[Kimchi-devel] [PATCH 16/23] refactor model: Create a separated model for vm resource

Aline Manera alinefm at linux.vnet.ibm.com
Wed Jan 29 23:34:57 UTC 2014


From: Aline Manera <alinefm at br.ibm.com>

The model implementation for vm and its sub-resources were added to
model_/vms.py

Signed-off-by: Aline Manera <alinefm at br.ibm.com>
---
 src/kimchi/model_/utils.py |   33 ++++
 src/kimchi/model_/vms.py   |  447 ++++++++++++++++++++++++++++++++++++++++++++
 src/kimchi/utils.py        |    4 +
 3 files changed, 484 insertions(+)
 create mode 100644 src/kimchi/model_/utils.py
 create mode 100644 src/kimchi/model_/vms.py

diff --git a/src/kimchi/model_/utils.py b/src/kimchi/model_/utils.py
new file mode 100644
index 0000000..a27b867
--- /dev/null
+++ b/src/kimchi/model_/utils.py
@@ -0,0 +1,33 @@
+#
+# Project Kimchi
+#
+# Copyright IBM, Corp. 2013
+#
+# Authors:
+#  Aline Manera <alinefm at linux.vnet.ibm.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+
+from kimchi.exception import OperationFailed
+
+
+def get_vm_name(vm_name, t_name, name_list):
+    if vm_name:
+        return vm_name
+    for i in xrange(1, 1000):
+        vm_name = "%s-vm-%i" % (t_name, i)
+        if vm_name not in name_list:
+            return vm_name
+    raise OperationFailed("Unable to choose a VM name")
diff --git a/src/kimchi/model_/vms.py b/src/kimchi/model_/vms.py
new file mode 100644
index 0000000..3de7fde
--- /dev/null
+++ b/src/kimchi/model_/vms.py
@@ -0,0 +1,447 @@
+#
+# Project Kimchi
+#
+# Copyright IBM, Corp. 2013
+#
+# Authors:
+#  Aline Manera <alinefm at linux.vnet.ibm.com>
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
+
+import os
+import time
+import uuid
+from xml.etree import ElementTree
+
+import libvirt
+from cherrypy.process.plugins import BackgroundTask
+
+from kimchi import vnc
+from kimchi import xmlutils
+from kimchi.exception import InvalidOperation, InvalidParameter
+from kimchi.exception import NotFoundError, OperationFailed
+from kimchi.model_.config import CapabilitiesModel
+from kimchi.model_.templates import TemplateModel
+from kimchi.model_.utils import get_vm_name
+from kimchi.screenshot import VMScreenshot
+from kimchi.utils import template_name_from_uri
+
+
+DOM_STATE_MAP = {0: 'nostate',
+                 1: 'running',
+                 2: 'blocked',
+                 3: 'paused',
+                 4: 'shutdown',
+                 5: 'shutoff',
+                 6: 'crashed'}
+
+GUESTS_STATS_INTERVAL = 5
+VM_STATIC_UPDATE_PARAMS = {'name': './name'}
+VM_LIVE_UPDATE_PARAMS = {}
+
+stats = {}
+
+
+class VMsModel(object):
+    def __init__(self, **kargs):
+        self.conn = kargs['conn']
+        self.objstore = kargs['objstore']
+        self.caps = CapabilitiesModel()
+        self.guests_stats_thread = BackgroundTask(GUESTS_STATS_INTERVAL,
+                                                  self._update_guests_stats)
+        self.guests_stats_thread.start()
+
+    def _update_guests_stats(self):
+        vm_list = self.get_list()
+
+        for name in vm_list:
+            dom = VMModel.get_vm(name, self.conn)
+            vm_uuid = dom.UUIDString()
+            info = dom.info()
+            state = DOM_STATE_MAP[info[0]]
+
+            if state != 'running':
+                stats[vm_uuid] = {}
+                continue
+
+            if stats.get(vm_uuid, None) is None:
+                stats[vm_uuid] = {}
+
+            timestamp = time.time()
+            prevStats = stats.get(vm_uuid, {})
+            seconds = timestamp - prevStats.get('timestamp', 0)
+            stats[vm_uuid].update({'timestamp': timestamp})
+
+            self._get_percentage_cpu_usage(vm_uuid, info, seconds)
+            self._get_network_io_rate(vm_uuid, dom, seconds)
+            self._get_disk_io_rate(vm_uuid, dom, seconds)
+
+    def _get_percentage_cpu_usage(self, vm_uuid, info, seconds):
+        prevCpuTime = stats[vm_uuid].get('cputime', 0)
+
+        cpus = info[3]
+        cpuTime = info[4] - prevCpuTime
+
+        base = (((cpuTime) * 100.0) / (seconds * 1000.0 * 1000.0 * 1000.0))
+        percentage = max(0.0, min(100.0, base / cpus))
+
+        stats[vm_uuid].update({'cputime': info[4], 'cpu': percentage})
+
+    def _get_network_io_rate(self, vm_uuid, dom, seconds):
+        prevNetRxKB = stats[vm_uuid].get('netRxKB', 0)
+        prevNetTxKB = stats[vm_uuid].get('netTxKB', 0)
+        currentMaxNetRate = stats[vm_uuid].get('max_net_io', 100)
+
+        rx_bytes = 0
+        tx_bytes = 0
+
+        tree = ElementTree.fromstring(dom.XMLDesc(0))
+        for target in tree.findall('devices/interface/target'):
+            dev = target.get('dev')
+            io = dom.interfaceStats(dev)
+            rx_bytes += io[0]
+            tx_bytes += io[4]
+
+        netRxKB = float(rx_bytes) / 1000
+        netTxKB = float(tx_bytes) / 1000
+
+        rx_stats = (netRxKB - prevNetRxKB) / seconds
+        tx_stats = (netTxKB - prevNetTxKB) / seconds
+
+        rate = rx_stats + tx_stats
+        max_net_io = round(max(currentMaxNetRate, int(rate)), 1)
+
+        stats[vm_uuid].update({'net_io': rate, 'max_net_io': max_net_io,
+                               'netRxKB': netRxKB, 'netTxKB': netTxKB})
+
+    def _get_disk_io_rate(self, vm_uuid, dom, seconds):
+        prevDiskRdKB = stats[vm_uuid].get('diskRdKB', 0)
+        prevDiskWrKB = stats[vm_uuid].get('diskWrKB', 0)
+        currentMaxDiskRate = stats[vm_uuid].get('max_disk_io', 100)
+
+        rd_bytes = 0
+        wr_bytes = 0
+
+        tree = ElementTree.fromstring(dom.XMLDesc(0))
+        for target in tree.findall("devices/disk/target"):
+            dev = target.get("dev")
+            io = dom.blockStats(dev)
+            rd_bytes += io[1]
+            wr_bytes += io[3]
+
+        diskRdKB = float(rd_bytes) / 1024
+        diskWrKB = float(wr_bytes) / 1024
+
+        rd_stats = (diskRdKB - prevDiskRdKB) / seconds
+        wr_stats = (diskWrKB - prevDiskWrKB) / seconds
+
+        rate = rd_stats + wr_stats
+        max_disk_io = round(max(currentMaxDiskRate, int(rate)), 1)
+
+        stats[vm_uuid].update({'disk_io': rate,
+                               'max_disk_io': max_disk_io,
+                               'diskRdKB': diskRdKB,
+                               'diskWrKB': diskWrKB})
+
+    def create(self, params):
+        conn = self.conn.get()
+        t_name = template_name_from_uri(params['template'])
+        vm_uuid = str(uuid.uuid4())
+        vm_list = self.get_list()
+        name = get_vm_name(params.get('name'), t_name, vm_list)
+        # incoming text, from js json, is unicode, do not need decode
+        if name in vm_list:
+            raise InvalidOperation("VM already exists")
+
+        vm_overrides = dict()
+        pool_uri = params.get('storagepool')
+        if pool_uri:
+            vm_overrides['storagepool'] = pool_uri
+        t = TemplateModel.get_template(t_name, self.objstore, self.conn,
+                                       vm_overrides)
+
+        if not self.caps.qemu_stream and t.info.get('iso_stream', False):
+            err = "Remote ISO image is not supported by this server."
+            raise InvalidOperation(err)
+
+        t.validate()
+        vol_list = t.fork_vm_storage(vm_uuid)
+
+        # Store the icon for displaying later
+        icon = t.info.get('icon')
+        if icon:
+            with self.objstore as session:
+                session.store('vm', vm_uuid, {'icon': icon})
+
+        libvirt_stream = False
+        if len(self.caps.libvirt_stream_protocols) == 0:
+            libvirt_stream = True
+
+        graphics = params.get('graphics')
+        xml = t.to_vm_xml(name, vm_uuid,
+                          libvirt_stream=libvirt_stream,
+                          qemu_stream_dns=self.caps.qemu_stream_dns,
+                          graphics=graphics)
+
+        try:
+            conn.defineXML(xml.encode('utf-8'))
+        except libvirt.libvirtError as e:
+            for v in vol_list:
+                vol = conn.storageVolLookupByPath(v['path'])
+                vol.delete(0)
+            raise OperationFailed(e.get_error_message())
+
+        return name
+
+    def get_list(self):
+        conn = self.conn.get()
+        names = [dom.name().decode('utf-8') for dom in conn.listAllDomains(0)]
+        return sorted(names, key=unicode.lower)
+
+
+class VMModel(object):
+    def __init__(self, **kargs):
+        self.conn = kargs['conn']
+        self.objstore = kargs['objstore']
+        self.vms = VMsModel(**kargs)
+        self.vmscreenshot = VMScreenshotModel(**kargs)
+
+    def update(self, name, params):
+        dom = self.get_vm(name, self.conn)
+        dom = self._static_vm_update(dom, params)
+        self._live_vm_update(dom, params)
+        return dom.name()
+
+    def _static_vm_update(self, dom, params):
+        state = DOM_STATE_MAP[dom.info()[0]]
+
+        old_xml = new_xml = dom.XMLDesc(0)
+
+        for key, val in params.items():
+            if key in VM_STATIC_UPDATE_PARAMS:
+                xpath = VM_STATIC_UPDATE_PARAMS[key]
+                new_xml = xmlutils.xml_item_update(new_xml, xpath, val)
+
+        try:
+            if 'name' in params:
+                if state == 'running':
+                    err = "VM name only can be updated when vm is powered off."
+                    raise InvalidParameter(err)
+                else:
+                    dom.undefine()
+            conn = self.conn.get()
+            dom = conn.defineXML(new_xml)
+        except libvirt.libvirtError as e:
+            dom = conn.defineXML(old_xml)
+            raise OperationFailed(e.get_error_message())
+        return dom
+
+    def _live_vm_update(self, dom, params):
+        pass
+
+    def lookup(self, name):
+        dom = self.get_vm(name, self.conn)
+        info = dom.info()
+        state = DOM_STATE_MAP[info[0]]
+        screenshot = None
+        graphics = self._vm_get_graphics(name)
+        graphics_type, graphics_listen, graphics_port = graphics
+        graphics_port = graphics_port if state == 'running' else None
+        try:
+            if state == 'running':
+                screenshot = self.vmscreenshot.lookup(name)
+            elif state == 'shutoff':
+                # reset vm stats when it is powered off to avoid sending
+                # incorrect (old) data
+                stats[dom.UUIDString()] = {}
+        except NotFoundError:
+            pass
+
+        with self.objstore as session:
+            try:
+                extra_info = session.get('vm', dom.UUIDString())
+            except NotFoundError:
+                extra_info = {}
+        icon = extra_info.get('icon')
+
+        vm_stats = stats.get(dom.UUIDString(), {})
+        res = {}
+        res['cpu_utilization'] = vm_stats.get('cpu', 0)
+        res['net_throughput'] = vm_stats.get('net_io', 0)
+        res['net_throughput_peak'] = vm_stats.get('max_net_io', 100)
+        res['io_throughput'] = vm_stats.get('disk_io', 0)
+        res['io_throughput_peak'] = vm_stats.get('max_disk_io', 100)
+
+        return {'state': state,
+                'stats': str(res),
+                'uuid': dom.UUIDString(),
+                'memory': info[2] >> 10,
+                'cpus': info[3],
+                'screenshot': screenshot,
+                'icon': icon,
+                'graphics': {"type": graphics_type,
+                             "listen": graphics_listen,
+                             "port": graphics_port}
+                }
+
+    def _vm_get_disk_paths(self, dom):
+        xml = dom.XMLDesc(0)
+        xpath = "/domain/devices/disk[@device='disk']/source/@file"
+        return xmlutils.xpath_get_text(xml, xpath)
+
+    def _vm_exists(self, name):
+        try:
+            self.get_vm(name, self.conn)
+            return True
+        except NotFoundError:
+            return False
+        except Exception, e:
+            err = "Unable to retrieve VM '%s': %s"
+            raise OperationFailed(err % (name, e.message))
+
+    @staticmethod
+    def get_vm(name, conn):
+        conn = conn.get()
+        try:
+            # outgoing text to libvirt, encode('utf-8')
+            return conn.lookupByName(name.encode("utf-8"))
+        except libvirt.libvirtError as e:
+            if e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
+                raise NotFoundError("Virtual Machine '%s' not found" % name)
+            else:
+                raise
+
+    def delete(self, name):
+        if self._vm_exists(name):
+            conn = self.conn.get()
+            dom = self.get_vm(name, self.conn)
+            self._vmscreenshot_delete(dom.UUIDString())
+            paths = self._vm_get_disk_paths(dom)
+            info = self.lookup(name)
+
+            if info['state'] == 'running':
+                self.stop(name)
+
+            dom.undefine()
+
+            for path in paths:
+                vol = conn.storageVolLookupByPath(path)
+                vol.delete(0)
+
+            with self.objstore as session:
+                session.delete('vm', dom.UUIDString(), ignore_missing=True)
+
+            vnc.remove_proxy_token(name)
+
+    def start(self, name):
+        dom = self.get_vm(name, self.conn)
+        dom.create()
+
+    def stop(self, name):
+        if self._vm_exists(name):
+            dom = self.get_vm(name, self.conn)
+            dom.destroy()
+
+    def _vm_get_graphics(self, name):
+        dom = self.get_vm(name, self.conn)
+        xml = dom.XMLDesc(0)
+        expr = "/domain/devices/graphics/@type"
+        res = xmlutils.xpath_get_text(xml, expr)
+        graphics_type = res[0] if res else None
+        expr = "/domain/devices/graphics/@listen"
+        res = xmlutils.xpath_get_text(xml, expr)
+        graphics_listen = res[0] if res else None
+        graphics_port = None
+        if graphics_type:
+            expr = "/domain/devices/graphics[@type='%s']/@port" % graphics_type
+            res = xmlutils.xpath_get_text(xml, expr)
+            graphics_port = int(res[0]) if res else None
+        return graphics_type, graphics_listen, graphics_port
+
+    def connect(self, name):
+        graphics = self._vm_get_graphics(name)
+        graphics_type, graphics_listen, graphics_port = graphics
+        if graphics_port is not None:
+            vnc.add_proxy_token(name, graphics_port)
+        else:
+            raise OperationFailed("Only able to connect to running vm's vnc "
+                                  "graphics.")
+
+    def _vmscreenshot_delete(self, vm_uuid):
+        screenshot = VMScreenshotModel.get_screenshot(vm_uuid, self.objstore,
+                                                      self.conn)
+        screenshot.delete()
+        with self.objstore as session:
+            session.delete('screenshot', vm_uuid)
+
+
+class VMScreenshotModel(object):
+    def __init__(self, **kargs):
+        self.objstore = kargs['objstore']
+        self.conn = kargs['conn']
+
+    def lookup(self, name):
+        dom = VMModel.get_vm(name, self.conn)
+        d_info = dom.info()
+        vm_uuid = dom.UUIDString()
+        if DOM_STATE_MAP[d_info[0]] != 'running':
+            raise NotFoundError('No screenshot for stopped vm')
+
+        screenshot = self.get_screenshot(vm_uuid, self.objstore, self.conn)
+        img_path = screenshot.lookup()
+        # screenshot info changed after scratch generation
+        with self.objstore as session:
+            session.store('screenshot', vm_uuid, screenshot.info)
+        return img_path
+
+    @staticmethod
+    def get_screenshot(vm_uuid, objstore, conn):
+        with objstore as session:
+            try:
+                params = session.get('screenshot', vm_uuid)
+            except NotFoundError:
+                params = {'uuid': vm_uuid}
+                session.store('screenshot', vm_uuid, params)
+        return LibvirtVMScreenshot(params, conn)
+
+
+class LibvirtVMScreenshot(VMScreenshot):
+    def __init__(self, vm_uuid, conn):
+        VMScreenshot.__init__(self, vm_uuid)
+        self.conn = conn
+
+    def _generate_scratch(self, thumbnail):
+        def handler(stream, buf, opaque):
+            fd = opaque
+            os.write(fd, buf)
+
+        fd = os.open(thumbnail, os.O_WRONLY | os.O_TRUNC | os.O_CREAT, 0644)
+        try:
+            conn = self.conn.get()
+            dom = conn.lookupByUUIDString(self.vm_uuid)
+            vm_name = dom.name()
+            stream = conn.newStream(0)
+            dom.screenshot(stream, 0, 0)
+            stream.recvAll(handler, fd)
+        except libvirt.libvirtError:
+            try:
+                stream.abort()
+            except:
+                pass
+            raise NotFoundError("Screenshot not supported for %s" % vm_name)
+        else:
+            stream.finish()
+        finally:
+            os.close(fd)
diff --git a/src/kimchi/utils.py b/src/kimchi/utils.py
index 5345d28..854f187 100644
--- a/src/kimchi/utils.py
+++ b/src/kimchi/utils.py
@@ -47,6 +47,10 @@ def _uri_to_name(collection, uri):
     return m.group(1)
 
 
+def template_name_from_uri(uri):
+    return _uri_to_name('templates', uri)
+
+
 def pool_name_from_uri(uri):
     return _uri_to_name('storagepools', uri)
 
-- 
1.7.10.4




More information about the Kimchi-devel mailing list