def get_host_name(vm_id): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid,value in vm_dict.iteritems(): if vm_id == vmid: return node return None
def get_domain_object(vm_id): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid, value in vm_dict.iteritems(): if vm_id == vmid: return value return None
def list_host_and_domain(): host_vm_dict = getHostVMDict() print '%s%s%s' %(str('Host Name').ljust(25),str('Domain Name').ljust(25),'Status') print '------------------------------------------------------------------' for node, vm_dict in host_vm_dict.iteritems(): for vmid,value in vm_dict.iteritems(): print '%s%s%s' %(str(node).ljust(25),vmid.ljust(25),'running')
def get_domain_object(vm_id): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid,value in vm_dict.iteritems(): if vm_id == vmid: return value return None
def find_lifetime_and_terminate_vm(): print 'termination' while (1): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid, value in vm_dict.iteritems(): vm_end_time = calculate_vm_endtime(value.vmid, value.start_time) #print vm_end_time #For Testing purpose we are subtracting 9000 seconds vm_end_time = float(vm_end_time) + float(9100) #print 'VMID '+vmid+' Host '+node+' Current Time : '+ str(int(time.time()/60)) +' End Time : '+str(int(vm_end_time/60)) now = datetime.datetime.now() vmtermination_log.write('END TIME::' + str(vm_end_time) + ' ::: CURRENT TIME :: ' + str(now) + '\n') if (time.mktime(now.timetuple()) >= vm_end_time): if (vm_terminate_guest(node, vmid)): vm_termination_list.append(vmid) vmtermination_log.write( str(datetime.datetime.now()) + ' :: TERMINATION HANDLER ::' + node + ' :: ' + vmid + ' :: Guest terminated\n') time.sleep(20)
def get_host_name(vm_id): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid, value in vm_dict.iteritems(): if vm_id == vmid: return node return None
def list_host_and_domain(): host_vm_dict = getHostVMDict() print '%s%s%s' % (str('Host Name').ljust(25), str('Domain Name').ljust(25), 'Status') print '------------------------------------------------------------------' for node, vm_dict in host_vm_dict.iteritems(): for vmid, value in vm_dict.iteritems(): print '%s%s%s' % (str(node).ljust(25), vmid.ljust(25), 'running')
def vm_terminate_dependency(source_host, vmid): #Remove entry from host_vm_dict.pkl #Remove the configuration XML host_vm_dict = getHostVMDict() guest = host_vm_dict[source_host][vmid] addOrUpdateDictionaryOfVM(source_host, vmid, None) resume_resources_from_guest(source_host, vmid, guest)
def update_dictionary(host, vmid, cpu_count): host_vm_dict = getHostVMDict() value = host_vm_dict[host][vmid] old_cpu = value.current_cpu required_cpu = float(cpu_count) - float(old_cpu) guest = Guest(value.vmip,value.vmid, float(cpu_count), value.max_cpu, value.current_memory, value.max_memory,value.io, value.start_time) addOrUpdateDictionaryOfVM(host, vmid, guest) update_resources_after_cpu_scaling(host, vmid, guest, required_cpu)
def monitorAndLogAndReportHotSpot(): usageInfo = "" file = open("/var/lib/virtdc/logs/monitor_logs/vmusage.log", "a+") host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): file.write("HOST NAME : " + node + " TIME : " + str(datetime.now()) + "\n") if vm_dict != {}: file.write( "VM ID\t\t|\tVM IP\t\t|\tAlloted CPU\t|\tCPU usage\t|\tAllotted memory\t|\tMemory usage\t|\tAllotted IO\t|\tIO usage\n" ) for vmid, value in vm_dict.iteritems(): vmip = value.vmip.strip() cpu_usage = getCpuUsage(vmip) mem_usage = getTaskMemUsage(vmip) io_usage = getIoUsage(vmip) print "Current Memory " + str(value.current_memory) print "Task Memory Usage" + str(mem_usage) # usage= 'VM ID: '+vmid+'\tVM IP: '+vmip + '\t\talloted cpu: '+str(value.current_cpu)+'\tcpu usage: ' + str(cpuUsage) + '\talotted memory: '+str(value.current_memory)+'\tmemory usage: ' + str(memUsage) + '\talotted io: '+str(value.io)+'\tio usage: ' + str(ioUsage) +"\n" usage = ( vmid + "\t|\t" + vmip + "\t|\t" + str(value.current_cpu) + "\t\t|\t" + str(cpu_usage) + "\t|\t" + str(value.current_memory) + "\t|\t" + str(mem_usage) + "\t|\t" + str(value.io) + "\t|\t" + str(io_usage) + "\n" ) usageInfo += usage file.write(usage + "\n") if float(cpu_usage) > float(value.current_cpu) or float(mem_usage) > float(value.current_memory): # report to VM Placement manager a = 0 # Process over memory usage information based on SLA process_mem_over_usage(vmid, float(mem_usage), float(value.current_memory)) # Report current usage to VM Placement manager process_action_on_current_usage(node, vmid, value, cpu_usage, mem_usage, io_usage) # print usageInfo file.close() return usageInfo
def load_balance(): node_list = ['node1', 'node2', 'node3', 'node4'] node_cpu_list = [0, 0, 0, 0] host_vm_dict = getHostVMDict() vm_obj_list = [] used_cpu_count = 0 for vm_dict in host_vm_dict.itervalues(): for value in vm_dict.itervalues(): used_cpu_count += value.current_cpu vm_obj_list.append(value) avg_cpu = int(math.ceil(used_cpu_count / len(node_list))) pickle_dict = {} lock = LockFile("/var/lib/virtdc/framework/host_vm_dict.pkl") with lock: while (len(vm_obj_list) > 0): max_cpu_vm = None # pick a vm with the largest cpu number for vm in vm_obj_list: if max_cpu_vm is None: max_cpu_vm = vm if vm.current_cpu > max_cpu_vm.current_cpu: max_cpu_vm = vm # migrate the max-cpu vm to first available node if vm_migrate_guest(get_host_name(max_cpu_vm.vmid), node_list[-1], max_cpu_vm.vmid) is False: return False node_cpu_list[-1] += max_cpu_vm.current_cpu # node is saturated if it has reached its balance quorum if node_cpu_list[-1] >= avg_cpu: node_list.pop() node_cpu_list.pop() # re-populate the vm pickle file pickle_dict.setdefault(node_list[-1], {}) pickle_dict[node_list[-1]][max_cpu_vm.vmid] = max_cpu_vm vm_obj_list.remove(max_cpu_vm) with open('/var/lib/virtdc/framework/host_vm_dict.pkl', 'w') as pickle_out: pickle.dump(pickle_dict, pickle_out) #pickleNodeVMDictionary(pickle_dict) return True
def load_balance(): node_list = ['node1', 'node2', 'node3', 'node4'] node_cpu_list = [ 0, 0, 0, 0 ] host_vm_dict = getHostVMDict() vm_obj_list = [] used_cpu_count = 0 for vm_dict in host_vm_dict.itervalues(): for value in vm_dict.itervalues(): used_cpu_count += value.current_cpu vm_obj_list.append(value) avg_cpu = int(math.ceil(used_cpu_count/len(node_list))) pickle_dict = {} lock = LockFile("/var/lib/virtdc/framework/host_vm_dict.pkl") with lock: while(len(vm_obj_list) > 0): max_cpu_vm = None # pick a vm with the largest cpu number for vm in vm_obj_list: if max_cpu_vm is None: max_cpu_vm = vm if vm.current_cpu > max_cpu_vm.current_cpu: max_cpu_vm = vm # migrate the max-cpu vm to first available node if vm_migrate_guest(get_host_name(max_cpu_vm.vmid), node_list[-1], max_cpu_vm.vmid) is False: return False node_cpu_list[-1] += max_cpu_vm.current_cpu # node is saturated if it has reached its balance quorum if node_cpu_list[-1] >= avg_cpu: node_list.pop() node_cpu_list.pop() # re-populate the vm pickle file pickle_dict.setdefault(node_list[-1], {}) pickle_dict[node_list[-1]][max_cpu_vm.vmid] = max_cpu_vm vm_obj_list.remove(max_cpu_vm) with open('/var/lib/virtdc/framework/host_vm_dict.pkl','w') as pickle_out: pickle.dump(pickle_dict, pickle_out) #pickleNodeVMDictionary(pickle_dict) return True
def update_dictionary(host, vmid, mem_size): host_vm_dict = getHostVMDict() value = host_vm_dict[host][vmid] old_memory = value.current_memory required_memory = float(mem_size) - float(old_memory) guest = Guest(value.vmip,value.vmid, value.current_cpu, value.max_cpu, float(mem_size), value.max_memory,value.io, value.start_time) #Update memory for guest in guest dictionary addOrUpdateDictionaryOfVM(host, vmid, guest) #Update memory for guest in host dictionary update_resources_after_mem_scaling(host, vmid, guest, required_memory)
def show_domain_info(vm_id): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid,value in vm_dict.iteritems(): if vm_id == vmid: print '%s%s' %(str('Domain Name:').ljust(30),vmid) print '--------------------------------------------' print '%s%s' %(str('Host Name:').ljust(30),node) print '%s%s' %(str('Domain IP:').ljust(30),value.vmip) print '%s%s' %(str('Current CPU [core]:').ljust(30),value.current_cpu) print '%s%s' %(str('Maximum CPU [core]:').ljust(30),value.max_cpu) print '%s%s' %(str('Current Memory [KiB]:').ljust(30),value.current_memory) print '%s%s' %(str('Maximum Memory [KiB]:').ljust(30),value.max_memory) print '%s%s' %(str('Created Time:').ljust(30),value.start_time)
def update_dictionary(host, vmid, mem_size): host_vm_dict = getHostVMDict() value = host_vm_dict[host][vmid] old_memory = value.current_memory required_memory = float(mem_size) - float(old_memory) guest = Guest(value.vmip, value.vmid, value.current_cpu, value.max_cpu, float(mem_size), value.max_memory, value.io, value.start_time) #Update memory for guest in guest dictionary addOrUpdateDictionaryOfVM(host, vmid, guest) #Update memory for guest in host dictionary update_resources_after_mem_scaling(host, vmid, guest, required_memory)
def do_prereq_start_workload(hostName, vmid): try: host_vm_dict = getHostVMDict() print host_vm_dict ip = host_vm_dict[hostName][vmid].vmip print "IP RUN " + str(ip) update_vmid_in_config(vmid) # copy host configuration file to guest scpHostConfig = 'scp -q -o StrictHostKeyChecking=no /var/lib/virtdc/vmonere/dominfo/' + vmid + '.txt root@' + ip + ':' + file_path subprocess.Popen(scpHostConfig, shell=True, stderr=subprocess.PIPE) start_monitor = 'ssh -n -q -o StrictHostKeyChecking=no root@' + ip + ' \"/bin/nohup sh -c \'/bin/python /var/lib/virtdc/vmonere/guest/vmonere_sender_socket.py\' > /dev/null 2>&1 &' + '\"' print start_monitor subprocess.Popen(start_monitor, shell=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print "error>", e.output, '<'
def do_prereq_start_workload(hostName, vmid): try: host_vm_dict=getHostVMDict() print host_vm_dict ip=host_vm_dict[hostName][vmid].vmip print "IP RUN "+str(ip) update_vmid_in_config(vmid) # copy host configuration file to guest scpHostConfig = 'scp -q -o StrictHostKeyChecking=no /var/lib/virtdc/vmonere/dominfo/'+vmid+'.txt root@'+ip+':'+file_path subprocess.Popen(scpHostConfig, shell=True, stderr=subprocess.PIPE) start_monitor = 'ssh -n -q -o StrictHostKeyChecking=no root@'+ip+' \"/bin/nohup sh -c \'/bin/python /var/lib/virtdc/vmonere/guest/vmonere_sender_socket.py\' > /dev/null 2>&1 &' + '\"' print start_monitor subprocess.Popen(start_monitor, shell=True, stderr=subprocess.PIPE) except subprocess.CalledProcessError as e: print "error>",e.output,'<'
def show_domain_info(vm_id): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid, value in vm_dict.iteritems(): if vm_id == vmid: print '%s%s' % (str('Domain Name:').ljust(30), vmid) print '--------------------------------------------' print '%s%s' % (str('Host Name:').ljust(30), node) print '%s%s' % (str('Domain IP:').ljust(30), value.vmip) print '%s%s' % (str('Current CPU [core]:').ljust(30), value.current_cpu) print '%s%s' % (str('Maximum CPU [core]:').ljust(30), value.max_cpu) print '%s%s' % (str('Current Memory [KiB]:').ljust(30), value.current_memory) print '%s%s' % (str('Maximum Memory [KiB]:').ljust(30), value.max_memory) print '%s%s' % (str('Created Time:').ljust(30), value.start_time)
def vm_migrate_dependency(source_host,dest_host,vmid): obj=NodeFinder() #Remove entry from host_vm_dict.pkl for the source_host #Add Entry to the dest_host in node_dict.pkl #Remove the configuration XML host_vm_dict = getHostVMDict() guest = host_vm_dict[source_host][vmid] #update guest dictionay on source_host addOrUpdateDictionaryOfVM(source_host, vmid, None) #Update host dictionary for source host resume_resources_from_guest(source_host, vmid, guest) #update guest dictionay on dest_host addOrUpdateDictionaryOfVM(dest_host, vmid, guest) #Update host dictionary for dest host host = obj.place_job (dest_host, guest.current_cpu,guest.current_memory,guest.io)
def vm_migrate_dependency(source_host, dest_host, vmid): obj = NodeFinder() #Remove entry from host_vm_dict.pkl for the source_host #Add Entry to the dest_host in node_dict.pkl #Remove the configuration XML host_vm_dict = getHostVMDict() guest = host_vm_dict[source_host][vmid] #update guest dictionay on source_host addOrUpdateDictionaryOfVM(source_host, vmid, None) #Update host dictionary for source host resume_resources_from_guest(source_host, vmid, guest) #update guest dictionay on dest_host addOrUpdateDictionaryOfVM(dest_host, vmid, guest) #Update host dictionary for dest host host = obj.place_job(dest_host, guest.current_cpu, guest.current_memory, guest.io)
def find_lifetime_and_terminate_vm(): print 'termination' while(1): host_vm_dict = getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): for vmid,value in vm_dict.iteritems(): vm_end_time = calculate_vm_endtime(value.vmid, value.start_time) #print vm_end_time #For Testing purpose we are subtracting 9000 seconds vm_end_time = float(vm_end_time) + float(9100) #print 'VMID '+vmid+' Host '+node+' Current Time : '+ str(int(time.time()/60)) +' End Time : '+str(int(vm_end_time/60)) now=datetime.datetime.now() vmtermination_log.write('END TIME::'+ str(vm_end_time)+ ' ::: CURRENT TIME :: '+str(now)+'\n') if (time.mktime(now.timetuple()) >= vm_end_time ): if (vm_terminate_guest(node, vmid) ): vm_termination_list.append(vmid) vmtermination_log.write(str(datetime.datetime.now()) +' :: TERMINATION HANDLER ::'+node+' :: '+vmid+' :: Guest terminated\n') time.sleep(20)
def monitorAndLogAndReportHotSpot(): usageInfo="" file= open('/var/lib/virtdc/logs/monitor_logs/vmusage.log', 'a+') host_vm_dict=getHostVMDict() for node, vm_dict in host_vm_dict.iteritems(): file.write("HOST NAME : "+node+" TIME : "+str(datetime.now())+'\n') if(vm_dict!={}): file.write('VM ID\t\t|\tVM IP\t\t|\tAlloted CPU\t|\tCPU usage\t|\tAllotted memory\t|\tMemory usage\t|\tAllotted IO\t|\tIO usage\n') for vmid,value in vm_dict.iteritems(): vmip = value.vmip.strip() cpu_usage = getCpuUsage(vmip) mem_usage = getTaskMemUsage(vmip) io_usage = getIoUsage(vmip) print "Current Memory "+str(value.current_memory) print "Task Memory Usage"+str(mem_usage) #usage= 'VM ID: '+vmid+'\tVM IP: '+vmip + '\t\talloted cpu: '+str(value.current_cpu)+'\tcpu usage: ' + str(cpuUsage) + '\talotted memory: '+str(value.current_memory)+'\tmemory usage: ' + str(memUsage) + '\talotted io: '+str(value.io)+'\tio usage: ' + str(ioUsage) +"\n" usage= vmid+'\t|\t'+vmip + '\t|\t'+str(value.current_cpu)+'\t\t|\t' + str(cpu_usage) + '\t|\t'+str(value.current_memory)+'\t|\t' + str(mem_usage) + '\t|\t'+str(value.io)+'\t|\t' + str(io_usage) +"\n" usageInfo+=usage file.write(usage+'\n') if (float(cpu_usage)>float(value.current_cpu) or float(mem_usage)>float(value.current_memory)): #report to VM Placement manager a=0 #Process over memory usage information based on SLA process_mem_over_usage(vmid, float(mem_usage), float(value.current_memory)) #Report current usage to VM Placement manager process_action_on_current_usage(node, vmid, value, cpu_usage, mem_usage, io_usage) #print usageInfo file.close() return usageInfo