Example #1
0
def patch_auth(sudo=True):
    """
    Override the authenticate function with a simple test against an
    internal dict of users and passwords.
    """
    config.set("authentication", "method", "fake")
    FakeUser.sudo = sudo
Example #2
0
def patch_auth(sudo=True):
    """
    Override the authenticate function with a simple test against an
    internal dict of users and passwords.
    """
    config.set("authentication", "method", "fake")
    FakeUser.sudo = sudo
Example #3
0
    def test_vm_memory_hotplug(self):
        config.set("authentication", "method", "pam")
        inst = model.Model(None, objstore_loc=self.tmp_store)
        orig_params = {'name': 'test', 'memory': 1024, 'cdrom': UBUNTU_ISO}
        inst.templates_create(orig_params)

        with RollbackContext() as rollback:
            params = {'name': 'kimchi-vm1',
                      'template': '/plugins/kimchi/templates/test'}
            task1 = inst.vms_create(params)
            inst.task_wait(task1['id'])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  'kimchi-vm1')
            # Start vm
            inst.vm_start('kimchi-vm1')
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff,
                                  'kimchi-vm1')

            # Hotplug memory, only available in Libvirt >= 1.2.14
            params = {'memory': 2048}
            if inst.capabilities_lookup()['mem_hotplug_support']:
                inst.vm_update('kimchi-vm1', params)
                rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                      'kimchi-vm1')
                self.assertEquals(params['memory'],
                                  inst.vm_lookup('kimchi-vm1')['memory'])
            else:
                self.assertRaises(InvalidOperation, inst.vm_update,
                                  'kimchi-vm1', params)
Example #4
0
    def test_vm_memory_hotplug(self):
        config.set("authentication", "method", "pam")
        inst = model.Model(None, objstore_loc=self.tmp_store)
        orig_params = {'name': 'test', 'memory': 1024, 'cdrom': UBUNTU_ISO}
        inst.templates_create(orig_params)

        with RollbackContext() as rollback:
            params = {'name': 'kimchi-vm1',
                      'template': '/plugins/kimchi/templates/test'}
            task1 = inst.vms_create(params)
            inst.task_wait(task1['id'])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  'kimchi-vm1')
            # Start vm
            inst.vm_start('kimchi-vm1')
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff,
                                  'kimchi-vm1')

            # Hotplug memory, only available in Libvirt >= 1.2.14
            params = {'memory': 2048}
            if inst.capabilities_lookup()['mem_hotplug_support']:
                inst.vm_update('kimchi-vm1', params)
                rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                      'kimchi-vm1')
                self.assertEquals(params['memory'],
                                  inst.vm_lookup('kimchi-vm1')['memory'])
            else:
                self.assertRaises(InvalidOperation, inst.vm_update,
                                  'kimchi-vm1', params)
Example #5
0
    def test_vm_memory_hotplug(self):
        config.set("authentication", "method", "pam")
        inst = model.Model(None, objstore_loc=self.tmp_store)
        orig_params = {"name": "test", "memory": 1024, "cdrom": UBUNTU_ISO}
        inst.templates_create(orig_params)

        with RollbackContext() as rollback:
            params = {"name": "kimchi-vm1", "template": "/plugins/kimchi/templates/test"}
            task1 = inst.vms_create(params)
            inst.task_wait(task1["id"])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, "kimchi-vm1")
            # Start vm
            inst.vm_start("kimchi-vm1")
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff, "kimchi-vm1")

            # Hotplug memory, only available in Libvirt >= 1.2.14
            params = {"memory": 2048}
            if inst.capabilities_lookup()["mem_hotplug_support"]:
                inst.vm_update("kimchi-vm1", params)
                rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, "kimchi-vm1")
                self.assertEquals(params["memory"], inst.vm_lookup("kimchi-vm1")["memory"])
            else:
                self.assertRaises(InvalidOperation, inst.vm_update, "kimchi-vm1", params)
Example #6
0
    def test_vm_edit(self):
        config.set("authentication", "method", "pam")
        inst = model.Model(None,
                           objstore_loc=self.tmp_store)

        # template disk format must be qcow2 because vmsnapshot
        # only supports this format
        orig_params = {'name': 'test', 'memory': 1024, 'cpus': 1,
                       'cdrom': UBUNTU_ISO,
                       'disks': [{'size': 1, 'format': 'qcow2', 'pool': {
                           'name': '/plugins/kimchi/storagepools/default'}}]}
        inst.templates_create(orig_params)

        with RollbackContext() as rollback:
            params_1 = {'name': 'kimchi-vm1',
                        'template': '/plugins/kimchi/templates/test'}
            params_2 = {'name': 'kimchi-vm2',
                        'template': '/plugins/kimchi/templates/test'}
            task1 = inst.vms_create(params_1)
            inst.task_wait(task1['id'])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  'kimchi-vm1')
            task2 = inst.vms_create(params_2)
            inst.task_wait(task2['id'])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  'kimchi-vm2')

            vms = inst.vms_get_list()
            self.assertTrue('kimchi-vm1' in vms)

            # make sure "vm_update" works when the domain has a snapshot
            inst.vmsnapshots_create(u'kimchi-vm1')

            # update vm graphics when vm is not running
            inst.vm_update(u'kimchi-vm1',
                           {"graphics": {"passwd": "123456"}})

            inst.vm_start('kimchi-vm1')
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff,
                                  'kimchi-vm1')

            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals('123456', vm_info['graphics']["passwd"])
            self.assertEquals(None, vm_info['graphics']["passwdValidTo"])

            # update vm graphics when vm is running
            inst.vm_update(u'kimchi-vm1',
                           {"graphics": {"passwd": "abcdef",
                                         "passwdValidTo": 20}})
            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals('abcdef', vm_info['graphics']["passwd"])
            self.assertGreaterEqual(20, vm_info['graphics']['passwdValidTo'])

            info = inst.vm_lookup('kimchi-vm1')
            self.assertEquals('running', info['state'])

            params = {'name': 'new-vm'}
            self.assertRaises(InvalidParameter, inst.vm_update,
                              'kimchi-vm1', params)

            # change VM users and groups, when wm is running.
            inst.vm_update(u'kimchi-vm1',
                           {'users': ['root'], 'groups': ['root']})
            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals(['root'], vm_info['users'])
            self.assertEquals(['root'], vm_info['groups'])
            # change VM users and groups by removing all elements,
            # when wm is running.
            inst.vm_update(u'kimchi-vm1', {'users': [], 'groups': []})
            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals([], vm_info['users'])
            self.assertEquals([], vm_info['groups'])

            inst.vm_poweroff('kimchi-vm1')
            self.assertRaises(OperationFailed, inst.vm_update,
                              'kimchi-vm1', {'name': 'kimchi-vm2'})

            params = {'name': u'пeω-∨м', 'cpus': 4, 'memory': 2048}
            inst.vm_update('kimchi-vm1', params)
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  u'пeω-∨м')
            self.assertEquals(info['uuid'], inst.vm_lookup(u'пeω-∨м')['uuid'])
            info = inst.vm_lookup(u'пeω-∨м')
            for key in params.keys():
                self.assertEquals(params[key], info[key])

            # change only VM users - groups are not changed (default is empty)
            users = inst.users_get_list()[:3]
            inst.vm_update(u'пeω-∨м', {'users': users})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['groups'])

            # change only VM groups - users are not changed (default is empty)
            groups = inst.groups_get_list()[:2]
            inst.vm_update(u'пeω-∨м', {'groups': groups})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users and groups by adding a new element to each one
            users.append(pwd.getpwuid(os.getuid()).pw_name)
            groups.append(grp.getgrgid(os.getgid()).gr_name)
            inst.vm_update(u'пeω-∨м', {'users': users, 'groups': groups})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users (wrong value) and groups
            # when an error occurs, everything fails and nothing is changed
            self.assertRaises(InvalidParameter, inst.vm_update, u'пeω-∨м',
                              {'users': ['userdoesnotexist'], 'groups': []})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users and groups (wrong value)
            # when an error occurs, everything fails and nothing is changed
            self.assertRaises(InvalidParameter, inst.vm_update, u'пeω-∨м',
                              {'users': [], 'groups': ['groupdoesnotexist']})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users and groups by removing all elements
            inst.vm_update(u'пeω-∨м', {'users': [], 'groups': []})
            self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['groups'])
Example #7
0
def patch_auth():
    """
    Override the authenticate function with a simple test against an
    internal dict of users and passwords.
    """
    config.set('authentication', 'method', 'fake')
Example #8
0
    def test_vm_edit(self):
        config.set("authentication", "method", "pam")
        inst = model.Model(None,
                           objstore_loc=self.tmp_store)

        # template disk format must be qcow2 because vmsnapshot
        # only supports this format
        orig_params = {'name': 'test', 'memory': 1024, 'cpus': 1,
                       'cdrom': UBUNTU_ISO,
                       'disks': [{'size': 1, 'format': 'qcow2'}]}
        inst.templates_create(orig_params)

        with RollbackContext() as rollback:
            params_1 = {'name': 'kimchi-vm1',
                        'template': '/plugins/kimchi/templates/test'}
            params_2 = {'name': 'kimchi-vm2',
                        'template': '/plugins/kimchi/templates/test'}
            task1 = inst.vms_create(params_1)
            inst.task_wait(task1['id'])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  'kimchi-vm1')
            task2 = inst.vms_create(params_2)
            inst.task_wait(task2['id'])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  'kimchi-vm2')

            vms = inst.vms_get_list()
            self.assertTrue('kimchi-vm1' in vms)

            # make sure "vm_update" works when the domain has a snapshot
            inst.vmsnapshots_create(u'kimchi-vm1')

            # update vm graphics when vm is not running
            inst.vm_update(u'kimchi-vm1',
                           {"graphics": {"passwd": "123456"}})

            inst.vm_start('kimchi-vm1')
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff,
                                  'kimchi-vm1')

            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals('123456', vm_info['graphics']["passwd"])
            self.assertEquals(None, vm_info['graphics']["passwdValidTo"])

            # update vm graphics when vm is running
            inst.vm_update(u'kimchi-vm1',
                           {"graphics": {"passwd": "abcdef",
                                         "passwdValidTo": 20}})
            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals('abcdef', vm_info['graphics']["passwd"])
            self.assertGreaterEqual(20, vm_info['graphics']['passwdValidTo'])

            info = inst.vm_lookup('kimchi-vm1')
            self.assertEquals('running', info['state'])

            params = {'name': 'new-vm'}
            self.assertRaises(InvalidParameter, inst.vm_update,
                              'kimchi-vm1', params)

            # change VM users and groups, when wm is running.
            inst.vm_update(u'kimchi-vm1',
                           {'users': ['root'], 'groups': ['root']})
            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals(['root'], vm_info['users'])
            self.assertEquals(['root'], vm_info['groups'])
            # change VM users and groups by removing all elements,
            # when wm is running.
            inst.vm_update(u'kimchi-vm1', {'users': [], 'groups': []})
            vm_info = inst.vm_lookup(u'kimchi-vm1')
            self.assertEquals([], vm_info['users'])
            self.assertEquals([], vm_info['groups'])

            inst.vm_poweroff('kimchi-vm1')
            self.assertRaises(OperationFailed, inst.vm_update,
                              'kimchi-vm1', {'name': 'kimchi-vm2'})

            params = {'name': u'пeω-∨м', 'cpus': 4, 'memory': 2048}
            inst.vm_update('kimchi-vm1', params)
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete,
                                  u'пeω-∨м')
            self.assertEquals(info['uuid'], inst.vm_lookup(u'пeω-∨м')['uuid'])
            info = inst.vm_lookup(u'пeω-∨м')
            for key in params.keys():
                self.assertEquals(params[key], info[key])

            # change only VM users - groups are not changed (default is empty)
            users = inst.users_get_list()[:3]
            inst.vm_update(u'пeω-∨м', {'users': users})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['groups'])

            # change only VM groups - users are not changed (default is empty)
            groups = inst.groups_get_list()[:2]
            inst.vm_update(u'пeω-∨м', {'groups': groups})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users and groups by adding a new element to each one
            users.append(pwd.getpwuid(os.getuid()).pw_name)
            groups.append(grp.getgrgid(os.getgid()).gr_name)
            inst.vm_update(u'пeω-∨м', {'users': users, 'groups': groups})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users (wrong value) and groups
            # when an error occurs, everything fails and nothing is changed
            self.assertRaises(InvalidParameter, inst.vm_update, u'пeω-∨м',
                              {'users': ['userdoesnotexist'], 'groups': []})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users and groups (wrong value)
            # when an error occurs, everything fails and nothing is changed
            self.assertRaises(InvalidParameter, inst.vm_update, u'пeω-∨м',
                              {'users': [], 'groups': ['groupdoesnotexist']})
            self.assertEquals(users, inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals(groups, inst.vm_lookup(u'пeω-∨м')['groups'])

            # change VM users and groups by removing all elements
            inst.vm_update(u'пeω-∨м', {'users': [], 'groups': []})
            self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['users'])
            self.assertEquals([], inst.vm_lookup(u'пeω-∨м')['groups'])
Example #9
0
    def test_vm_edit(self):
        config.set("authentication", "method", "pam")
        inst = model.Model(None, objstore_loc=self.tmp_store)

        # template disk format must be qcow2 because vmsnapshot
        # only supports this format
        orig_params = {
            "name": "test",
            "memory": 1024,
            "cpus": 1,
            "cdrom": UBUNTU_ISO,
            "disks": [{"size": 1, "format": "qcow2"}],
        }
        inst.templates_create(orig_params)

        with RollbackContext() as rollback:
            params_1 = {"name": "kimchi-vm1", "template": "/plugins/kimchi/templates/test"}
            params_2 = {"name": "kimchi-vm2", "template": "/plugins/kimchi/templates/test"}
            task1 = inst.vms_create(params_1)
            inst.task_wait(task1["id"])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, "kimchi-vm1")
            task2 = inst.vms_create(params_2)
            inst.task_wait(task2["id"])
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, "kimchi-vm2")

            vms = inst.vms_get_list()
            self.assertTrue("kimchi-vm1" in vms)

            # make sure "vm_update" works when the domain has a snapshot
            inst.vmsnapshots_create(u"kimchi-vm1")

            # update vm graphics when vm is not running
            inst.vm_update(u"kimchi-vm1", {"graphics": {"passwd": "123456"}})

            inst.vm_start("kimchi-vm1")
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_poweroff, "kimchi-vm1")

            vm_info = inst.vm_lookup(u"kimchi-vm1")
            self.assertEquals("123456", vm_info["graphics"]["passwd"])
            self.assertEquals(None, vm_info["graphics"]["passwdValidTo"])

            # update vm graphics when vm is running
            inst.vm_update(u"kimchi-vm1", {"graphics": {"passwd": "abcdef", "passwdValidTo": 20}})
            vm_info = inst.vm_lookup(u"kimchi-vm1")
            self.assertEquals("abcdef", vm_info["graphics"]["passwd"])
            self.assertGreaterEqual(20, vm_info["graphics"]["passwdValidTo"])

            info = inst.vm_lookup("kimchi-vm1")
            self.assertEquals("running", info["state"])

            params = {"name": "new-vm"}
            self.assertRaises(InvalidParameter, inst.vm_update, "kimchi-vm1", params)

            # change VM users and groups, when wm is running.
            inst.vm_update(u"kimchi-vm1", {"users": ["root"], "groups": ["root"]})
            vm_info = inst.vm_lookup(u"kimchi-vm1")
            self.assertEquals(["root"], vm_info["users"])
            self.assertEquals(["root"], vm_info["groups"])
            # change VM users and groups by removing all elements,
            # when wm is running.
            inst.vm_update(u"kimchi-vm1", {"users": [], "groups": []})
            vm_info = inst.vm_lookup(u"kimchi-vm1")
            self.assertEquals([], vm_info["users"])
            self.assertEquals([], vm_info["groups"])

            inst.vm_poweroff("kimchi-vm1")
            self.assertRaises(OperationFailed, inst.vm_update, "kimchi-vm1", {"name": "kimchi-vm2"})

            params = {"name": u"пeω-∨м", "cpus": 4, "memory": 2048}
            inst.vm_update("kimchi-vm1", params)
            rollback.prependDefer(utils.rollback_wrapper, inst.vm_delete, u"пeω-∨м")
            self.assertEquals(info["uuid"], inst.vm_lookup(u"пeω-∨м")["uuid"])
            info = inst.vm_lookup(u"пeω-∨м")
            for key in params.keys():
                self.assertEquals(params[key], info[key])

            # change only VM users - groups are not changed (default is empty)
            users = inst.users_get_list()[:3]
            inst.vm_update(u"пeω-∨м", {"users": users})
            self.assertEquals(users, inst.vm_lookup(u"пeω-∨м")["users"])
            self.assertEquals([], inst.vm_lookup(u"пeω-∨м")["groups"])

            # change only VM groups - users are not changed (default is empty)
            groups = inst.groups_get_list()[:2]
            inst.vm_update(u"пeω-∨м", {"groups": groups})
            self.assertEquals(users, inst.vm_lookup(u"пeω-∨м")["users"])
            self.assertEquals(groups, inst.vm_lookup(u"пeω-∨м")["groups"])

            # change VM users and groups by adding a new element to each one
            users.append(pwd.getpwuid(os.getuid()).pw_name)
            groups.append(grp.getgrgid(os.getgid()).gr_name)
            inst.vm_update(u"пeω-∨м", {"users": users, "groups": groups})
            self.assertEquals(users, inst.vm_lookup(u"пeω-∨м")["users"])
            self.assertEquals(groups, inst.vm_lookup(u"пeω-∨м")["groups"])

            # change VM users (wrong value) and groups
            # when an error occurs, everything fails and nothing is changed
            self.assertRaises(
                InvalidParameter, inst.vm_update, u"пeω-∨м", {"users": ["userdoesnotexist"], "groups": []}
            )
            self.assertEquals(users, inst.vm_lookup(u"пeω-∨м")["users"])
            self.assertEquals(groups, inst.vm_lookup(u"пeω-∨м")["groups"])

            # change VM users and groups (wrong value)
            # when an error occurs, everything fails and nothing is changed
            self.assertRaises(
                InvalidParameter, inst.vm_update, u"пeω-∨м", {"users": [], "groups": ["groupdoesnotexist"]}
            )
            self.assertEquals(users, inst.vm_lookup(u"пeω-∨м")["users"])
            self.assertEquals(groups, inst.vm_lookup(u"пeω-∨м")["groups"])

            # change VM users and groups by removing all elements
            inst.vm_update(u"пeω-∨м", {"users": [], "groups": []})
            self.assertEquals([], inst.vm_lookup(u"пeω-∨м")["users"])
            self.assertEquals([], inst.vm_lookup(u"пeω-∨м")["groups"])