class InformationAggregator():
def __init__(self):
self.logger = logging.getLogger(self.__class__.__name__)
self.COMPUTE_NODES = [
'acticloud1', 'acticloud2', 'acticloud3', 'acticloud4'
]
self.acticlouddb_client = ActiCloudDBClient()
self.openstack_client = OpenstackClient()
def is_gold_vm(self, vmid):
return self.acticlouddb_client.is_gold_vm(vmid, 1)
def get_vm_nr_vcpus(self, vmid):
return self.acticlouddb_client.get_nr_vcpus(vmid)
def get_vm_current_host(self, vmid):
return self.openstack_client.get_vm_current_host(vmid)
def getServerListByComputeNode(self, computeNode):
return self.openstack_client.get_vms_by_hostname(computeNode)
def getGoldServerListByComputeNode(self, computeNode):
all_servers = self.getServerListByComputeNode(computeNode)
gold_servers = [x for x in all_servers if self.is_gold_vm(x)]
return gold_servers
def getSilverServerListByComputeNode(self, computeNode):
all_servers = self.getServerListByComputeNode(computeNode)
silver_servers = [x for x in all_servers if not self.is_gold_vm(x)]
return silver_servers
def getVcpusByComputeNode(self, computeNode):
gold_vcpus = self.acticlouddb_client.get_nr_gold_vcpus_by_hostname(
computeNode)
silver_vcpus = self.acticlouddb_client.get_nr_silver_vcpus_by_hostname(
computeNode)
return (gold_vcpus, silver_vcpus)
def getServerList(self):
return self.openstack_client.get_vms()
def getComputeNodes(self):
return list(self.COMPUTE_NODES)
class InformationAggregator():
def __init__(self, compute_node_name, system_type):
global INTERFERENCE_DETECTION_ENABLED
self.logger = logging.getLogger(self.__class__.__name__)
self.hostname = compute_node_name
self.compute_node_name = compute_node_name
self.system_type = system_type
if system_type == "actistatic" or system_type == "actifull":
if system_type == "actifull":
INTERFERENCE_DETECTION_ENABLED = True
self.system = ActiManagerSystem([2, 1, 10], compute_node_name)
elif system_type == "gps":
self.system = GoldPerSocketSystem([2, 1, 10], compute_node_name)
elif system_type == "gno":
self.system = GoldNotOversubscribedSystem([2, 1, 10],
compute_node_name)
else:
self.logger.error("Wrong system_type given: %s", system_type)
sys.exit(1)
self.acticlouddb_client = ActiCloudDBClient()
self.openstack_client = OpenstackClient()
return
def get_system(self):
return self.system
def report_events(self):
if ("acti" in self.system_type):
event_logger.log_event({
'event': 'internal-profit-report',
'profit-value': self.system.cur_profit,
'hostname': self.hostname
})
esd_dict = dict()
for vm in self.system.vms:
esd_dict[vm] = [v.esd for v in self.system.vms[vm].vcpus]
event_logger.log_event({
'event': 'internal-esd-report',
'values': esd_dict,
'hostname': self.hostname
})
def get_pid_from_vm_id(self, vm):
command = "nova show %s | grep -i 'OS-EXT-SRV-ATTR:instance_name' | awk -F'|' '{print $3}'" % str(
vm.id)
libvirt_instance_name = shell_command.run_shell_command(
command).strip()
command = "ssh %s ps -ef | grep %s | grep \"qemu-system\" | grep -v grep | awk '{print $2}'" % (
self.hostname, libvirt_instance_name)
pid = shell_command.run_shell_command(command).strip()
return pid
def get_dst_numa_node_from_pcpu(self, pcpu_id):
#module numa has not implemented numa_node_of_cpu() call of numa(3) library
for i in range(0, numa.get_max_node() + 1):
if pcpu_id in numa.node_to_cpus(i):
return i
def print_vcpu_to_pcpu_mapping(self):
p_mapping = []
for vm in self.getServerListByComputeNode(self.compute_node_name):
vm_mapping = self.getVMVcpuMapping(vm)
for i in range(len(vm_mapping)):
p_mapping.append(0)
break
for vm in self.getServerListByComputeNode(self.compute_node_name):
vm_mapping = self.getVMVcpuMapping(vm)
for i in range(len(vm_mapping)):
if vm_mapping[i]:
if self.is_gold_vm(vm):
p_mapping[i] += 10
else:
p_mapping[i] += 1
self.logger.info("Physical CPU mapping: %s" % p_mapping)
return
def is_noisy_vm(self, vm):
is_noisy = self.acticlouddb_client.is_noisy_vm(vm.id)
return is_noisy
def is_sensitive_vm(self, vm):
is_sensitive = self.acticlouddb_client.is_sensitive_vm(vm.id)
return is_sensitive
def is_gold_vm(self, vm):
is_gold = self.acticlouddb_client.is_gold_vm(vm.id, 1)
return is_gold
def get_vm_nr_vcpus(self, vm):
return self.acticlouddb_client.get_nr_vcpus(vm.id)
def get_cost_function(self, vm):
cost_function = self.acticlouddb_client.cost_function(vm.id)
return cost_function
def get_cpu_util(self, vm):
return 1.0 # FIXME
cpu_util = self.acticlouddb_client.cpu_util(vm.id)
return cpu_util
def update_moves(self, vm): # vm: Vm class instance
prev_moves = self.acticlouddb_client.get_moves(vm.id)
self.acticlouddb_client.set_moves(vm.id, prev_moves + vm.moves)
def getServerListByComputeNode(self, computeNode):
return self.openstack_client.get_vms_by_hostname(computeNode)
def getServerList(self):
return self.openstack_client.get_vms()
def getVMVcpuMapping(self, vm):
try:
libvirt_instance_name = getattr(vm,
'OS-EXT-SRV-ATTR:instance_name')
with libvirt_client.LibVirtConnection(self.hostname,
"qemu+ssh") as libvconn:
libvinstance = libvirt_client.LibVirtInstance(
libvconn, str(libvirt_instance_name))
return list(libvinstance.get_instance_mapping()[0])
except:
self.logger.info(
"=================> Could not get vcpu mapping of VM %s",
vm.id)
return None
