From 1b6e7727dd594270d07ca7445aa0bbc8215ad5a2 Mon Sep 17 00:00:00 2001 From: "berrange@roquette.boston.redhat.com" Date: Wed, 29 Mar 2006 05:35:11 -0500 Subject: [PATCH] Added preferences via GConf --- gnome-vm-manager.glade | 330 +++++++++++++++++++++++++++++- gnome-vm-manager.py | 450 ++++++++++++++++++++++++++++++++--------- 2 files changed, 684 insertions(+), 96 deletions(-) diff --git a/gnome-vm-manager.glade b/gnome-vm-manager.glade index 0f2e16b9..20588d15 100644 --- a/gnome-vm-manager.glade +++ b/gnome-vm-manager.glade @@ -3,7 +3,7 @@ - + True Virtual Machine Manager GTK_WINDOW_TOPLEVEL @@ -83,7 +83,7 @@ True - Details + VM details True @@ -109,6 +109,21 @@ + + + + True + + + + + + True + gtk-preferences + True + + + @@ -301,6 +316,7 @@ Inactive virtual machines True + False True True gtk-delete @@ -327,6 +343,7 @@ Inactive virtual machines True + False True True GTK_RELIEF_NORMAL @@ -402,6 +419,7 @@ Inactive virtual machines True + False True True gtk-open @@ -471,9 +489,9 @@ Inactive virtual machines - + True - True + False Virtual Machine Manager Copyright (C) 2006 Red Hat Inc. @@ -494,9 +512,10 @@ Inactive virtual machines False Daniel P. Berrange <berrange@redhat.com> translator-credits + - + True Virtual Machine Details GTK_WINDOW_TOPLEVEL @@ -1740,4 +1759,305 @@ Inactive virtual machines + + True + Virtual Machine Manager Preferences + GTK_WINDOW_TOPLEVEL + GTK_WIN_POS_NONE + False + True + False + True + False + False + GDK_WINDOW_TYPE_HINT_DIALOG + GDK_GRAVITY_NORTH_WEST + True + False + False + + + + + True + False + 0 + + + + True + GTK_BUTTONBOX_END + + + + True + True + True + gtk-help + True + GTK_RELIEF_NORMAL + True + -11 + + + + + + True + True + True + gtk-close + True + GTK_RELIEF_NORMAL + True + -7 + + + + + + 0 + False + True + GTK_PACK_END + + + + + + True + False + 0 + + + + 3 + True + 0 + 0.5 + GTK_SHADOW_ETCHED_IN + + + + True + 0.5 + 0.5 + 1 + 1 + 0 + 0 + 12 + 0 + + + + 3 + True + 2 + 3 + False + 3 + 3 + + + + True + Update status every + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + 1 + 0 + 1 + fill + + + + + + + True + Maintain history of + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 0 + 1 + 1 + 2 + fill + + + + + + + True + True + 1 + 0 + True + GTK_UPDATE_IF_VALID + False + False + 5 1 60 1 5 5 + + + + 1 + 2 + 0 + 1 + fill + + + + + + + True + seconds + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 2 + 3 + 0 + 1 + + + + + + + True + samples + False + False + GTK_JUSTIFY_LEFT + False + False + 0 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + 2 + 3 + 1 + 2 + fill + + + + + + + True + True + 1 + 0 + True + GTK_UPDATE_IF_VALID + False + False + 10 10 100 1 5 5 + + + + 1 + 2 + 1 + 2 + fill + + + + + + + + + + + True + <b>Status monitoring</b> + False + True + GTK_JUSTIFY_LEFT + False + False + 0.5 + 0.5 + 0 + 0 + PANGO_ELLIPSIZE_NONE + -1 + False + 0 + + + label_item + + + + + 0 + True + True + + + + + 0 + True + True + + + + + + diff --git a/gnome-vm-manager.py b/gnome-vm-manager.py index 15f76341..e291b6b3 100755 --- a/gnome-vm-manager.py +++ b/gnome-vm-manager.py @@ -1,15 +1,17 @@ #!/usr/bin/python +import gconf import gtk import gobject import gtk.gdk import gtk.glade +from time import time import re import os import os.path import libvirt -tickrate = 5000 +gconf_dir = "/apps/gnome-virtual-manager" # Ought not to hardcode stuff as being in /usr gladedir = "/usr/share/gnome-vm-manager" @@ -20,79 +22,167 @@ if os.path.exists("./gnome-vm-manager.glade"): class vmmAbout: def __init__(self): - self.window = gtk.glade.XML(gladedir + "/gnome-vm-manager.glade", "vm-about") - self.window.get_widget("vm-about").hide() + self.window = gtk.glade.XML(gladedir + "/gnome-vm-manager.glade", "vmm-about") + self.window.get_widget("vmm-about").hide() + + self.window.signal_autoconnect({ + "on_vmm_about_delete_event": self.close, + }) def show(self): - dialog = self.window.get_widget("vm-about") + dialog = self.window.get_widget("vmm-about") dialog.set_version("0.1") dialog.show_all() + def close(self,ignore1=None,ignore2=None): + self.window.get_widget("vmm-about").hide() + return 1 + + +class vmmDetails: + def __init__(self, vmm): + self.window = gtk.glade.XML(gladedir + "/gnome-vm-manager.glade", "vmm-details") + self.vmm = vmm + + +class vmmPreferences: + def __init__(self, conf): + self.window = gtk.glade.XML(gladedir + "/gnome-vm-manager.glade", "vmm-preferences") + self.conf = conf + self.window.get_widget("vmm-preferences").hide() + + self.conf.on_stats_update_interval_changed(self.refresh_update_interval) + self.conf.on_stats_history_length_changed(self.refresh_history_length) + + self.refresh_update_interval() + self.refresh_history_length() + + self.window.signal_autoconnect({ + "on_stats_update_interval_changed": self.change_update_interval, + "on_stats_history_length_changed": self.change_history_length, + + "on_close_clicked": self.close, + "on_vmm_preferences_delete_event": self.close, + }) + + def close(self,ignore1=None,ignore2=None): + self.window.get_widget("vmm-preferences").hide() + return 1 + + def show(self): + self.window.get_widget("vmm-preferences").show_all() + + def refresh_update_interval(self, ignore1=None,ignore2=None,ignore3=None,ignore4=None): + self.window.get_widget("stats-update-interval").set_value(self.conf.get_stats_update_interval()) + + def refresh_history_length(self, ignore1=None,ignore2=None,ignore3=None,ignore4=None): + self.window.get_widget("stats-history-length").set_value(self.conf.get_stats_history_length()) + + def change_update_interval(self, src): + self.conf.set_stats_update_interval(src.get_value_as_int()) + + def change_history_length(self, src): + self.conf.set_stats_history_length(src.get_value_as_int()) + class vmmManager: def __init__(self): - self.window = gtk.glade.XML(gladedir + "/gnome-vm-manager.glade", "vm-manager") + self.window = gtk.glade.XML(gladedir + "/gnome-vm-manager.glade", "vmm-manager") + self.conf = vmmConfig() self.vmm = libvirt.openReadOnly(None) #self.vmm = libvirt.open(None) - self.stats = {} - - self.record_stats() + self.stats = vmmStats(self.vmm, self.conf) self.populate_vms() - self.tickrate = 5000 - self.about = None; - - self.timer = gobject.timeout_add(self.tickrate, self.refresh_stats) + self.about = None + self.preferences = None + + # Setup update timers + self.conf.on_stats_update_interval_changed(self.change_timer_interval) + self.schedule_timer() + + self.conf.on_vmlist_status_visible_changed(self.toggle_status_visible_widget) + self.conf.on_vmlist_cpu_usage_visible_changed(self.toggle_cpu_usage_visible_widget) + self.conf.on_vmlist_memory_usage_visible_changed(self.toggle_memory_usage_visible_widget) + self.conf.on_vmlist_disk_usage_visible_changed(self.toggle_disk_usage_visible_widget) + self.conf.on_vmlist_network_traffic_visible_changed(self.toggle_network_traffic_visible_widget) + + self.window.get_widget("menu_view_status").set_active(self.conf.is_vmlist_status_visible()) + self.window.get_widget("menu_view_cpu_usage").set_active(self.conf.is_vmlist_cpu_usage_visible()) + self.window.get_widget("menu_view_memory_usage").set_active(self.conf.is_vmlist_memory_usage_visible()) + self.window.get_widget("menu_view_disk_usage").set_active(self.conf.is_vmlist_disk_usage_visible()) + self.window.get_widget("menu_view_network_traffic").set_active(self.conf.is_vmlist_network_traffic_visible()) self.window.signal_autoconnect({ - "on_menu_view_status_activate" : self.toggle_status_column, - "on_menu_view_cpu_usage_activate" : self.toggle_cpu_column, - "on_menu_view_memory_usage_activate" : self.toggle_memory_column, - "on_menu_view_disk_usage_activate" : self.toggle_disk_column, - "on_menu_view_network_traffic_activate" : self.toggle_network_column, + "on_menu_view_status_activate" : self.toggle_status_visible_conf, + "on_menu_view_cpu_usage_activate" : self.toggle_cpu_usage_visible_conf, + "on_menu_view_memory_usage_activate" : self.toggle_memory_usage_visible_conf, + "on_menu_view_disk_usage_activate" : self.toggle_disk_usage_visible_conf, + "on_menu_view_network_traffic_activate" : self.toggle_network_traffic_visible_conf, "on_vm_manager_delete_event": self.exit_app, "on_menu_file_quit_activate": self.exit_app, "on_vmm_close_clicked": self.exit_app, + "on_menu_edit_preferences_activate": self.show_preferences, "on_menu_help_about_activate": self.show_about, }) + + self.vm_selected(None) + self.window.get_widget("vm-list").get_selection().connect("changed", self.vm_selected) + def exit_app(self, ignore=None,ignore2=None): gtk.main_quit() + def schedule_timer(self): + interval = self.conf.get_stats_update_interval() * 1000 + print "Scheduling at " + str(interval) + self.timer_started = time() * 1000 + self.timer = gobject.timeout_add(interval, self.refresh_stats) + + + def change_timer_interval(self,ignore1,ignore2,ignore3,ignore4): + print "Removing timer" + gobject.source_remove(self.timer) + self.refresh_stats() + self.schedule_timer() + + def vm_selected(self, selection): + if selection == None or selection.count_selected_rows() == 0: + self.window.get_widget("vm-delete").set_sensitive(False) + self.window.get_widget("vm-details").set_sensitive(False) + self.window.get_widget("vm-open").set_sensitive(False) + self.window.get_widget("menu_edit_delete").set_sensitive(False) + self.window.get_widget("menu_edit_details").set_sensitive(False) + else: + self.window.get_widget("vm-delete").set_sensitive(True) + self.window.get_widget("vm-details").set_sensitive(True) + self.window.get_widget("vm-open").set_sensitive(True) + self.window.get_widget("menu_edit_delete").set_sensitive(True) + self.window.get_widget("menu_edit_details").set_sensitive(True) def show_about(self, ignore=None): if self.about == None: self.about = vmmAbout() self.about.show() + def show_preferences(self, ignore=None): + if self.preferences == None: + self.preferences = vmmPreferences(self.conf) + self.preferences.show() + def refresh_stats(self): - self.record_stats() - self.timer = gobject.timeout_add(self.tickrate, self.refresh_stats) + self.stats.tick() vmlist = self.window.get_widget("vm-list") model = vmlist.get_model() - print "Refresh " + str(model.iter_n_children(None)) + for row in range(model.iter_n_children(None)): model.row_changed(str(row), model.iter_nth_child(None, row)) - - def record_stats(self): - print "Record" - doms = self.vmm.listDomainsID() - if doms != None: - for id in self.vmm.listDomainsID(): - vm = self.vmm.lookupByID(id) - info = vm.info() - name = vm.name() - if not(self.stats.has_key(name)): - self.stats[name] = [] - if len(self.stats[name]) > 4: - self.stats[name] = (self.stats[name])[1:len(self.stats[name])] - self.stats[name].append(info) - # XXX why is max-mem wrong for Domain-0 when run as root ?!?!?! - #print info + return 1 + def populate_vms(self): vmlist = self.window.get_widget("vm-list") @@ -105,7 +195,7 @@ class vmmManager: cpuUsageCol = gtk.TreeViewColumn("CPU usage") memoryUsageCol = gtk.TreeViewColumn("Memory usage") diskUsageCol = gtk.TreeViewColumn("Disk usage") - networkUsageCol = gtk.TreeViewColumn("Network traffic") + networkTrafficCol = gtk.TreeViewColumn("Network traffic") name_txt = gtk.CellRendererText() nameCol.pack_start(name_txt, True) @@ -116,27 +206,32 @@ class vmmManager: vmlist.append_column(cpuUsageCol) vmlist.append_column(memoryUsageCol) vmlist.append_column(diskUsageCol) - vmlist.append_column(networkUsageCol) + vmlist.append_column(networkTrafficCol) status_txt = gtk.CellRendererText() statusCol.pack_start(status_txt, True) statusCol.set_cell_data_func(status_txt, self.status_text, None) - + statusCol.set_visible(self.conf.is_vmlist_status_visible()) + cpuUsage_txt = gtk.CellRendererText() cpuUsageCol.pack_start(cpuUsage_txt, True) cpuUsageCol.set_cell_data_func(cpuUsage_txt, self.cpu_usage_text, None) + cpuUsageCol.set_visible(self.conf.is_vmlist_cpu_usage_visible()) memoryUsage_txt = gtk.CellRendererText() memoryUsageCol.pack_start(memoryUsage_txt, True) memoryUsageCol.set_cell_data_func(memoryUsage_txt, self.memory_usage_text, None) + memoryUsageCol.set_visible(self.conf.is_vmlist_memory_usage_visible()) diskUsage_txt = gtk.CellRendererText() diskUsageCol.pack_start(diskUsage_txt, True) diskUsageCol.set_cell_data_func(diskUsage_txt, self.disk_usage_text, None) + diskUsageCol.set_visible(self.conf.is_vmlist_disk_usage_visible()) - networkUsage_txt = gtk.CellRendererText() - networkUsageCol.pack_start(networkUsage_txt, True) - networkUsageCol.set_cell_data_func(networkUsage_txt, self.network_usage_text, None) + networkTraffic_txt = gtk.CellRendererText() + networkTrafficCol.pack_start(networkTraffic_txt, True) + networkTrafficCol.set_cell_data_func(networkTraffic_txt, self.network_usage_text, None) + networkTrafficCol.set_visible(self.conf.is_vmlist_network_traffic_visible()) doms = self.vmm.listDomainsID() if doms != None: @@ -144,79 +239,65 @@ class vmmManager: vm = self.vmm.lookupByID(id) model.append([vm.name()]) - def toggle_status_column(self,menu): + def toggle_status_visible_conf(self, menu): + self.conf.set_vmlist_status_visible(menu.get_active()) + + def toggle_status_visible_widget(self, ignore1, ignore2, ignore3, ignore4): + menu = self.window.get_widget("menu_view_status") vmlist = self.window.get_widget("vm-list") col = vmlist.get_column(1) - col.set_visible(menu.get_active()) + col.set_visible(self.conf.is_vmlist_status_visible()) - def toggle_cpu_column(self,menu): + def toggle_cpu_usage_visible_conf(self, menu): + self.conf.set_vmlist_cpu_usage_visible(menu.get_active()) + + def toggle_cpu_usage_visible_widget(self, ignore1, ignore2, ignore3, ignore4): + menu = self.window.get_widget("menu_view_cpu_usage") vmlist = self.window.get_widget("vm-list") col = vmlist.get_column(2) - col.set_visible(menu.get_active()) + col.set_visible(self.conf.is_vmlist_cpu_usage_visible()) - def toggle_memory_column(self,menu): + def toggle_memory_usage_visible_conf(self, menu): + self.conf.set_vmlist_memory_usage_visible(menu.get_active()) + + def toggle_memory_usage_visible_widget(self, ignore1, ignore2, ignore3, ignore4): + menu = self.window.get_widget("menu_view_memory_usage") vmlist = self.window.get_widget("vm-list") col = vmlist.get_column(3) - col.set_visible(menu.get_active()) + col.set_visible(self.conf.is_vmlist_memory_usage_visible()) - def toggle_disk_column(self,menu): + def toggle_disk_usage_visible_conf(self, menu): + self.conf.set_vmlist_disk_usage_visible(menu.get_active()) + + def toggle_disk_usage_visible_widget(self, ignore1, ignore2, ignore3, ignore4): + menu = self.window.get_widget("menu_view_disk_usage") vmlist = self.window.get_widget("vm-list") col = vmlist.get_column(4) - col.set_visible(menu.get_active()) + col.set_visible(self.conf.is_vmlist_disk_usage_visible()) - def toggle_network_column(self,menu): + def toggle_network_traffic_visible_conf(self, menu): + self.conf.set_vmlist_network_traffic_visible(menu.get_active()) + + def toggle_network_traffic_visible_widget(self, ignore1, ignore2, ignore3, ignore4): + menu = self.window.get_widget("menu_view_network_traffic") vmlist = self.window.get_widget("vm-list") col = vmlist.get_column(5) - col.set_visible(menu.get_active()) + col.set_visible(self.conf.is_vmlist_network_traffic_visible()) def status_text(self, column, cell, model, iter, data): name = model.get_value(iter, 0) - statusRecord = self.stats[name] - info = statusRecord[len(statusRecord)-1] - if info[0] == libvirt.VIR_DOMAIN_NOSTATE: - cell.set_property('text', "Unknown") - elif info[0] == libvirt.VIR_DOMAIN_RUNNING: - cell.set_property('text', "Running") - elif info[0] == libvirt.VIR_DOMAIN_BLOCKED: - cell.set_property('text', "Blocked") - elif info[0] == libvirt.VIR_DOMAIN_PAUSED: - cell.set_property('text', "Paused") - elif info[0] == libvirt.VIR_DOMAIN_SHUTDOWN: - cell.set_property('text', "Shutdown") - elif info[0] == libvirt.VIR_DOMAIN_SHUTOFF: - cell.set_property('text', "Shutoff") - elif info[0] == libvirt.VIR_DOMAIN_CRASHED: - cell.set_property('text', "Crashed") + cell.set_property('text', self.stats.run_status(name)) def cpu_usage_text(self, column, cell, model, iter, data): name = model.get_value(iter, 0) - statusRecord = self.stats[name] - nSample = len(statusRecord) - - if nSample < 2: - cell.set_property('text', "-") - else: - total = 0 - for dom in self.stats.keys(): - last = self.stats[dom][len(self.stats[dom])-2] - current = self.stats[dom][len(self.stats[dom])-1] - total += current[4] - last[4] - - last = statusRecord[len(statusRecord)-2] - current = statusRecord[len(statusRecord)-1] - fraction = current[4] - last[4] - - percentage = fraction * 100.0 / total - - cell.set_property('text',"%2.2f %%" % percentage) + cell.set_property('text', "%2.2f %%" % self.stats.percent_cpu_time(name)) def memory_usage_text(self, column, cell, model, iter, data): name = model.get_value(iter, 0) - statusRecord = self.stats[name] - current = statusRecord[len(statusRecord)-1] - - cell.set_property('text', "%s of %s" % (self.pretty_mem(current[2]), self.pretty_mem(current[1]))) + current = self.stats.current_memory(name) + maximum = self.stats.maximum_memory(name) + cell.set_property('text', "%s of %s" % (self.pretty_mem(current), self.pretty_mem(maximum))) #cell.set_property('text', self.pretty_mem(current[2])) def pretty_mem(self, mem): @@ -232,6 +313,193 @@ class vmmManager: def network_usage_text(self, column, cell, model, iter, data): #cell.set_property('text', "100 bytes/sec") cell.set_property('text', "-") + +class vmmConfig: + def __init__(self): + self.conf = gconf.client_get_default() + self.conf.add_dir (gconf_dir, + gconf.CLIENT_PRELOAD_NONE) + + def is_vmlist_status_visible(self): + return self.conf.get_bool(gconf_dir + "/vmlist-fields/status") + + def is_vmlist_cpu_usage_visible(self): + return self.conf.get_bool(gconf_dir + "/vmlist-fields/cpu_usage") + + def is_vmlist_memory_usage_visible(self): + return self.conf.get_bool(gconf_dir + "/vmlist-fields/memory_usage") + + def is_vmlist_disk_usage_visible(self): + return self.conf.get_bool(gconf_dir + "/vmlist-fields/disk_usage") + + def is_vmlist_network_traffic_visible(self): + return self.conf.get_bool(gconf_dir + "/vmlist-fields/network_traffic") + + + + def set_vmlist_status_visible(self, state): + self.conf.set_bool(gconf_dir + "/vmlist-fields/status", state) + + def set_vmlist_cpu_usage_visible(self, state): + self.conf.set_bool(gconf_dir + "/vmlist-fields/cpu_usage", state) + + def set_vmlist_memory_usage_visible(self, state): + self.conf.set_bool(gconf_dir + "/vmlist-fields/memory_usage", state) + + def set_vmlist_disk_usage_visible(self, state): + self.conf.set_bool(gconf_dir + "/vmlist-fields/disk_usage", state) + + def set_vmlist_network_traffic_visible(self, state): + self.conf.set_bool(gconf_dir + "/vmlist-fields/network_traffic", state) + + + + def on_vmlist_status_visible_changed(self, callback): + self.conf.notify_add(gconf_dir + "/vmlist-fields/status", callback) + + def on_vmlist_cpu_usage_visible_changed(self, callback): + self.conf.notify_add(gconf_dir + "/vmlist-fields/cpu_usage", callback) + + def on_vmlist_memory_usage_visible_changed(self, callback): + self.conf.notify_add(gconf_dir + "/vmlist-fields/memory_usage", callback) + + def on_vmlist_disk_usage_visible_changed(self, callback): + self.conf.notify_add(gconf_dir + "/vmlist-fields/disk_usage", callback) + + def on_vmlist_network_traffic_visible_changed(self, callback): + self.conf.notify_add(gconf_dir + "/vmlist-fields/network_traffic", callback) + + + + def get_stats_update_interval(self): + interval = self.conf.get_int(gconf_dir + "/stats/update-interval") + if interval < 1: + return 1 + return interval + + def get_stats_history_length(self): + history = self.conf.get_int(gconf_dir + "/stats/history-length") + if history < 10: + return 10 + return history + + + def set_stats_update_interval(self, interval): + self.conf.set_int(gconf_dir + "/stats/update-interval", interval) + + def set_stats_history_length(self, length): + self.conf.set_int(gconf_dir + "/stats/history-length", length) + + + def on_stats_update_interval_changed(self, callback): + self.conf.notify_add(gconf_dir + "/stats/update-interval", callback) + + def on_stats_history_length_changed(self, callback): + self.conf.notify_add(gconf_dir + "/stats/history-length", callback) + + +class vmmStats: + def __init__(self, vmm, conf): + self.vmm = vmm + self.vms = {} + self.conf = conf + self.callbacks = { "notify_added": [], "notify_removed": [] } + self.tick() + + def connect_to_signal(self, name, callback): + if not(self.callbacks.has_key(name)): + raise "unknown signal " + name + "requested" + + self.callbacks[name].append(callback) + + def notify_added(self, name): + for cb in self.callbacks["notify_added"]: + cb(name) + + + def notify_removed(self, name): + for cb in self.callbacks["notify_added"]: + cb(name) + + def tick(self): + doms = self.vmm.listDomainsID() + newVms = {} + if doms != None: + for id in self.vmm.listDomainsID(): + vm = self.vmm.lookupByID(id) + newVms[vm.name()] = vm + + for name in self.vms.keys(): + if not(newVms.has_key(name)): + del self.vms[name] + self.notify_removed(name) + + for name in newVms.keys(): + if not(self.vms.has_key(name)): + self.vms[name] = { "handle": newVms[name], + "stats": [] } + self.notify_added(name) + + now = time() + + totalCpuTime = 0 + for name in self.vms.keys(): + info = self.vms[name]["handle"].info() + + if len(self.vms[name]["stats"]) > self.conf.get_stats_history_length(): + self.vms[name]["stats"] = self.vms[name]["stats"][0:len(self.vms[name]["stats"])-1] + + prevCpuTime = 0 + prevTimestamp = 0 + if len(self.vms[name]["stats"]) > 0: + prevTimestamp = self.vms[name]["stats"][0]["timestamp"] + prevCpuTime = self.vms[name]["stats"][0]["absCpuTime"] + + print str(now-prevTimestamp) + print str(info[4]-prevCpuTime) + print str((now - prevTimestamp)*1000 * 1000) + print + pcentCpuTime = (info[4]-prevCpuTime) * 100 / ((now - prevTimestamp)*1000 * 1000*1000) + + newStats = [{ "timestamp": now, + "status": info[0], + "absCpuTime": info[4], + "relCpuTime": (info[4]-prevCpuTime), + "pcentCpuTime": pcentCpuTime, + "currMem": info[2], + "maxMem": info[1] }] + totalCpuTime = totalCpuTime + newStats[0]["relCpuTime"] + newStats.append(self.vms[name]["stats"]) + self.vms[name]["stats"] = newStats + + def current_memory(self, name): + return self.vms[name]["stats"][0]["currMem"] + + def maximum_memory(self, name): + return self.vms[name]["stats"][0]["maxMem"] + + def percent_cpu_time(self, name): + return self.vms[name]["stats"][0]["pcentCpuTime"] + + def run_status(self, name): + status = self.vms[name]["stats"][0]["status"] + if status == libvirt.VIR_DOMAIN_NOSTATE: + return "Idle" + elif status == libvirt.VIR_DOMAIN_RUNNING: + return "Running" + elif status == libvirt.VIR_DOMAIN_BLOCKED: + return "Blocked" + elif status == libvirt.VIR_DOMAIN_PAUSED: + return "Paused" + elif status == libvirt.VIR_DOMAIN_SHUTDOWN: + return "Shutdown" + elif status == libvirt.VIR_DOMAIN_SHUTOFF: + return "Shutoff" + elif status == libvirt.VIR_DOMAIN_CRASHED: + return "Crashed" + else: + raise "Unknown status code" + # Run me! def main():