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 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
