diff --git a/utils/RADclass.py b/utils/RADclass.py
new file mode 100644
index 0000000..bfbdbaf
--- /dev/null
+++ b/utils/RADclass.py
@@ -0,0 +1,1619 @@
+# -*- coding: utf-8 -*-
+import code
+
+##
+# Copyright 2015 Telefónica Investigación y Desarrollo, S.A.U.
+# This file is part of openmano
+# All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+#
+# For those usages not covered by the Apache License, Version 2.0 please
+# contact with: nfvlabs@tid.es
+##
+
+'''
+Implement the logic for obtaining compute nodes information 
+Resource Availability Descriptor 
+'''
+__author__="Pablo Montes"
+
+#TODO: remove warnings, remove unused things 
+
+from definitionsClass import definitionsClass
+from auxiliary_functions import get_ssh_connection
+import libvirt
+from xml.etree import ElementTree
+import paramiko 
+import re
+import yaml
+
+
+def getCredentials(creds, data):
+    """Used as a backup for libvirt.openAuth in order to provide password that came with data,
+    not used by the moment
+    """
+    print "RADclass:getCredentials", creds, data
+    for cred in creds:
+        print cred[1] + ": ",
+        if cred[0] == libvirt.VIR_CRED_AUTHNAME:
+            cred[4] = data
+        elif cred[0] == libvirt.VIR_CRED_PASSPHRASE:
+            cred[4] = data
+        else:
+            return -1
+    return 0
+
+class RADclass():
+    def __init__(self):
+        self.name = None
+        self.machine = None
+        self.user = None
+        self.password = None
+        self.nodes = dict()                 #Dictionary of nodes. Keys are the node id, values are Node() elements
+        self.nr_processors = None           #Integer. Number of processors in the system 
+        self.processor_family = None        #If all nodes have the same value equal them, otherwise keep as None
+        self.processor_manufacturer = None  #If all nodes have the same value equal them, otherwise keep as None
+        self.processor_version = None       #If all nodes have the same value equal them, otherwise keep as None
+        self.processor_features = None      #If all nodes have the same value equal them, otherwise keep as None
+        self.memory_type = None             #If all nodes have the same value equal them, otherwise keep as None
+        self.memory_freq = None             #If all nodes have the same value equal them, otherwise keep as None
+        self.memory_nr_channels = None      #If all nodes have the same value equal them, otherwise keep as None
+        self.memory_size = None             #Integer. Sum of the memory in all nodes
+        self.memory_hugepage_sz = None
+        self.hypervisor = Hypervisor()      #Hypervisor information
+        self.os = OpSys()                   #Operating system information
+        self.ports_list = list()            #List containing all network ports in the node. This is used to avoid having defined multiple times the same port in the system
+    
+    
+    def obtain_RAD(self, user, password, machine):
+        """This function obtains the RAD information from the remote server.
+        It uses both a ssh and a libvirt connection. 
+        It is desirable in future versions get rid of the ssh connection, but currently 
+        libvirt does not provide all the needed information. 
+        Returns (True, Warning) in case of success and (False, <error>) in case of error"""
+        warning_text=""
+        try:
+            #Get virsh and ssh connection
+            (return_status, code) = get_ssh_connection(machine, user, password)
+            if not return_status:
+                print 'RADclass.obtain_RAD() error:', code
+                return (return_status, code)
+            ssh_conn = code
+            
+            self.connection_IP = machine
+            #print "libvirt open pre"
+            virsh_conn=libvirt.open("qemu+ssh://"+user+'@'+machine+"/system")
+            #virsh_conn=libvirt.openAuth("qemu+ssh://"+user+'@'+machine+"/system", 
+            #        [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_PASSPHRASE, libvirt.VIR_CRED_USERNAME], getCredentials, password],
+            #        0)
+            #print "libvirt open after"
+            
+    #         #Set connection infomation
+    #         (return_status, code) = self.set_connection_info(machine, user, password)
+    #         if not return_status:
+    #             return (return_status, 'Error in '+machine+': '+code)
+            
+            #Set server name
+            machine_name = get_hostname(virsh_conn)
+            (return_status, code) = self.set_name(machine_name)
+            if not return_status:
+                return (return_status, 'Error at self.set_name in '+machine+': '+code)
+            warning_text += code
+            
+            #Get the server processors information
+            processors = dict()
+            (return_status, code) = get_processor_information(ssh_conn, virsh_conn, processors)
+            if not return_status:
+                return (return_status, 'Error at get_processor_information in '+machine+': '+code)
+            warning_text += code
+            
+            #Get the server memory information
+            memory_nodes = dict()
+            (return_status, code) = get_memory_information(ssh_conn, virsh_conn, memory_nodes)
+            if not return_status:
+                return (return_status, 'Error at get_memory_information in '+machine+': '+code)
+            warning_text += code
+            
+            #Get nics information
+            nic_topology = dict()
+    #         (return_status, code) = get_nic_information_old(ssh_conn, nic_topology)
+            (return_status, code) = get_nic_information(ssh_conn, virsh_conn, nic_topology)
+            if not return_status:
+                return (return_status, 'Error at get_nic_information in '+machine+': '+code)
+            warning_text += code
+            
+            #Pack each processor, memory node  and nics in a node element
+            #and add the node to the RAD element
+            for socket_id, processor in processors.iteritems():
+                node = Node()
+                if not socket_id in nic_topology:
+                    nic_topology[socket_id] = list()
+                    
+                (return_status, code) = node.set(processor, memory_nodes[socket_id], nic_topology[socket_id])
+    #             else:
+    #                 (return_status, code) = node.set(processor, memory_nodes[socket_id])
+                if not return_status:
+                    return (return_status, 'Error at node.set in '+machine+': '+code)
+                warning_text += code
+                (return_status, code) = self.insert_node(node)
+                if not return_status:
+                    return (return_status, 'Error at self.insert_node in '+machine+': '+code)
+                if code not in warning_text:
+                    warning_text += code
+            
+            #Fill os data
+            os = OpSys()
+            (return_status, code) = get_os_information(ssh_conn, os)
+            if not return_status:
+                return (return_status, 'Error at get_os_information in '+machine+': '+code)
+            warning_text += code
+            (return_status, code) = self.set_os(os)
+            if not return_status:
+                return (return_status, 'Error at self.set_os in '+machine+': '+code)
+            warning_text += code
+            
+            #Fill hypervisor data
+            hypervisor = Hypervisor()
+            (return_status, code) = get_hypervisor_information(virsh_conn, hypervisor)
+            if not return_status:
+                return (return_status, 'Error at get_hypervisor_information in '+machine+': '+code)
+            warning_text += code
+            (return_status, code) = self.set_hypervisor(hypervisor)
+            if not return_status:
+                return (return_status, 'Error at self.set_hypervisor in '+machine+': '+code)
+            warning_text += code
+            ssh_conn.close()
+                
+            return (True, warning_text)
+        except libvirt.libvirtError, e:
+            text = e.get_error_message()
+            print 'RADclass.obtain_RAD() exception:', text
+            return (False, text)
+        except paramiko.ssh_exception.SSHException, e:
+            text = e.args[0]
+            print  "obtain_RAD ssh Exception:", text
+            return False, text
+
+    def set_name(self,name):
+        """Sets the machine name. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(name,str):
+            return (False, 'The variable \'name\' must be text')
+        self.name = name
+        return (True, "")
+    
+    def set_connection_info(self, machine, user, password):
+        """Sets the connection information. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(machine,str):
+            return (False, 'The variable \'machine\' must be text')
+        if not isinstance(user,str):
+            return (False, 'The variable \'user\' must be text')
+#         if not isinstance(password,str):
+#             return (False, 'The variable \'password\' must be text')
+        (self.machine, self.user, self.password) = (machine, user, password)
+        return (True, "")
+        
+    def insert_node(self,node):
+        """Inserts a new node and updates class variables. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(node,Node):
+            return (False, 'The variable \'node\' must be a Node element')
+        
+        if node.id_ in self.nodes:
+            return (False, 'The node is already present in the nodes list.')
+        
+        #Check if network ports have not been inserted previously as part of another node
+        for port_key in node.ports_list:
+            if port_key in self.ports_list:
+                return (False, 'Network port '+port_key+' defined multiple times in the system')
+            self.ports_list.append(port_key)
+        
+        #Insert the new node
+        self.nodes[node.id_] = node
+        
+        #update variables
+        self.update_variables()
+        
+        return (True, "")
+    
+    def update_variables(self):
+        """Updates class variables. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        warning_text=""
+        #The number of processors and nodes is the same
+        self.nr_processors = len(self.nodes)
+        
+        #If all processors are the same get the values. Otherwise keep them as none
+        prev_processor_family = prev_processor_manufacturer = prev_processor_version = prev_processor_features = None
+        different_processor_family = different_processor_manufacturer = different_processor_version = different_processor_features = False
+        for node in self.nodes.itervalues():
+            (self.processor_family, self.processor_manufacturer, self.processor_version, self.processor_features) = node.get_processor_info()
+            if prev_processor_family != None and self.processor_family != prev_processor_family:
+                different_processor_family = True
+            if prev_processor_manufacturer != None and self.processor_manufacturer != prev_processor_manufacturer:
+                different_processor_manufacturer = True
+            if prev_processor_version != None and self.processor_version != prev_processor_version:
+                different_processor_version = True
+            if prev_processor_features != None and self.processor_features != prev_processor_features:
+                different_processor_features = True
+            (prev_processor_family, prev_processor_manufacturer, prev_processor_version, prev_processor_features) = (self.processor_family, self.processor_manufacturer, self.processor_version, self.processor_features)
+
+        if different_processor_family:
+            self.processor_family = None
+        if different_processor_features:
+            self.processor_features = None
+        if different_processor_manufacturer:
+            self.processor_manufacturer = None
+        if different_processor_version:
+            self.processor_version = None
+            
+        #If all memory nodes are the same get the values. Otherwise keep them as none
+        #Sum the total memory
+        self.memory_size = 0
+        different_memory_freq = different_memory_nr_channels = different_memory_type = different_memory_hugepage_sz = False
+        prev_memory_freq = prev_memory_nr_channels = prev_memory_type = prev_memory_hugepage_sz = None
+        for node in self.nodes.itervalues():
+            (self.memory_freq, self.memory_nr_channels, self.memory_type, memory_size, self.memory_hugepage_sz) = node.get_memory_info()
+            self.memory_size += memory_size 
+            if prev_memory_freq != None and self.memory_freq != prev_memory_freq:
+                different_memory_freq = True
+            if prev_memory_nr_channels != None and self.memory_nr_channels != prev_memory_nr_channels:
+                different_memory_nr_channels = True
+            if prev_memory_type != None and self.memory_type != prev_memory_type:
+                different_memory_type = True
+            if prev_memory_hugepage_sz != None and self.memory_hugepage_sz != prev_memory_hugepage_sz:
+                different_memory_hugepage_sz = True
+            (prev_memory_freq, prev_memory_nr_channels, prev_memory_type, prev_memory_hugepage_sz) = (self.memory_freq, self.memory_nr_channels, self.memory_type, self.memory_hugepage_sz)
+            
+        if different_memory_freq:
+            self.memory_freq = None
+        if different_memory_nr_channels:
+            self.memory_nr_channels = None
+        if different_memory_type:
+            self.memory_type = None
+        if different_memory_hugepage_sz:
+            warning_text += 'Detected different hugepages size in different sockets\n'
+            
+        return (True, warning_text)
+        
+    def set_hypervisor(self,hypervisor):
+        """Sets the hypervisor. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(hypervisor,Hypervisor):
+            return (False, 'The variable \'hypervisor\' must be of class Hypervisor')
+        
+        self.hypervisor.assign(hypervisor) 
+        return (True, "")
+    
+    def set_os(self,os):
+        """Sets the operating system. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(os,OpSys):
+            return (False, 'The variable \'os\' must be of class OpSys')
+        
+        self.os.assign(os)
+        return (True, "")
+    
+    def to_text(self):
+        text= 'name: '+str(self.name)+'\n'
+        text+= 'processor:\n'
+        text+= '    nr_processors: '+str(self.nr_processors)+'\n' 
+        text+= '    family: '+str(self.processor_family)+'\n'
+        text+= '    manufacturer: '+str(self.processor_manufacturer)+'\n'
+        text+= '    version: '+str(self.processor_version)+'\n'
+        text+= '    features: '+str(self.processor_features)+'\n'
+        text+= 'memory:\n'
+        text+= '    type: '+str(self.memory_type)+'\n'
+        text+= '    freq: '+str(self.memory_freq)+'\n'
+        text+= '    nr_channels: '+str(self.memory_nr_channels)+'\n'
+        text+= '    size: '+str(self.memory_size)+'\n'
+        text+= 'hypervisor:\n'
+        text+= self.hypervisor.to_text()
+        text+= 'os:\n'
+        text+= self.os.to_text()
+        text+= 'resource topology:\n'
+        text+= '    nr_nodes: '+ str(len(self.nodes))+'\n'
+        text+= '    nodes:\n'
+        for node_k, node_v in self.nodes.iteritems():
+            text+= '        node'+str(node_k)+':\n'
+            text+= node_v.to_text()
+        return text
+    
+    def to_yaml(self):
+        return yaml.load(self.to_text())
+    
+class Node():
+    def __init__(self):
+        self.id_ = None                      #Integer. Node id. Unique in the system
+        self.processor = ProcessorNode()    #Information about the processor in the node
+        self.memory = MemoryNode()          #Information about the memory in the node
+        self.nic_list = list()              #List of Nic() containing information about the nics associated to the node
+        self.ports_list = list()            #List containing all network ports in the node. This is used to avoid having defined multiple times the same port in the system
+        
+    def get_processor_info(self):
+        """Gets the processor information. Returns (processor_family, processor_manufacturer, processor_version, processor_features)"""
+        return self.processor.get_info()
+        
+    def get_memory_info(self):
+        """Gets the memory information. Returns (memory_freq, memory_nr_channels, memory_type, memory_size)"""
+        return self.memory.get_info()
+    
+#     def set(self, *args):
+#         """Sets the node information. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+#         if len(args)==2:
+#             processor = args[0]
+#             memory = args[1]
+#             nics = False
+#         elif len(args)==3:
+#             processor = args[0]
+#             memory = args[1]
+#             nic_list = args[2]
+#             nics = True
+#         else:
+#             return (False, 'Wrong number of elements calling Node().set()')
+
+    def set(self, processor, memory, nic_list):
+        (status, return_code) = self.processor.assign(processor)
+        if not status:
+            return (status, return_code)
+        
+        self.id_ = processor.id_
+        
+        (status, return_code) = self.memory.assign(memory)
+        if not status:
+            return (status, return_code)
+        
+#         if nics:
+        for nic in nic_list:
+            if not isinstance(nic,Nic):
+                return (False, 'The nics must be of type Nic')
+            self.nic_list.append(nic)
+            for port_key in nic.ports.iterkeys():
+                if port_key in self.ports_list:
+                    return (False, 'Network port '+port_key+'defined multiple times in the same node')
+                self.ports_list.append(port_key)
+            
+        return (True,"")
+   
+    def assign(self, node):
+        """Sets the node information. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        warning_text=""
+        processor = node.processor
+        memory = node.memory
+        nic_list = node.nic_list
+        (status, return_code) = self.processor.assign(processor)
+        if not status:
+            return (status, return_code)
+        
+        self.id_ = processor.id_
+        
+        (status, return_code) = self.memory.assign(memory)
+        if not status:
+            return (status, return_code)
+        warning_text += code
+        
+        for nic in nic_list:
+            if not isinstance(nic,Nic):
+                return (False, 'The nics must be of type Nic')
+            self.nic_list.append(nic)
+            for port_key in nic.ports.iterkeys():
+                if port_key in self.ports_list:
+                    return (False, 'Network port '+port_key+'defined multiple times in the same node')
+                self.ports_list.append(port_key)
+            
+        return (True,warning_text)
+   
+    def to_text(self):
+        text= '            id: '+str(self.id_)+'\n'
+        text+= '            cpu:\n'
+        text += self.processor.to_text()
+        text+= '            memory:\n'
+        text += self.memory.to_text()
+        if len(self.nic_list) > 0:
+            text+= '            nics:\n'
+            nic_index = 0
+            for nic in self.nic_list:
+                text+= '                nic '+str(nic_index)+':\n'
+                text += nic.to_text()
+                nic_index += 1
+        return text
+    
+class ProcessorNode():
+    #Definition of the possible values of processor variables
+    possible_features = definitionsClass.processor_possible_features
+    possible_manufacturers = definitionsClass.processor_possible_manufacturers
+    possible_families = definitionsClass.processor_possible_families
+    possible_versions = definitionsClass.processor_possible_versions
+    
+    def __init__(self):
+        self.id_ = None              #Integer. Numeric identifier of the socket
+        self.family = None          #Text. Family name of the processor
+        self.manufacturer = None    #Text. Manufacturer of the processor
+        self.version = None         #Text. Model version of the processor
+        self.features = list()      #list. List of features offered by the processor
+        self.cores = list()         #list. List of cores in the processor. In case of hyperthreading the coupled cores are expressed as [a,b]
+        self.eligible_cores = list()#list. List of cores that can be used
+        #self.decicated_cores
+        #self.shared_cores -> this should also contain information to know if cores are being used
+        
+    def assign(self, processor):
+        """Sets the processor information. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(processor,ProcessorNode):
+            return (False, 'The variable \'processor\' must be of class ProcessorNode')
+        
+        self.id_ = processor.id_
+        self.family = processor.family
+        self.manufacturer = processor.manufacturer
+        self.version = processor.version
+        self.features = processor.features
+        self.cores = processor.cores
+        self.eligible_cores = processor.eligible_cores
+        
+        return (True, "")
+    
+    def set(self, id_, family, manufacturer, version, features, cores):
+        """Sets the processor information. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        warning_text = ""
+
+        if not isinstance(id_,int):
+            return (False, 'The processor id_ must be of type int')  
+        if not isinstance(family,str):
+            return (False, 'The processor family must be of type str')
+        if not isinstance(manufacturer,str):
+            return (False, 'The processor manufacturer must be of type str')
+        if not isinstance(version,str):
+            return (False, 'The processor version must be of type str')        
+        if not isinstance(features,list):
+            return (False, 'The processor features must be of type list')
+        if not isinstance(cores,list):
+            return (False, 'The processor cores must be of type list')
+ 
+        (self.id_, self.family, self.manufacturer, self.version) = (id_, family, manufacturer, version)
+ 
+        if not manufacturer in self.possible_manufacturers:
+            warning_text += "processor manufacturer '%s' not among: %s\n" %(manufacturer, str(self.possible_manufacturers))     
+        if not family in self.possible_families:
+            warning_text += "family '%s' not among: %s\n" % (family, str(self.possible_families))
+#        if not version in self.possible_versions:
+#            warning_text += 'The version %s is not one of these: %s\n' % (version, str(self.possible_versions))
+        
+        for feature in features:
+            if not feature in self.possible_features:
+                warning_text += "processor feature '%s' not among: %s\n" % (feature, str(self.possible_versions))
+            self.features.append(feature)
+        
+        for iterator in sorted(cores):
+            if not isinstance(iterator,list) or not all(isinstance(x, int) for x in iterator):
+                return (False, 'The cores list must be in the form of [[a,b],[c,d],...] where a,b,c,d are of type int')
+            self.cores.append(iterator)
+        
+        self.set_eligible_cores()
+        
+        return (True,warning_text)
+           
+    def set_eligible_cores(self):
+        """Set the default eligible cores, this is all cores non used by the host operating system"""
+        not_first = False
+        for iterator in self.cores:
+            if not_first:
+                self.eligible_cores.append(iterator)
+            else:
+                not_first = True                
+        return
+    
+    def get_info(self):
+        """Returns processor parameters (self.family, self.manufacturer, self.version, self.features)"""
+        return (self.family, self.manufacturer, self.version, self.features)
+    
+    def to_text(self):
+        text= '                id: '+str(self.id_)+'\n'
+        text+= '                family: '+self.family+'\n'
+        text+= '                manufacturer: '+self.manufacturer+'\n'
+        text+= '                version: '+self.version+'\n'
+        text+= '                features: '+str(self.features)+'\n'
+        text+= '                cores: '+str(self.cores)+'\n'
+        text+= '                eligible_cores: '+str(self.eligible_cores)+'\n'
+        return text
+    
+class MemoryNode():
+    def __init__(self):
+        self.modules = list()               #List of MemoryModule(). List of all modules installed in the node
+        self.nr_channels = None             #Integer. Number of modules installed in the node
+        self.node_size = None               #Integer. Total size in KiB of memory installed in the node
+        self.eligible_memory = None         #Integer. Size in KiB of eligible memory in the node     
+        self.hugepage_sz = None             #Integer. Size in KiB of hugepages
+        self.hugepage_nr = None             #Integer. Number of hugepages allocated in the module
+        self.eligible_hugepage_nr = None    #Integer. Number of eligible hugepages in the node
+        self.type_ = None                    #Text. Type of memory modules. If modules have a different value keep it as None
+        self.freq = None                    #Integer. Frequency of the modules in MHz. If modules have a different value keep it as None
+        self.module_size = None             #Integer. Size of the modules in KiB. If modules have a different value keep it as None
+        self.form_factor = None             #Text. Form factor of the modules. If modules have a different value keep it as None
+       
+    def assign(self, memory_node):
+        return self.set(memory_node.modules, memory_node.hugepage_sz, memory_node.hugepage_nr)
+         
+    def set(self, modules, hugepage_sz, hugepage_nr):
+        """Set the memory node information. hugepage_sz must be expressed in KiB. 
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(modules, list):
+            return (False, 'The modules must be a list of elements of class MemoryModule')
+        if not isinstance(hugepage_sz,int):
+            return (False, 'The hugepage_sz variable must be an int expressing the size in KiB')
+        if not isinstance(hugepage_nr,int):
+            return (False, 'The hugepage_nr variable must be of type int')
+        
+        (self.hugepage_sz, self.hugepage_nr) = (hugepage_sz, hugepage_nr)
+        self.node_size = self.nr_channels = 0
+        
+        different_type = different_freq = different_module_size = different_form_factor = False
+        prev_type = prev_freq = prev_module_size = prev_form_factor = None
+        for iterator in modules:
+            if not isinstance(iterator,MemoryModule):
+                return (False, 'The modules must be a list of elements of class MemoryModule')
+            self.modules.append(iterator)
+            (self.type_, self.freq, self.module_size, self.form_factor) = (iterator.type_, iterator.freq, iterator.size, iterator.form_factor)
+            self.node_size += self.module_size
+            self.nr_channels += 1
+            if prev_type != None and prev_type != self.type_:
+                different_type = True
+            if prev_freq != None and prev_freq != self.freq:
+                different_freq = True
+            if prev_module_size != None and prev_module_size != self.module_size:
+                different_module_size = True
+            if prev_form_factor != None and prev_form_factor != self.form_factor:
+                different_form_factor = True
+            (prev_type, prev_freq, prev_module_size, prev_form_factor) = (self.type_, self.freq, self.module_size, self.form_factor)
+        
+        if different_type:
+            self.type_ = None
+        if different_freq:
+            self.freq = None
+        if different_module_size:
+            self.module_size = None
+        if different_form_factor:
+            self.form_factor = None
+        
+        (return_value, error_code) = self.set_eligible_memory()
+        if not return_value:
+            return (return_value, error_code)
+        
+        return (True, "")
+    
+    def set_eligible_memory(self):
+        """Sets the default eligible_memory and eligible_hugepage_nr. This is all memory but 2GiB and all hugepages"""
+        self.eligible_memory = self.node_size - 2*1024*1024
+        if self.eligible_memory < 0:
+            return (False, "There is less than 2GiB of memory in the module")
+        
+        self.eligible_hugepage_nr = self.hugepage_nr 
+        return (True,"")
+    
+    def get_info(self):
+        """Return memory information (self.freq, self.nr_channels, self.type_, self.node_size)"""
+        return (self.freq, self.nr_channels, self.type_, self.node_size, self.hugepage_sz)
+        
+    def to_text(self):
+        text= '                node_size: '+str(self.node_size)+'\n'
+        text+= '                nr_channels: '+str(self.nr_channels)+'\n'
+        text+= '                eligible_memory: '+str(self.eligible_memory)+'\n'
+        text+= '                hugepage_sz: '+str(self.hugepage_sz)+'\n'
+        text+= '                hugepage_nr: '+str(self.hugepage_nr)+'\n'
+        text+= '                eligible_hugepage_nr: '+str(self.eligible_hugepage_nr)+'\n'
+        text+= '                type: '+self.type_+'\n'
+        text+= '                freq: '+str(self.freq)+'\n'
+        text+= '                module_size: '+str(self.module_size)+'\n'
+        text+= '                form_factor: '+self.form_factor+'\n'
+        text+= '                modules details:\n'
+        for module in self.modules:
+            text += module.to_text()
+        return text
+        
+class MemoryModule():
+    #Definition of the possible values of module variables
+    possible_types = definitionsClass.memory_possible_types
+    possible_form_factors = definitionsClass.memory_possible_form_factors
+    
+    def __init__(self):
+        self.locator = None     #Text. Name of the memory module
+        self.type_ = None        #Text. Type of memory module
+        self.freq = None        #Integer. Frequency of the module in MHz
+        self.size = None        #Integer. Size of the module in KiB
+        self.form_factor = None #Text. Form factor of the module
+        
+    def set(self, locator, type_, freq, size, form_factor):
+        """Sets the memory module information. 
+        Frequency must be expressed in MHz and size in KiB.
+        Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        warning_text=""
+        if not isinstance(locator, str):
+            return (False, "The type of the variable locator must be str")
+        if not isinstance(type_, str):
+            return (False, "The type of the variable type_ must be str")
+        if not isinstance(form_factor, str):
+            return (False, "The type of the variable form_factor must be str")
+        if not isinstance(freq, int):
+            return (False, "The type of the variable freq must be int")
+        if not isinstance(size, int):
+            return (False, "The type of the variable size must be int")
+        
+        if not form_factor in self.possible_form_factors:
+            warning_text += "memory form_factor '%s' not among: %s\n" %(form_factor, str(self.possible_form_factors))
+        if not type_ in self.possible_types:
+            warning_text += "memory type '%s' not among: %s\n" %(type_, str(self.possible_types))
+        
+        (self.locator, self.type_, self.freq, self.size, self.form_factor) = (locator, type_, freq, size, form_factor)
+        return (True, warning_text)   
+    
+    def to_text(self):
+        text= '                    '+self.locator+':\n'
+        text+= '                        type: '+self.type_+'\n'
+        text+= '                        freq: '+str(self.freq)+'\n'
+        text+= '                        size: '+str(self.size)+'\n'
+        text+= '                        form factor: '+self.form_factor+'\n'
+        return text
+         
+class Nic():
+    def __init__(self):
+        self.model = None       #Text. Model of the nic
+        self.ports = dict()     #Dictionary of ports. Keys are the port name, value are Port() elements
+    
+    def set_model(self, model):
+        """Sets the model of the nic. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(model,str):
+            return (False, 'The \'model\' must be of type str')
+           
+        self.model = model
+        return (True, "")
+   
+    def add_port(self, port):
+        """Adds a port to the nic. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+        if not isinstance(port,Port):
+            return (False, 'The \'port\' must be of class Port')
+       
+#        port_id = str(port.pci_device_id[0])+':'+str(port.pci_device_id[1])+':'+str(port.pci_device_id[2])+'.'+str(port.pci_device_id[3])
+#CHANGED
+#        port_id = port.name
+        port_id = port.pci_device_id
+#CHANGED END 
+        if port_id in self.ports:
+            return (False, 'The \'port\' '+port.pci_device_id+' is duplicated in the nic')
+#             return (False, 'The \'port\' is duplicated in the nic')
+       
+        self.ports[port_id] = port
+        return (True, "")
+   
+    def to_text(self):
+        text= '                    model: '+ str(self.model)+'\n'
+        text+= '                    ports: '+'\n'
+        for key,port in self.ports.iteritems():
+            text+= '                        "'+key+'":'+'\n'
+            text += port.to_text()
+        return text
+               
+class Port():
+    def __init__(self):
+        self.name = None            #Text. Port name
+        self.virtual = None         #Boolean. States if the port is a virtual function
+        self.enabled = None         #Boolean. States if the port is enabled
+        self.eligible = None        #Boolean. States if the port is eligible
+        self.speed = None           #Integer. Indicates the speed in Mbps
+        self.available_bw = None    #Integer. BW in Mbps that is available.
+        self.mac = None             #list. Indicates the mac address of the port as a list in format ['XX','XX','XX','XX','XX','XX']
+        self.pci_device_id_split = None   #list. Indicates the pci address  of the port as a list in format ['XXXX','XX','XX','X']
+        self.pci_device_id = None
+        self.PF_pci_device_id = None
+        
+#     def set(self, name, virtual, enabled, speed, mac, pci_device_id, pci_device_id_split):
+#         """Sets the port information. The variable speed indicates the speed in Mbps. Returns (True,Warning) in case of success and ('False',<error description>) in case of error"""
+#         if not isinstance(name,str):
+#             return (False, 'The variable \'name\' must be of type str')
+#         if not isinstance(virtual,bool):
+#             return (False, 'The variable \'virtual\' must be of type bool')
+#         if not isinstance(enabled,bool):
+#             return (False, 'The variable \'enabled\' must be of type bool')
+#         if not isinstance(enabled,bool):
+#             return (speed, 'The variable \'speed\' must be of type int')
+#         if not isinstance(mac, list) and not isinstance(mac,NoneType):
+#             return (False, 'The variable \'enabled\' must be of type list indicating the mac address in format [\'XXXX\',\'XX\',\'XX\',\'X\'] or NoneType')
+#         if not isinstance(pci_device_id_split, list) or len(pci_device_id_split) != 4: 
+#             return (False, 'The variable \'pci_device_id_split\' must be of type list, indicating the pci address in format [\'XX\',\'XX\',\'XX\',\'XX\',\'XX\',\'XX\']')
+#         
+#         expected_len = [4,2,2,1]
+#         index = 0
+#         for iterator in pci_device_id_split:
+#             if not isinstance(iterator,str) or not iterator.isdigit() or len(iterator) != expected_len[index]:
+#                 return (False, 'The variable \'pci_device_id_split\' must be of type list, indicating the pci address in format [\'XX\',\'XX\',\'XX\',\'XX\',\'XX\',\'XX\']')
+#             index += 1
+#             
+#         if not isinstance(mac,NoneType):
+#             for iterator in mac:
+#                 if not isinstance(iterator,str) or not iterator.isalnum() or len(iterator) != 2:
+#                     return (False, 'The variable \'enabled\' must be of type list indicating the mac address in format [\'XXXX\',\'XX\',\'XX\',\'X\'] or NoneType')
+#         
+#         #By default only virtual ports are eligible
+# #         (self.name, self.virtual, self.enabled, self.eligible, self.available_bw, self.speed, self.mac, self.pci_device_id, self.pci_device_id_split) = (name, virtual, enabled, virtual, speed, speed, mac, pci_device_id, pci_device_id_split)
+#         (self.name, self.virtual, self.enabled, self.eligible, self.available_bw, self.mac, self.pci_device_id, self.pci_device_id_split) = (name, virtual, enabled, virtual, speed, mac, pci_device_id, pci_device_id_split)
+
+    def to_text(self):
+        text= '                            pci: "'+ str(self.pci_device_id)+'"\n'
+        text+= '                            virtual: '+ str(self.virtual)+'\n'
+        if self.virtual:
+            text+= '                            PF_pci_id: "'+self.PF_pci_device_id+'"\n'
+        text+= '                            eligible: '+ str(self.eligible)+'\n'
+        text+= '                            enabled: '+str(self.enabled)+'\n'
+        text+= '                            speed: '+ str(self.speed)+'\n'
+        text+= '                            available bw: '+ str(self.available_bw)+'\n'
+        text+= '                            mac: '+ str(self.mac)+'\n'
+        text+= '                            source_name: '+ str(self.name)+'\n'
+        return text
+    
+class Hypervisor():
+    #Definition of the possible values of hypervisor variables
+    possible_types = definitionsClass.hypervisor_possible_types
+    possible_domain_types = definitionsClass.hypervisor_possible_domain_types
+
+    def __init__(self):
+        self.type_ = None            #Text. Hypervisor type_
+        self.version = None         #int. Hypervisor version
+        self.lib_version = None     #int. Libvirt version used to compile hypervisor
+        self.domains = list()       #list. List of all the available domains
+        
+    def set(self, hypervisor, version, lib_version, domains):
+        warning_text=""
+        if not isinstance(hypervisor,str):
+            return (False, 'The variable type_ must be of type str')
+        if not isinstance(version,int):
+            return (False, 'The variable version must be of type int')
+        if not isinstance(lib_version,int):
+            return (False, 'The library version must be of type int')
+        if not isinstance(domains,list):
+            return (False, 'Domains must be a list of the possible domains as str')
+        
+        if not hypervisor in self.possible_types:
+            warning_text += "Hyperpivor '%s' not among: %s\n" % (hypervisor, str(self.possible_types))
+        
+        valid_domain_found = False
+        for domain in domains:
+            if not isinstance(domain,str):
+                return (False, 'Domains must be a list of the possible domains as str')
+            if domain in self.possible_domain_types:
+                valid_domain_found = True
+                self.domains.append(domain)
+                
+        if not valid_domain_found:
+            warning_text += 'No valid domain found among: %s\n' % str(self.possible_domain_types)
+            
+        
+        (self.version, self.lib_version, self.type_) = (version, lib_version, hypervisor)
+        return (True, warning_text)
+     
+    def assign(self, hypervisor):
+        (self.version, self.lib_version, self.type_) = (hypervisor.version, hypervisor.lib_version, hypervisor.type_)
+        for domain in hypervisor.domains:
+            self.domains.append(domain)
+        return
+           
+    def to_text(self):
+        text= '    type: '+self.type_+'\n'
+        text+= '    version: '+str(self.version)+'\n'
+        text+= '    libvirt version: '+ str(self.lib_version)+'\n'
+        text+= '    domains: '+str(self.domains)+'\n'
+        return text
+        
+class OpSys():
+    #Definition of the possible values of os variables
+    possible_id = definitionsClass.os_possible_id
+    possible_types = definitionsClass.os_possible_types
+    possible_architectures = definitionsClass.os_possible_architectures
+
+    def __init__(self):
+        self.id_ = None                   #Text. Identifier of the OS. Formed by <Distibutor ID>-<Release>-<Codename>. In linux this can be obtained using lsb_release -a
+        self.type_ = None                 #Text. Type of operating system
+        self.bit_architecture = None     #Integer. Architecture
+        
+    def set(self, id_, type_, bit_architecture):
+        warning_text=""
+        if not isinstance(type_,str):
+            return (False, 'The variable type_ must be of type str')
+        if not isinstance(id_,str):
+            return (False, 'The variable id_ must be of type str')
+        if not isinstance(bit_architecture,str):
+            return (False, 'The variable bit_architecture must be of type str')
+        
+        if not type_ in self.possible_types:
+            warning_text += "os type '%s' not among: %s\n" %(type_, str(self.possible_types))
+        if not id_ in self.possible_id:
+            warning_text += "os release '%s' not among: %s\n" %(id_, str(self.possible_id))
+        if not bit_architecture in self.possible_architectures:
+            warning_text += "os bit_architecture '%s' not among: %s\n" % (bit_architecture, str(self.possible_architectures))
+        
+        (self.id_, self.type_, self.bit_architecture) = (id_, type_, bit_architecture)
+        return (True, warning_text)
+    
+    def assign(self,os):
+        (self.id_, self.type_, self.bit_architecture) = (os.id_, os.type_, os.bit_architecture)
+        return
+    
+    def to_text(self):
+        text= '    id: '+self.id_+'\n'
+        text+= '    type: '+self.type_+'\n'
+        text+= '    bit_architecture: '+self.bit_architecture+'\n'
+        return text
+     
+def get_hostname(virsh_conn):
+    return virsh_conn.getHostname().rstrip('\n')
+
+def get_hugepage_size(ssh_conn):
+    command = 'sudo hugeadm --page-sizes'
+#  command = 'hugeadm --page-sizes-all'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    mem=stdout.read()
+    if mem=="":
+        return 0
+    return int(mem)
+
+def get_hugepage_nr(ssh_conn,hugepage_sz, node_id):
+    command = 'cat /sys/devices/system/node/node'+str(node_id)+'/hugepages/hugepages-'+str(hugepage_sz/1024)+'kB/nr_hugepages'
+    (_, stdout, _) = ssh_conn.exec_command(command)
+    #print command, 
+    #text = stdout.read()
+    #print "'"+text+"'"
+    #return int(text)
+    
+    try:
+        value=int(stdout.read())
+    except: 
+        value=0
+    return value
+
+def get_memory_information(ssh_conn, virsh_conn, memory_nodes):
+    warning_text=""
+    tree=ElementTree.fromstring(virsh_conn.getSysinfo(0))
+    memory_dict = dict()
+    node_id = 0 #TODO revise. Added for allowing VM as compute hosts 
+    for target in tree.findall("memory_device"):
+        locator_f = size_f = freq_f = type_f = formfactor_f = False
+        locator_f = True #TODO revise. Added for allowing VM as compute hosts
+        module_form_factor = ""
+        for entry in target.findall("entry"):
+            if entry.get("name") == 'size':
+                size_f = True
+                size_split = entry.text.split(' ')
+                if size_split[1] == 'MB':
+                    module_size = int(size_split[0]) * 1024 * 1024
+                elif size_split[1] == 'GB':
+                    module_size = int(size_split[0]) * 1024 * 1024 * 1024
+                elif size_split[1] == 'KB':
+                    module_size = int(size_split[0]) * 1024
+                else:
+                    module_size = int(size_split[0])
+                
+            elif entry.get("name") == 'speed':
+                freq_f = True
+                freq_split = entry.text.split(' ')
+                if freq_split[1] == 'MHz':
+                    module_freq = int(freq_split[0]) * 1024 * 1024
+                elif freq_split[1] == 'GHz':
+                    module_freq = int(freq_split[0]) * 1024 * 1024 * 1024
+                elif freq_split[1] == 'KHz':
+                    module_freq = int(freq_split[0]) * 1024
+            
+            elif entry.get("name") == 'type':
+                type_f = True
+                module_type = entry.text
+                   
+            elif entry.get("name") == 'form_factor':
+                formfactor_f = True
+                module_form_factor = entry.text  
+            #TODO revise. Commented for allowing VM as compute hosts
+            # elif entry.get("name") == 'locator' and not locator_f:
+            #     # other case, it is obtained by bank_locator that we give priority to
+            #     locator = entry.text
+            #     pos = locator.find(module_form_factor)
+            #     if module_form_factor == locator[0:len(module_form_factor) ]:
+            #         pos = len(module_form_factor) +1 
+            #     else:
+            #         pos = 0
+            #     if locator[pos] in "ABCDEFGH":  
+            #         locator_f = True
+            #         node_id = ord(locator[pos])-ord('A')
+            #         #print entry.text, node_id
+            # 
+            # elif entry.get("name") == 'bank_locator':
+            #     locator = entry.text
+            #     pos = locator.find("NODE ")
+            #     if pos >= 0 and len(locator)>pos+5:
+            #         if locator[pos+5] in ("01234567"): #len("NODE ") is 5
+            #             node_id = int(locator[pos+5])
+            #             locator_f = True
+            #  
+
+        #When all module fields have been found add a new module to the list 
+        if locator_f and size_f and freq_f and type_f and formfactor_f:
+            #If the memory node has not yet been created create it
+            if node_id not in memory_dict:
+                memory_dict[node_id] = []
+                
+            #Add a new module to the memory node
+            module = MemoryModule()
+            #TODO revise. Changed for allowing VM as compute hosts
+            (return_status, code) = module.set('NODE %d' % node_id, module_type, module_freq, module_size, module_form_factor)
+            #(return_status, code) = module.set(locator, module_type, module_freq, module_size, module_form_factor)
+            if not return_status:
+                return (return_status, code)
+            memory_dict[node_id].append(module)
+            if code not in warning_text:
+                warning_text += code
+            node_id += 1 #TODO revise. Added for allowing VM as compute hosts
+    
+    #Fill memory nodes
+    #Hugepage size is constant for all nodes
+    hugepage_sz = get_hugepage_size(ssh_conn)
+    for node_id, modules in memory_dict.iteritems():
+        memory_node = MemoryNode()
+        memory_node.set(modules, hugepage_sz, get_hugepage_nr(ssh_conn,hugepage_sz, node_id))
+        memory_nodes[node_id] = memory_node
+        
+    return (True, warning_text)
+
+def get_cpu_topology_ht(ssh_conn, topology):
+    command = 'cat /proc/cpuinfo'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    sockets = []
+    cores = []
+    core_map = {}
+    core_details = []
+    core_lines = {}
+    for line in stdout.readlines():
+        if len(line.strip()) != 0:
+            name, value = line.split(":", 1)
+            core_lines[name.strip()] = value.strip()
+        else:
+            core_details.append(core_lines)
+            core_lines = {}
+    
+    for core in core_details:
+        for field in ["processor", "core id", "physical id"]:
+            if field not in core:
+                return(False,'Error getting '+field+' value from /proc/cpuinfo')
+            core[field] = int(core[field])
+    
+        if core["core id"] not in cores:
+            cores.append(core["core id"])
+        if core["physical id"] not in sockets:
+            sockets.append(core["physical id"])
+        key = (core["physical id"], core["core id"])
+        if key not in core_map:
+            core_map[key] = []
+        core_map[key].append(core["processor"])
+      
+    for s in sockets:
+        hyperthreaded_cores = list()
+        for c in cores:
+            hyperthreaded_cores.append(core_map[(s,c)])
+        topology[s] = hyperthreaded_cores
+      
+    return (True, "")
+
+def get_processor_information(ssh_conn, vish_conn, processors):
+    warning_text=""
+    #Processor features are the same for all processors
+    #TODO (at least using virsh capabilities)nr_numa_nodes
+    capabilities = list()
+    tree=ElementTree.fromstring(vish_conn.getCapabilities())
+    for target in tree.findall("host/cpu/feature"):
+        if target.get("name") == 'pdpe1gb':
+            capabilities.append('lps')
+        elif target.get("name") == 'dca':
+            capabilities.append('dioc')  
+        elif target.get("name") == 'vmx' or target.get("name") == 'svm':
+            capabilities.append('hwsv')
+        elif target.get("name") == 'ht':
+            capabilities.append('ht')
+        
+    target = tree.find("host/cpu/arch")
+    if target.text == 'x86_64' or target.text == 'amd64':
+        capabilities.append('64b')
+      
+    command = 'cat /proc/cpuinfo | grep flags'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    line = stdout.readline()
+    if 'ept' in line or 'npt' in line:
+        capabilities.append('tlbps')
+    
+    #Find out if IOMMU is enabled
+    command = 'dmesg |grep -e Intel-IOMMU'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    if 'enabled' in stdout.read():
+        capabilities.append('iommu')
+      
+    #Equivalent for AMD
+    command = 'dmesg |grep -e AMD-Vi'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    if len(stdout.read()) > 0:
+        capabilities.append('iommu')
+    
+    #-----------------------------------------------------------
+    topology = dict()
+    #In case hyperthreading is active it is necessary to determine cpu topology using /proc/cpuinfo
+    if 'ht' in capabilities:
+        (return_status, code) = get_cpu_topology_ht(ssh_conn, topology)
+        if not return_status:
+            return (return_status, code)
+        warning_text += code
+
+    #Otherwise it is possible to do it using virsh capabilities
+    else:
+        for target in tree.findall("host/topology/cells/cell"):
+            socket_id = int(target.get("id"))
+            topology[socket_id] = list()
+            for cpu in target.findall("cpus/cpu"):
+                topology[socket_id].append(int(cpu.get("id")))
+    
+    #-----------------------------------------------------------         
+    #Create a dictionary with the information of all processors
+    #p_fam = p_man = p_ver = None
+    tree=ElementTree.fromstring(vish_conn.getSysinfo(0))
+    #print vish_conn.getSysinfo(0)
+    #return (False, 'forces error for debuging')
+    not_populated=False
+    socket_id = -1     #in case we can not determine the socket_id we assume incremental order, starting by 0
+    for target in tree.findall("processor"):
+        count = 0
+        socket_id += 1
+        #Get processor id, family, manufacturer and version
+        for entry in target.findall("entry"):
+            if entry.get("name") == "status":
+                if entry.text[0:11] == "Unpopulated":
+                    not_populated=True
+            elif entry.get("name") == 'socket_destination':
+                socket_text = entry.text
+                if socket_text.startswith('CPU'):
+                    socket_text = socket_text.strip('CPU')
+                    socket_text = socket_text.strip() #removes trailing spaces
+                    if socket_text.isdigit() and int(socket_text)<9 and int(socket_text)>0:
+                        socket_id = int(socket_text) - 1
+              
+            elif entry.get("name") == 'family':
+                family = entry.text
+                count += 1
+            elif entry.get("name") == 'manufacturer':
+                manufacturer = entry.text
+                count += 1
+            elif entry.get("name") == 'version':
+                version = entry.text.strip()
+                count += 1
+        if count != 3:
+            return (False, 'Error. Not all expected fields could be found in processor')
+        
+        #Create and fill processor structure
+        if not_populated:
+            continue  #avoid inconsistence of some machines where more socket detected than 
+        processor = ProcessorNode()
+        (return_status, code) = processor.set(socket_id, family, manufacturer, version, capabilities, topology[socket_id])
+        if not return_status:
+            return (return_status, code)
+        if code not in warning_text:
+            warning_text += code
+
+        #Add processor to the processors dictionary
+        processors[socket_id] = processor
+    
+    return (True, warning_text)
+
+def get_nic_information(ssh_conn, virsh_conn, nic_topology):   
+    warning_text=""
+    #Get list of net devices
+    net_devices = virsh_conn.listDevices('net',0)
+    print virsh_conn.listDevices('net',0)
+    for device in net_devices:
+        try:
+            #Get the XML descriptor of the device:
+            net_XML = ElementTree.fromstring(virsh_conn.nodeDeviceLookupByName(device).XMLDesc(0))
+            #print "net_XML:" , net_XML
+            #obtain the parent
+            parent = net_XML.find('parent')
+            if parent == None:
+                print 'No parent was found in XML for device '+device
+                #Error. continue?-------------------------------------------------------------
+                continue
+            if parent.text == 'computer':
+                continue
+            if not parent.text.startswith('pci_'):
+                print device + ' parent is neither computer nor pci'
+                #Error. continue?-------------------------------------------------------------
+                continue
+            interface = net_XML.find('capability/interface').text
+            mac = net_XML.find('capability/address').text
+            
+            #Get the pci XML
+            pci_XML = ElementTree.fromstring(virsh_conn.nodeDeviceLookupByName(parent.text).XMLDesc(0))
+            #print pci_XML
+            #Get pci
+            name = pci_XML.find('name').text.split('_')
+            pci = name[1]+':'+name[2]+':'+name[3]+'.'+name[4]
+            
+            #If slot == 0 it is a PF, otherwise it is a VF
+            capability = pci_XML.find('capability')
+            if capability.get('type') != 'pci':
+                print device + 'Capability is not of type pci in '+parent.text
+                #Error. continue?-------------------------------------------------------------
+                continue
+            slot = capability.find('slot').text
+            bus = capability.find('bus').text
+            node_id = None
+            numa_ = capability.find('numa')
+            if numa_ != None:
+                node_id = numa_.get('node');
+                if node_id != None: node_id =int(node_id)
+            if slot == None or bus == None:
+                print device + 'Bus and slot not detected in '+parent.text
+                #Error. continue?-------------------------------------------------------------
+                continue
+            if slot != '0':
+    #             print ElementTree.tostring(pci_XML)
+                virtual = True
+                capability_pf = capability.find('capability')
+                if capability_pf.get('type') != 'phys_function':
+                    print 'physical_function not found in VF '+parent.text
+                    #Error. continue?-------------------------------------------------------------
+                    continue
+                PF_pci = capability_pf.find('address').attrib
+                PF_pci_text = PF_pci['domain'].split('x')[1]+':'+PF_pci['bus'].split('x')[1]+':'+PF_pci['slot'].split('x')[1]+'.'+PF_pci['function'].split('x')[1]
+                
+            else:
+                virtual = False
+            
+            #Obtain node for the port
+            if node_id == None:
+                node_id = int(bus)>>6
+            #print "node_id:", node_id
+            
+            #Only for non virtual interfaces: Obtain speed and if link is detected (this must be done using ethtool)
+            if not virtual:
+                command = 'sudo ethtool '+interface+' | grep -e Speed -e "Link detected"'
+                (_, stdout, stderr) = ssh_conn.exec_command(command)
+                error = stderr.read()
+                if len(error) >0:
+                    print 'Error running '+command+'\n'+error
+                    #Error. continue?-------------------------------------------------------------
+                    continue
+                for line in stdout.readlines():
+                    line = line.strip().rstrip('\n').split(': ')
+                    if line[0] == 'Speed':
+                        if line[1].endswith('Mb/s'):
+                            speed = int(line[1].split('M')[0])*int(1e6)
+                        elif line[1].endswith('Gb/s'):
+                            speed = int(line[1].split('G')[0])*int(1e9)
+                        elif line[1].endswith('Kb/s'):
+                            speed = int(line[1].split('K')[0])*int(1e3)
+                        else:
+                            #the interface is listed but won't be used
+                            speed = 0
+                    elif line[0] == 'Link detected':
+                        if line[1] == 'yes':
+                            enabled = True
+                        else:
+                            enabled = False
+                    else:
+                        print 'Unnexpected output of command '+command+':'
+                        print line
+                        #Error. continue?-------------------------------------------------------------
+                        continue
+                
+            if not node_id in nic_topology:
+                nic_topology[node_id] = list()
+                #With this implementation we make the RAD with only one nic per node and this nic has all ports, TODO: change this by including parent information of PF
+                nic_topology[node_id].append(Nic())
+             
+            #Load the appropriate nic    
+            nic = nic_topology[node_id][0]
+            
+            #Create a new port and fill it
+            port = Port()
+            port.name = interface
+            port.virtual = virtual
+            port.speed = speed
+            if virtual:
+                port.available_bw = 0
+                port.PF_pci_device_id = PF_pci_text
+            else:
+                port.available_bw = speed
+                if speed == 0:
+                    port.enabled = False
+                else:
+                    port.enabled = enabled
+
+            port.eligible = virtual  #Only virtual ports are eligible
+            port.mac = mac
+            port.pci_device_id = pci
+            port.pci_device_id_split = name[1:]
+            
+            #Save the port information
+            nic.add_port(port)         
+        except Exception,e:
+            print 'Error: '+str(e)
+
+    #set in vitual ports if they are enabled
+    for nic in nic_topology.itervalues():
+        for port in nic[0].ports.itervalues():
+#             print port.pci_device_id
+            if port.virtual:
+                enabled = nic[0].ports.get(port.PF_pci_device_id)
+                if enabled == None:
+                    return(False, 'The PF '+port.PF_pci_device_id+' (VF '+port.pci_device_id+') is not present in ports dict')
+                #Only if the PF is enabled the VF can be enabled
+                if nic[0].ports[port.PF_pci_device_id].enabled:
+                    port.enabled = True
+                else:
+                    port.enabled = False
+            
+    return (True, warning_text)     
+
+def get_nic_information_old(ssh_conn, nic_topology):
+    command = 'lstopo-no-graphics --of xml'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    tree=ElementTree.fromstring(stdout.read())
+    for target in tree.findall("object/object"):
+        #Find numa nodes
+        if target.get("type") != "NUMANode":
+            continue
+        node_id = int(target.get("os_index"))
+        nic_topology[node_id] = list()
+        
+        #find nics in numa node
+        for entry in target.findall("object/object"):
+            if entry.get("type") != 'Bridge':
+                continue
+            nic_name = entry.get("name")
+            model = None
+            nic = Nic()
+            
+            #find ports in nic
+            for pcidev in entry.findall("object"):
+                if pcidev.get("type") != 'PCIDev':
+                    continue
+                enabled = speed = mac = pci_busid = None
+                port = Port()
+                model = pcidev.get("name")
+                virtual = False
+                if 'Virtual' in model:
+                    virtual = True
+                pci_busid = pcidev.get("pci_busid")
+                for osdev in pcidev.findall("object"):
+                    name = osdev.get("name")
+                    for info in osdev.findall("info"):
+                        if info.get("name") != 'Address':
+                            continue
+                        mac = info.get("value")
+                        #get the port speed and status
+                        command = 'sudo ethtool '+name
+                        (_, stdout, stderr) = ssh_conn.exec_command(command)
+                        error = stderr.read()
+                        if len(error)>0:
+                            return (False, 'Error obtaining '+name+' information: '+error)
+                        ethtool = stdout.read()
+                        if '10000baseT/Full' in ethtool:
+                            speed = 10e9
+                        elif '1000baseT/Full' in ethtool:
+                            speed = 1e9
+                        elif '100baseT/Full' in ethtool:
+                            speed = 100e6
+                        elif '10baseT/Full' in ethtool:
+                            speed = 10e6
+                        else:
+                            return (False, 'Speed not detected in '+name)
+
+                    enabled = False
+                    if 'Link detected: yes' in ethtool:
+                        enabled = True
+                    
+                    if speed != None and mac != None and pci_busid != None:
+                        mac = mac.split(':')
+                        pci_busid_split = re.split(':|\.', pci_busid)
+                        #Fill the port information
+                        port.set(name, virtual, enabled, speed, mac, pci_busid, pci_busid_split)
+                        nic.add_port(port)
+              
+            if len(nic.ports) > 0:  
+                #Fill the nic model
+                if model != None:
+                    nic.set_model(model)
+                else:
+                    nic.set_model(nic_name)
+                
+                #Add it to the topology
+                nic_topology[node_id].append(nic)
+                
+    return (True, "")
+
+def get_os_information(ssh_conn, os):
+    warning_text=""
+#    command = 'lsb_release -a'
+#    (stdin, stdout, stderr) = ssh_conn.exec_command(command)
+#    cont = 0
+#    for line in stdout.readlines():
+#        line_split = re.split('\t| *', line.rstrip('\n'))
+#        if line_split[0] == 'Distributor' and line_split[1] == 'ID:':
+#            distributor = line_split[2]
+#            cont += 1
+#        elif line_split[0] == 'Release:':
+#            release = line_split[1]
+#            cont += 1
+#        elif line_split[0] == 'Codename:':
+#            codename = line_split[1]
+#            cont += 1
+#    if cont != 3:
+#        return (False, 'It was not possible to obtain the OS id')
+#    id_ = distributor+'-'+release+'-'+codename
+
+
+    command = 'cat /etc/redhat-release'
+    (_, stdout, _) = ssh_conn.exec_command(command)
+    id_text= stdout.read()
+    if len(id_text)==0:
+        #try with Ubuntu
+        command = 'lsb_release -d -s'
+        (_, stdout, _) = ssh_conn.exec_command(command)
+        id_text= stdout.read()
+    if len(id_text)==0:
+        raise paramiko.ssh_exception.SSHException("Can not determinte release neither with 'lsb_release' nor with 'cat /etc/redhat-release'")
+    id_ = id_text.rstrip('\n')
+   
+    command = 'uname -o'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    type_ = stdout.read().rstrip('\n')
+    
+    command = 'uname -i'
+    (_, stdout, stderr) = ssh_conn.exec_command(command)
+    error = stderr.read()
+    if len(error)>0:
+        raise paramiko.ssh_exception.SSHException(command +' : '+ error)
+    bit_architecture = stdout.read().rstrip('\n')
+    
+    (return_status, code) = os.set(id_, type_, bit_architecture)
+    if not return_status:
+        return (return_status, code)
+    warning_text += code
+    return (True, warning_text) 
+
+def get_hypervisor_information(virsh_conn, hypervisor):
+    type_ = virsh_conn.getType().rstrip('\n')
+    version = virsh_conn.getVersion()
+    lib_version = virsh_conn.getLibVersion()
+    
+    domains = list()
+    tree=ElementTree.fromstring(virsh_conn.getCapabilities())
+    for target in tree.findall("guest"):
+        os_type = target.find("os_type").text
+        #We only allow full virtualization
+        if os_type != 'hvm':
+            continue
+        wordsize = int(target.find('arch/wordsize').text)
+        if wordsize == 64:
+            for domain in target.findall("arch/domain"):
+                domains.append(domain.get("type"))
+            
+    (return_status, code) = hypervisor.set(type_, version, lib_version, domains)
+    if not return_status:
+        return (return_status, code)
+    return (True, code)      
+     
+class RADavailableResourcesClass(RADclass):
+    def __init__(self, resources):
+        """Copy resources from the RADclass (server resources not taking into account resources used by VMs"""
+        #New
+        self.reserved = dict()          #Dictionary of reserved resources for a server. Key are VNFC names and values RADreservedResources
+        self.cores_consumption = None   #Dictionary of cpu consumption. Key is the cpu and the value is
+        
+        self.machine = resources.machine
+        self.user = resources.user
+        self.password = resources.password
+        self.name = resources.name
+        self.nr_processors = resources.nr_processors 
+        self.processor_family = resources.processor_family
+        self.processor_manufacturer = resources.processor_manufacturer
+        self.processor_version = resources.processor_version
+        self.processor_features = resources.processor_features
+        self.memory_type = resources.memory_type
+        self.memory_freq = resources.memory_freq
+        self.memory_nr_channels = resources.memory_nr_channels
+        self.memory_size = resources.memory_size
+        self.memory_hugepage_sz = resources.memory_hugepage_sz
+        self.hypervisor = Hypervisor()
+        self.hypervisor.assign(resources.hypervisor)
+        self.os = OpSys()
+        self.os.assign(resources.os)
+        self.nodes = dict()
+        for node_k, node_v in resources.nodes.iteritems():
+            self.nodes[node_k] = Node()
+            self.nodes[node_k].assign(node_v)
+        return
+    
+    def _get_cores_consumption_warnings(self):
+        """Returns list of warning strings in case warnings are generated. 
+        In case no warnings are generated the return value will be an empty list"""
+        warnings = list()
+        #Get the cores consumption
+        (return_status, code) = get_ssh_connection(self.machine, self.user, self.password)
+        if not return_status:
+            return (return_status, code)
+        ssh_conn = code
+        command = 'mpstat -P ALL 1 1 | grep Average | egrep -v CPU\|all'
+        (_, stdout, stderr) = ssh_conn.exec_command(command)
+        error = stderr.read()
+        if len(error) > 0:
+            return (False, error)
+    
+        self.cores_consumption = dict()
+        for line in stdout.readlines():
+            cpu_usage_split = re.split('\t| *', line.rstrip('\n'))
+            usage = 100 *(1 - float(cpu_usage_split[10]))
+            if usage > 0:
+                self.cores_consumption[int(cpu_usage_split[1])] = usage 
+        ssh_conn.close()   
+        #Check if any core marked as available in the nodes has cpu_usage > 0
+        for _, node_v in self.nodes.iteritems():
+            cores = node_v.processor.eligible_cores
+            for cpu in cores:
+                if len(cpu) > 1:
+                    for core in cpu:
+                        if core in self.cores_consumption:
+                            warnings.append('Warning: Core '+str(core)+' is supposed to be idle but it is consuming '+str(self.cores_consumption[core])+'%')
+                else:
+                    if cpu in self.cores_consumption:
+                        warnings.append('Warning: Core '+str(core)+' is supposed to be idle but it is consuming '+str(self.cores_consumption[cpu])+'%')
+        
+        return warnings
+    
+    def reserved_to_text(self):
+        text = str()
+        for VNFC_name, VNFC_reserved in self.reserved.iteritems():
+            text += '    VNFC: '+str(VNFC_name)+'\n'
+            text += VNFC_reserved.to_text()
+                    
+        return text
+    
+    def obtain_usage(self):
+        resp = dict()
+        #Iterate through nodes to get cores, eligible cores, memory and physical ports (save ports usage for next section)
+        nodes = dict()
+        ports_usage = dict()
+        hugepage_size = dict()
+        for node_k, node_v in self.nodes.iteritems():
+            node = dict()
+            ports_usage[node_k] = dict()
+            eligible_cores = list()
+            for pair in node_v.processor.eligible_cores:
+                if isinstance(pair, list):
+                    for element in pair:
+                        eligible_cores.append(element)
+                else:
+                    eligible_cores.append(pair)
+            node['cpus'] = {'cores':node_v.processor.cores,'eligible_cores':eligible_cores}
+            node['memory'] = {'size':str(node_v.memory.node_size/(1024*1024*1024))+'GB','eligible':str(node_v.memory.eligible_memory/(1024*1024*1024))+'GB'}
+            hugepage_size[node_k] = node_v.memory.hugepage_sz
+            
+            ports = dict()
+            for nic in node_v.nic_list:
+                for port in nic.ports.itervalues():
+                    if port.enabled and not port.virtual: 
+                        ports[port.name] = {'speed':str(port.speed/1000000000)+'G'}
+#                         print '*************** ',port.name,'speed',port.speed 
+                        ports_usage[node_k][port.name] = 100 - int(100*float(port.available_bw)/float(port.speed))
+            node['ports'] = ports
+            nodes[node_k] = node
+        resp['RAD'] = nodes
+        
+        #Iterate through reserved section to get used cores, used memory and port usage
+        cores = dict()
+        memory = dict()
+        #reserved_cores = list
+        for node_k in self.nodes.iterkeys():
+            if not node_k in cores:
+                cores[node_k] = list()
+                memory[node_k] = 0
+            for _, reserved in self.reserved.iteritems():
+                if node_k in reserved.node_reserved_resources:
+                    node_v = reserved.node_reserved_resources[node_k]
+                    cores[node_k].extend(node_v.reserved_cores)
+                    memory[node_k] += node_v.reserved_hugepage_nr * hugepage_size[node_k]
+                            
+        occupation = dict()       
+        for node_k in self.nodes.iterkeys():
+            ports = dict()
+            for name, usage in ports_usage[node_k].iteritems():
+                ports[name] = {'occupied':str(usage)+'%'}
+#             print '****************cores',cores
+#             print '****************memory',memory
+            occupation[node_k] = {'cores':cores[node_k],'memory':str(memory[node_k]/(1024*1024*1024))+'GB','ports':ports}
+        resp['occupation'] = occupation
+        
+        return resp            
+    
+class RADreservedResources():
+    def __init__(self):
+        self.node_reserved_resources = dict()      #dict. keys are the RAD nodes id, values are NodeReservedResources
+        self.mgmt_interface_pci = None             #pci in the VNF for the management interface
+        self.image = None                          #Path in remote machine of the VNFC image
+    
+    def update(self,reserved):
+        self.image = reserved.image
+        self.mgmt_interface_pci = reserved.mgmt_interface_pci
+        for k,v in reserved.node_reserved_resources.iteritems():
+            if k in self.node_reserved_resources.keys():
+                return (False, 'Duplicated node entry '+str(k)+' in reserved resources')
+            self.node_reserved_resources[k]=v
+            
+        return (True, "")
+    
+    def to_text(self):
+        text = '        image: '+str(self.image)+'\n'
+        for node_id, node_reserved in self.node_reserved_resources.iteritems():
+            text += '        Node ID: '+str(node_id)+'\n'
+            text += node_reserved.to_text()
+        return text
+
+class NodeReservedResources():
+    def __init__(self):
+    #     reserved_shared_cores = None      #list. List of all cores that the VNFC needs in shared mode  #TODO Not used
+    #     reserved_memory = None            #Integer. Amount of KiB needed by the VNFC #TODO. Not used since hugepages are used
+        self.reserved_cores = list()             #list. List of all cores that the VNFC uses
+        self.reserved_hugepage_nr = 0            #Integer. Number of hugepages needed by the VNFC 
+        self.reserved_ports = dict()             #dict. The key is the physical port pci and the value the VNFC port description
+        self.vlan_tags = dict()
+        self.cpu_pinning = None
+    
+    def to_text(self):
+        text = '            cores: '+str(self.reserved_cores)+'\n'
+        text += '            cpu_pinning: '+str(self.cpu_pinning)+'\n'
+        text += '            hugepages_nr: '+str(self.reserved_hugepage_nr)+'\n'
+        for port_pci, port_description in self.reserved_ports.iteritems():
+            text += '            port: '+str(port_pci)+'\n'
+            text += port_description.to_text()
+        return text
+    
+#     def update(self,reserved):
+#         self.reserved_cores = list(reserved.reserved_cores)
+#         self.reserved_hugepage_nr = reserved.reserved_hugepage_nr
+#         self.reserved_ports = dict(reserved.reserved_ports)
+#         self.cpu_pinning = list(reserved.cpu_pinning)
+    
+    
+