Merge lp:~bigkevmcd/landscape-client/vm-info-in-registration into lp:~landscape/landscape-client/trunk

[Kevin McDermott]

Register with vm-info so that we add the computer to the correct licence if possible...

[Free Ekanayaka (free.ekanayaka)]

Looks good! +1

[1]

Maybe instead of mocking get_vm_info we could add:

class Registration(object):

    root_path = "/"

and override it in the tests.

review: Approve

[Thomas Herve (therve)]

+1!

review: Approve

=== modified file 'landscape/broker/registration.py'
--- landscape/broker/registration.py	2011-01-12 16:30:14 +0000
+++ landscape/broker/registration.py	2011-06-11 00:36:37 +0000
@@ -9,6 +9,7 @@
 from landscape.lib.fetch import fetch, FetchError
 from landscape.lib.tag import is_valid_tag_list
 from landscape.lib.network import get_fqdn
+from landscape.lib.vm_info import get_vm_info
 
 
 EC2_HOST = "169.254.169.254"
@@ -279,7 +280,8 @@
                            "account_name": id.account_name,
                            "registration_password": id.registration_password,
                            "hostname": get_fqdn(),
-                           "tags": tags}
+                           "tags": tags,
+                           "vm-info": get_vm_info()}
                 self._exchange.send(message)
             else:
                 self._reactor.fire("registration-failed")

=== modified file 'landscape/broker/tests/test_registration.py'
--- landscape/broker/tests/test_registration.py	2011-01-12 16:30:14 +0000
+++ landscape/broker/tests/test_registration.py	2011-06-11 00:36:37 +0000
@@ -16,6 +16,7 @@
 from landscape.lib.bpickle import dumps
 from landscape.lib.fetch import HTTPCodeError, FetchError
 from landscape.lib.persist import Persist
+from landscape.lib.vm_info import get_vm_info
 from landscape.configuration import print_text
 
 
@@ -154,7 +155,34 @@
                               "account_name": "account_name",
                               "registration_password": None,
                               "hostname": "ooga.local",
-                              "tags": None}])
+                              "tags": None,
+                              "vm-info": get_vm_info()}])
+        self.assertEqual(self.logfile.getvalue().strip(),
+                         "INFO: Queueing message to register with account "
+                         "'account_name' without a password.")
+
+    def test_queue_message_on_exchange_with_vm_info(self):
+        """
+        When a computer_title and account_name are available, no
+        secure_id is set, and an exchange is about to happen,
+        queue a registration message.
+        """
+        get_vm_info_mock = self.mocker.replace(get_vm_info)
+        get_vm_info_mock()
+        self.mocker.result("vmware")
+        self.mocker.replay()
+        self.mstore.set_accepted_types(["register"])
+        self.config.computer_title = "Computer Title"
+        self.config.account_name = "account_name"
+        self.reactor.fire("pre-exchange")
+        self.assertMessages(self.mstore.get_pending_messages(),
+                            [{"type": "register",
+                              "computer_title": "Computer Title",
+                              "account_name": "account_name",
+                              "registration_password": None,
+                              "hostname": "ooga.local",
+                              "tags": None,
+                              "vm-info": u"vmware"}])
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
                          "'account_name' without a password.")
@@ -172,7 +200,8 @@
                               "account_name": "account_name",
                               "registration_password": "SEKRET",
                               "hostname": "ooga.local",
-                              "tags": None}])
+                              "tags": None,
+                              "vm-info": get_vm_info()}])
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
                          "'account_name' with a password.")
@@ -194,7 +223,8 @@
                               "account_name": "account_name",
                               "registration_password": "SEKRET",
                               "hostname": "ooga.local",
-                              "tags": u"computer,tag"}])
+                              "tags": u"computer,tag",
+                              "vm-info": get_vm_info()}])
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
                          "'account_name' and tags computer,tag "
@@ -219,7 +249,8 @@
                               "account_name": "account_name",
                               "registration_password": "SEKRET",
                               "hostname": "ooga.local",
-                              "tags": None}])
+                              "tags": None,
+                              "vm-info": get_vm_info()}])
         self.assertEqual(self.logfile.getvalue().strip(),
                          "ERROR: Invalid tags provided for cloud "
                          "registration.\n    "
@@ -244,7 +275,8 @@
               "account_name": "account_name",
               "registration_password": "SEKRET",
               "hostname": "ooga.local",
-              "tags": u"prova\N{LATIN SMALL LETTER J WITH CIRCUMFLEX}o"}])
+              "tags": u"prova\N{LATIN SMALL LETTER J WITH CIRCUMFLEX}o",
+              "vm-info": get_vm_info()}])
         self.assertEqual(self.logfile.getvalue().strip(),
                          "INFO: Queueing message to register with account "
                          "'account_name' and tags prova\xc4\xb5o "
@@ -433,6 +465,7 @@
                               "account_name": "account_name",
                               "registration_password": "SEKRET",
                               "hostname": socket.getfqdn(),
+                              "vm-info": get_vm_info(),
                               "tags": None}])
 
 
@@ -828,6 +861,7 @@
                               "account_name": u"onward",
                               "registration_password": u"password",
                               "hostname": socket.getfqdn(),
+                              "vm-info": get_vm_info(),
                               "tags": None}])
 
     def test_should_register_in_cloud(self):

=== added file 'landscape/lib/tests/test_vm_info.py'
--- landscape/lib/tests/test_vm_info.py	1970-01-01 00:00:00 +0000
+++ landscape/lib/tests/test_vm_info.py	2011-06-11 00:36:37 +0000
@@ -0,0 +1,121 @@
+import os
+
+from landscape.tests.helpers import LandscapeTest
+
+from landscape.lib.vm_info import get_vm_info
+
+
+class VMInfoTest(LandscapeTest):
+
+    sample_kvm_cpuinfo = """
+processor	: 0
+vendor_id	: GenuineIntel
+cpu family	: 6
+model		: 2
+model name	: QEMU Virtual CPU version 0.14.0
+stepping	: 3
+cpu MHz		: 2653.112
+cache size	: 4096 KB
+fpu		: yes
+fpu_exception	: yes
+cpuid level	: 4
+wp		: yes
+flags		: fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca
+bogomips	: 5306.22
+clflush size	: 64
+cache_alignment	: 64
+address sizes	: 40 bits physical, 48 bits virtual
+power management:
+"""
+
+    def test_get_vm_info_empty_when_no_virtualization_is_found(self):
+        """
+        L{get_vm_info} should be empty when there's no virtualisation.
+        """
+        root_path = self.makeDir()
+        self.assertEqual(u"", get_vm_info(root_path=root_path))
+
+    def test_get_vm_info_is_openvz_when_proc_vz_exists(self):
+        """
+        L{get_vm_info} should return 'openvz' when /proc/vz exists.
+        """
+        root_path = self.makeDir()
+        proc_path = os.path.join(root_path, "proc")
+        self.makeDir(path=proc_path)
+
+        proc_vz_path = os.path.join(proc_path, "vz")
+        self.makeFile(path=proc_vz_path, content="foo")
+
+        self.assertEqual("openvz", get_vm_info(root_path=root_path))
+
+    def test_get_vm_info_is_xen_when_proc_sys_xen_exists(self):
+        """
+        L{get_vm_info} should return 'xen' when /proc/sys/xen exists.
+        """
+        root_path = self.makeDir()
+        proc_path = os.path.join(root_path, "proc")
+        self.makeDir(path=proc_path)
+
+        proc_sys_path = os.path.join(proc_path, "sys")
+        self.makeDir(path=proc_sys_path)
+
+        proc_sys_xen_path = os.path.join(proc_sys_path, "xen")
+        self.makeFile(path=proc_sys_xen_path, content="foo")
+
+        self.assertEqual("xen", get_vm_info(root_path=root_path))
+
+    def test_get_vm_info_is_xen_when_sys_bus_xen_exists(self):
+        """
+        L{get_vm_info} should return 'xen' when /sys/bus/xen exists.
+        """
+        root_path = self.makeDir()
+        sys_path = os.path.join(root_path, "sys")
+        self.makeDir(path=sys_path)
+
+        sys_bus_path = os.path.join(sys_path, "bus")
+        self.makeDir(path=sys_bus_path)
+
+        sys_bus_xen_path = os.path.join(sys_bus_path, "xen")
+        self.makeFile(path=sys_bus_xen_path, content="foo")
+
+        self.assertEqual("xen", get_vm_info(root_path=root_path))
+
+    def test_get_vm_info_is_xen_when_proc_xen_exists(self):
+        """
+        L{get_vm_info} should return 'xen' when /proc/xen exists.
+        """
+        root_path = self.makeDir()
+        proc_path = os.path.join(root_path, "proc")
+        self.makeDir(path=proc_path)
+
+        proc_xen_path = os.path.join(proc_path, "xen")
+        self.makeFile(path=proc_xen_path, content="foo")
+
+        self.assertEqual("xen", get_vm_info(root_path=root_path))
+
+    def test_get_vminfo_is_kvm_when_qemu_is_found_in_proc_cpuinfo(self):
+        """
+        L{get_vm_info} should return 'kvm' when QEMU Virtual CPU is found in
+        /proc/cpuinfo.
+        """
+        root_path = self.makeDir()
+        proc_path = os.path.join(root_path, "proc")
+        self.makeDir(path=proc_path)
+
+        cpuinfo_path = os.path.join(proc_path, "cpuinfo")
+        self.makeFile(path=cpuinfo_path, content=self.sample_kvm_cpuinfo)
+
+        self.assertEqual("kvm", get_vm_info(root_path=root_path))
+
+    def test_get_vm_info_is_empty_when_qemu_is_not_found_in_proc_cpuinfo(self):
+        """
+        L{get_vm_info} should have an empty string when QEMU Virtual CPU is not
+        found in /proc/cpuinfo.
+        """
+        root_path = self.makeDir()
+        proc_path = os.path.join(root_path, "proc")
+        self.makeDir(path=proc_path)
+
+        cpuinfo_path = os.path.join(proc_path, "cpuinfo")
+        self.makeFile(path=cpuinfo_path, content="foo")
+        self.assertEqual(u"", get_vm_info(root_path=root_path))

=== added file 'landscape/lib/vm_info.py'
--- landscape/lib/vm_info.py	1970-01-01 00:00:00 +0000
+++ landscape/lib/vm_info.py	2011-06-11 00:36:37 +0000
@@ -0,0 +1,39 @@
+"""
+Network introspection utilities using ioctl and the /proc filesystem.
+"""
+import os
+
+
+def get_vm_info(root_path="/"):
+    """
+    This is a utility that returns the virtualization type
+
+    It loops through some possible configurations and return a string with
+    the name of the technology being used or None if there's no match
+    """
+    virt_info = ""
+
+    def join_root_path(path):
+        return os.path.join(root_path, path)
+
+    xen_paths = ["proc/sys/xen", "sys/bus/xen", "proc/xen"]
+    xen_paths = map(join_root_path, xen_paths)
+
+    vz_path = os.path.join(root_path, "proc/vz")
+    if os.path.exists(vz_path):
+        virt_info = "openvz"
+
+    elif filter(os.path.exists, xen_paths):
+        virt_info = "xen"
+
+    cpu_info_path = os.path.join(root_path, "proc/cpuinfo")
+    if os.path.exists(cpu_info_path):
+        try:
+            fd = open(cpu_info_path)
+            cpuinfo = fd.read()
+            if "QEMU Virtual CPU" in cpuinfo:
+                virt_info = "kvm"
+        finally:
+            fd.close()
+
+    return virt_info

=== modified file 'landscape/message_schemas.py'
--- landscape/message_schemas.py	2011-05-12 10:21:22 +0000
+++ landscape/message_schemas.py	2011-06-11 00:36:37 +0000
@@ -68,11 +68,10 @@
     "computer-info",
     {"hostname": utf8,
      "total-memory": Int(),
-     "total-swap": Int(),
-     "vm-info": String()},
+     "total-swap": Int()},
     # Not sure why these are all optional, but it's explicitly tested
     # in the server
-    optional=["hostname", "total-memory", "total-swap", "vm-info"])
+    optional=["hostname", "total-memory", "total-swap"])
 
 DISTRIBUTION_INFO = Message(
     "distribution-info",
@@ -139,9 +138,10 @@
      "computer_title": utf8,
      "hostname": utf8,
      "account_name": utf8,
-     "tags": Any(utf8, Constant(None))},
+     "tags": Any(utf8, Constant(None)),
+     "vm-info": String()},
     # hostname wasn't around in old versions
-    optional=["registration_password", "hostname", "tags"])
+    optional=["registration_password", "hostname", "tags", "vm-info"])
 
 REGISTER_CLOUD_VM = Message(
     "register-cloud-vm",

=== modified file 'landscape/monitor/computerinfo.py'
--- landscape/monitor/computerinfo.py	2011-04-25 17:56:33 +0000
+++ landscape/monitor/computerinfo.py	2011-06-11 00:36:37 +0000
@@ -1,5 +1,4 @@
 import logging
-import os
 
 from landscape.lib.lsb_release import LSB_RELEASE_FILENAME, parse_lsb_release
 from landscape.lib.network import get_fqdn
@@ -60,8 +59,6 @@
         self._add_if_new(message, "total-memory",
                          total_memory)
         self._add_if_new(message, "total-swap", total_swap)
-        vm_info = self._get_vm_info()
-        self._add_if_new(message, "vm-info", vm_info)
         return message
 
     def _add_if_new(self, message, key, value):
@@ -95,37 +92,3 @@
         message = {}
         message.update(parse_lsb_release(self._lsb_release_filename))
         return message
-
-    def _get_vm_info(self):
-        """
-        This is a utility that returns the virtualization type
-
-        It loops through some possible configurations and return a string with
-        the name of the technology being used or None if there's no match
-        """
-        virt_info = ""
-
-        def join_root_path(path):
-            return os.path.join(self._root_path, path)
-
-        xen_paths = ["proc/sys/xen", "sys/bus/xen", "proc/xen"]
-        xen_paths = map(join_root_path, xen_paths)
-
-        vz_path = os.path.join(self._root_path, "proc/vz")
-        if os.path.exists(vz_path):
-            virt_info = "openvz"
-
-        elif filter(os.path.exists, xen_paths):
-            virt_info = "xen"
-
-        cpu_info_path = os.path.join(self._root_path, "proc/cpuinfo")
-        if os.path.exists(cpu_info_path):
-            try:
-                fd = open(cpu_info_path)
-                cpuinfo = fd.read()
-                if "QEMU Virtual CPU" in cpuinfo:
-                    virt_info = "kvm"
-            finally:
-                fd.close()
-
-        return virt_info

=== modified file 'landscape/monitor/tests/test_computerinfo.py'
--- landscape/monitor/tests/test_computerinfo.py	2011-04-25 17:56:33 +0000
+++ landscape/monitor/tests/test_computerinfo.py	2011-06-11 00:36:37 +0000
@@ -1,5 +1,4 @@
 import re
-import os
 
 from landscape.monitor.computerinfo import ComputerInfo
 from landscape.tests.helpers import LandscapeTest, MonitorHelper
@@ -45,27 +44,6 @@
 VmallocChunk:   107432 kB
 """
 
-    sample_kvm_cpuinfo = """
-processor	: 0
-vendor_id	: GenuineIntel
-cpu family	: 6
-model		: 2
-model name	: QEMU Virtual CPU version 0.14.0
-stepping	: 3
-cpu MHz		: 2653.112
-cache size	: 4096 KB
-fpu		: yes
-fpu_exception	: yes
-cpuid level	: 4
-wp		: yes
-flags		: fpu de pse tsc msr pae mce cx8 apic sep mtrr pge mca
-bogomips	: 5306.22
-clflush size	: 64
-cache_alignment	: 64
-address sizes	: 40 bits physical, 48 bits virtual
-power management:
-"""
-
     def setUp(self):
         LandscapeTest.setUp(self)
         self.lsb_release_filename = self.makeFile(SAMPLE_LSB_RELEASE)
@@ -302,7 +280,7 @@
         plugin.exchange()
         computer_info = {"type": "computer-info", "hostname": "ooga.local",
                          "timestamp": 0, "total-memory": 1510,
-                         "total-swap": 1584, "vm-info": ""}
+                         "total-swap": 1584}
         dist_info = {"type": "distribution-info",
                      "code-name": "dapper", "description": "Ubuntu 6.06.1 LTS",
                      "distributor-id": "Ubuntu", "release": "6.06"}
@@ -347,146 +325,3 @@
 
         self.mstore.set_accepted_types(["distribution-info", "computer-info"])
         self.assertMessages(list(self.mstore.get_pending_messages()), [])
-
-    def test_vminfo_empty_when_no_virtualization_is_found(self):
-        """
-        L{ComputerInfo} should always have the vm-info key even when no
-        virtualization is used.
-
-        And it should be an empty string.
-        """
-        self.mstore.set_accepted_types(["computer-info"])
-        root_path = self.makeDir()
-        plugin = ComputerInfo(root_path=root_path)
-        self.monitor.add(plugin)
-
-        plugin.exchange()
-        message = self.mstore.get_pending_messages()[0]
-        self.assertTrue("vm-info" in message)
-        self.assertEqual("", message["vm-info"])
-
-    def test_vminfo_is_openvz_when_proc_vz_exists(self):
-        """
-        L{ComputerInfo} should have 'openvz' as the value of vm-info when
-        /proc/vz exists.
-        """
-        root_path = self.makeDir()
-        proc_path = os.path.join(root_path, "proc")
-        self.makeDir(path=proc_path)
-
-        proc_vz_path = os.path.join(proc_path, "vz")
-        self.makeFile(path=proc_vz_path, content="foo")
-
-        self.mstore.set_accepted_types(["computer-info"])
-        plugin = ComputerInfo(root_path=root_path)
-        self.monitor.add(plugin)
-
-        plugin.exchange()
-        message = self.mstore.get_pending_messages()[0]
-        self.assertEquals('openvz', message["vm-info"])
-
-    def test_vminfo_is_xen_when_proc_sys_xen_exists(self):
-        """
-        L{ComputerInfo} should have 'xen' as the value of vm-info when
-        /proc/sys/xen exists.
-        """
-        root_path = self.makeDir()
-        proc_path = os.path.join(root_path, "proc")
-        self.makeDir(path=proc_path)
-
-        proc_sys_path = os.path.join(proc_path, "sys")
-        self.makeDir(path=proc_sys_path)
-
-        proc_sys_xen_path = os.path.join(proc_sys_path, "xen")
-        self.makeFile(path=proc_sys_xen_path, content="foo")
-
-        self.mstore.set_accepted_types(["computer-info"])
-        plugin = ComputerInfo(root_path=root_path)
-        self.monitor.add(plugin)
-
-        plugin.exchange()
-        message = self.mstore.get_pending_messages()[0]
-        self.assertEquals('xen', message["vm-info"])
-
-    def test_vminfo_is_xen_when_sys_bus_xen_exists(self):
-        """
-        L{ComputerInfo} should have 'xen' as value of vm-info when
-        /sys/bus/xen exists
-        """
-        root_path = self.makeDir()
-        sys_path = os.path.join(root_path, "sys")
-        self.makeDir(path=sys_path)
-
-        sys_bus_path = os.path.join(sys_path, "bus")
-        self.makeDir(path=sys_bus_path)
-
-        sys_bus_xen_path = os.path.join(sys_bus_path, "xen")
-        self.makeFile(path=sys_bus_xen_path, content="foo")
-
-        self.mstore.set_accepted_types(["computer-info"])
-        plugin = ComputerInfo(root_path=root_path)
-        self.monitor.add(plugin)
-
-        plugin.exchange()
-        message = self.mstore.get_pending_messages()[0]
-        self.assertEquals('xen', message["vm-info"])
-
-    def test_vminfo_is_xen_when_proc_xen_exists(self):
-        """
-        L{ComputerInfo} should have 'xen' as value of vm-info when
-        /proc/xen exists.
-        """
-        root_path = self.makeDir()
-        proc_path = os.path.join(root_path, "proc")
-        self.makeDir(path=proc_path)
-
-        proc_xen_path = os.path.join(proc_path, "xen")
-        self.makeFile(path=proc_xen_path, content="foo")
-
-        self.mstore.set_accepted_types(["computer-info"])
-        plugin = ComputerInfo(root_path=root_path)
-        self.monitor.add(plugin)
-
-        plugin.exchange()
-        message = self.mstore.get_pending_messages()[0]
-        self.assertEquals('xen', message["vm-info"])
-
-    def test_vminfo_is_kvm_when_qemu_is_found_in_proc_cpuinfo(self):
-        """
-        L{ComputerInfo} should have 'kvm' as value of vm-info when
-        QEMU Virtual CPU is found in /proc/cpuinfo.
-        """
-        root_path = self.makeDir()
-        proc_path = os.path.join(root_path, "proc")
-        self.makeDir(path=proc_path)
-
-        cpuinfo_path = os.path.join(proc_path, "cpuinfo")
-        self.makeFile(path=cpuinfo_path, content=self.sample_kvm_cpuinfo)
-
-        self.mstore.set_accepted_types(["computer-info"])
-        plugin = ComputerInfo(root_path=root_path)
-        self.monitor.add(plugin)
-
-        plugin.exchange()
-        message = self.mstore.get_pending_messages()[0]
-        self.assertEqual("kvm", message["vm-info"])
-
-    def test_vminfo_is_empty_when_qemu_is_not_found_in_proc_cpuinfo(self):
-        """
-        L{ComputerInfo} should have an empty string as value of vm-info when
-        QEMU Virtual CPU is not found in /proc/cpuinfo.
-        """
-        root_path = self.makeDir()
-        proc_path = os.path.join(root_path, "proc")
-        self.makeDir(path=proc_path)
-
-        cpuinfo_path = os.path.join(proc_path, "cpuinfo")
-        self.makeFile(path=cpuinfo_path, content="foo")
-
-        self.mstore.set_accepted_types(["computer-info"])
-        plugin = ComputerInfo(root_path=root_path)
-        self.monitor.add(plugin)
-
-        plugin.exchange()
-        message = self.mstore.get_pending_messages()[0]
-        self.assertEqual("", message["vm-info"])