Exemplo n.º 1
0
 def test_modern_bases(self):
     for distro, version in modern_version_bases[_get_arch()].iteritems():
         entry = lookup(distro, version)
         self.assertEquals(entry['disk_bus'],
                           get_template_default('modern', 'disk_bus'))
         self.assertEquals(entry['nic_model'],
                           get_template_default('modern', 'nic_model'))
Exemplo n.º 2
0
 def test_modern_bases(self):
     for distro, version in modern_version_bases[_get_arch()].iteritems():
         entry = lookup(distro, version)
         self.assertEquals(entry['disk_bus'],
                           get_template_default('modern', 'disk_bus'))
         self.assertEquals(entry['nic_model'],
                           get_template_default('modern', 'nic_model'))
Exemplo n.º 3
0
 def test_lookup_unknown_distro_version_returns_old_distro(self):
     distro = 'unknown_distro'
     version = 'unknown_version'
     entry = lookup(distro, version)
     self.assertEquals(entry['disk_bus'],
                       get_template_default('old', 'disk_bus'))
     self.assertEquals(entry['nic_model'],
                       get_template_default('old', 'nic_model'))
Exemplo n.º 4
0
 def test_lookup_unknown_distro_version_returns_old_distro(self):
     distro = 'unknown_distro'
     version = 'unknown_version'
     entry = lookup(distro, version)
     self.assertEquals(entry['disk_bus'],
                       get_template_default('old', 'disk_bus'))
     self.assertEquals(entry['nic_model'],
                       get_template_default('old', 'nic_model'))
Exemplo n.º 5
0
 def test_old_distros(self):
     old_versions = {'debian': '5.0', 'ubuntu': '7.04', 'opensuse': '10.1',
                     'centos': '5.1', 'rhel': '5.1', 'fedora': '15'}
     for distro, version in old_versions.iteritems():
         entry = lookup(distro, version)
         self.assertEquals(entry['disk_bus'],
                           get_template_default('old', 'disk_bus'))
         self.assertEquals(entry['nic_model'],
                           get_template_default('old', 'nic_model'))
Exemplo n.º 6
0
 def test_modern_distros(self):
     # versions based on ppc64 modern distros
     modern_versions = {'ubuntu': '14.04', 'opensuse': '13.1',
                        'rhel': '6.5', 'fedora': '19', 'sles': '11sp3'}
     for distro, version in modern_versions.iteritems():
         entry = lookup(distro, version)
         self.assertEquals(entry['disk_bus'],
                           get_template_default('modern', 'disk_bus'))
         self.assertEquals(entry['nic_model'],
                           get_template_default('modern', 'nic_model'))
Exemplo n.º 7
0
    def test_minimal_construct(self):
        disk_bus = get_template_default('old', 'disk_bus')
        memory = get_template_default('old', 'memory')
        nic_model = get_template_default('old', 'nic_model')
        fields = (('name', 'test'), ('os_distro', 'unknown'),
                  ('os_version', 'unknown'), ('cpus', 1),
                  ('memory', memory), ('networks', ['default']),
                  ('disk_bus', disk_bus), ('nic_model', nic_model),
                  ('graphics', {'type': 'vnc', 'listen': '127.0.0.1'}),
                  ('cdrom', self.iso))

        args = {'name': 'test', 'cdrom': self.iso}
        t = VMTemplate(args)
        for name, val in fields:
            self.assertEquals(val, t.info.get(name))
Exemplo n.º 8
0
 def test_modern_distros(self):
     # versions based on ppc64 modern distros
     modern_versions = {
         'ubuntu': '14.04',
         'opensuse': '13.1',
         'rhel': '6.5',
         'fedora': '19',
         'sles': '11sp3'
     }
     for distro, version in modern_versions.iteritems():
         entry = lookup(distro, version)
         self.assertEquals(entry['disk_bus'],
                           get_template_default('modern', 'disk_bus'))
         self.assertEquals(entry['nic_model'],
                           get_template_default('modern', 'nic_model'))
Exemplo n.º 9
0
 def test_old_distros(self):
     old_versions = {
         'debian': '5.0',
         'ubuntu': '7.04',
         'opensuse': '10.1',
         'centos': '5.1',
         'rhel': '5.1',
         'fedora': '15'
     }
     for distro, version in old_versions.iteritems():
         entry = lookup(distro, version)
         self.assertEquals(entry['disk_bus'],
                           get_template_default('old', 'disk_bus'))
         self.assertEquals(entry['nic_model'],
                           get_template_default('old', 'nic_model'))
Exemplo n.º 10
0
    def test_minimal_construct(self):
        disk_bus = get_template_default('old', 'disk_bus')
        memory = get_template_default('old', 'memory')
        nic_model = get_template_default('old', 'nic_model')
        fields = (('name', 'test'), ('os_distro', 'unknown'),
                  ('os_version', 'unknown'), ('cpus', 1),
                  ('memory', memory), ('networks', ['default']),
                  ('disk_bus', disk_bus), ('nic_model', nic_model),
                  ('graphics', {'type': 'vnc', 'listen': '127.0.0.1'}),
                  ('cdrom', self.iso))

        args = {'name': 'test', 'cdrom': self.iso}
        t = VMTemplate(args)
        for name, val in fields:
            self.assertEquals(val, t.info.get(name))
Exemplo n.º 11
0
    def test_vm_info(self):
        model.templates_create({'name': u'test', 'cdrom': fake_iso})
        model.vms_create({'name': u'test-vm', 'template': '/templates/test'})
        vms = model.vms_get_list()
        self.assertEquals(2, len(vms))
        self.assertIn(u'test-vm', vms)

        keys = set(
            ('name', 'state', 'stats', 'uuid', 'memory', 'cpus', 'screenshot',
             'icon', 'graphics', 'users', 'groups', 'access', 'persistent'))

        stats_keys = set(
            ('cpu_utilization', 'net_throughput', 'net_throughput_peak',
             'io_throughput', 'io_throughput_peak'))

        info = model.vm_lookup(u'test-vm')
        self.assertEquals(keys, set(info.keys()))
        self.assertEquals('shutoff', info['state'])
        self.assertEquals('test-vm', info['name'])
        self.assertEquals(get_template_default('old', 'memory'),
                          info['memory'])
        self.assertEquals(1, info['cpus'])
        self.assertEquals('images/icon-vm.png', info['icon'])
        self.assertEquals(stats_keys, set(info['stats'].keys()))
        self.assertEquals('vnc', info['graphics']['type'])
        self.assertEquals('127.0.0.1', info['graphics']['listen'])
Exemplo n.º 12
0
    def test_iso_scan_shallow(self):
        # fake environment preparation
        self._create_pool('pool-3')
        self.request('/storagepools/pool-3/activate', '{}', 'POST')
        params = {'name': 'fedora.iso',
                  'capacity': 1073741824,  # 1 GiB
                  'type': 'file',
                  'format': 'iso'}
        task_info = model.storagevolumes_create('pool-3', params)
        wait_task(self._task_lookup, task_info['id'])

        storagevolume = json.loads(self.request(
            '/storagepools/kimchi_isos/storagevolumes/').read())[0]
        self.assertEquals('fedora.iso', storagevolume['name'])
        self.assertEquals('iso', storagevolume['format'])
        self.assertEquals('/var/lib/libvirt/images/fedora.iso',
                          storagevolume['path'])
        self.assertEquals(1073741824, storagevolume['capacity'])  # 1 GiB
        self.assertEquals(0, storagevolume['allocation'])
        self.assertEquals('17', storagevolume['os_version'])
        self.assertEquals('fedora', storagevolume['os_distro'])
        self.assertEquals(True, storagevolume['bootable'])

        # Create a template
        # In real model os distro/version can be omitted
        # as we will scan the iso
        req = json.dumps({'name': 'test',
                          'cdrom': storagevolume['path'],
                          'os_distro': storagevolume['os_distro'],
                          'os_version': storagevolume['os_version']})
        resp = self.request('/templates', req, 'POST')
        self.assertEquals(201, resp.status)

        # Verify the template
        t = json.loads(self.request('/templates/test').read())
        self.assertEquals('test', t['name'])
        self.assertEquals('fedora', t['os_distro'])
        self.assertEquals('17', t['os_version'])
        self.assertEquals(get_template_default('old', 'memory'), t['memory'])

        # Deactivate or destroy scan pool return 405
        resp = self.request('/storagepools/kimchi_isos/storagevolumes'
                            '/deactivate', '{}', 'POST')
        self.assertEquals(405, resp.status)

        resp = self.request('/storagepools/kimchi_isos/storagevolumes',
                            '{}', 'DELETE')
        self.assertEquals(405, resp.status)

        # Delete the template
        resp = self.request('/templates/%s' % t['name'], '{}', 'DELETE')
        self.assertEquals(204, resp.status)

        resp = self.request('/storagepools/pool-3/deactivate', '{}', 'POST')
        self.assertEquals(200, resp.status)
        self._delete_pool('pool-3')
Exemplo n.º 13
0
    def test_minimal_construct(self):
        disk_bus = get_template_default("old", "disk_bus")
        memory = get_template_default("old", "memory")
        nic_model = get_template_default("old", "nic_model")
        fields = (
            ("name", "test"),
            ("os_distro", "unknown"),
            ("os_version", "unknown"),
            ("cpus", 1),
            ("memory", memory),
            ("networks", ["default"]),
            ("disk_bus", disk_bus),
            ("nic_model", nic_model),
            ("graphics", {"type": "vnc", "listen": "127.0.0.1"}),
            ("cdrom", self.iso),
        )

        args = {"name": "test", "cdrom": self.iso}
        t = VMTemplate(args)
        for name, val in fields:
            self.assertEquals(val, t.info.get(name))
Exemplo n.º 14
0
    def test_vm_iface(self):

        with RollbackContext() as rollback:
            # Create a template as a base for our VMs
            req = json.dumps({'name': 'test', 'cdrom': fake_iso})
            resp = self.request('/templates', req, 'POST')
            self.assertEquals(201, resp.status)
            # Delete the template
            rollback.prependDefer(self.request,
                                  '/templates/test', '{}', 'DELETE')

            # Create a VM with default args
            req = json.dumps({'name': 'test-vm',
                              'template': '/templates/test'})
            resp = self.request('/vms', req, 'POST')
            self.assertEquals(202, resp.status)
            task = json.loads(resp.read())
            wait_task(self._task_lookup, task['id'])
            # Delete the VM
            rollback.prependDefer(self.request,
                                  '/vms/test-vm', '{}', 'DELETE')

            # Create a network
            req = json.dumps({'name': 'test-network',
                              'connection': 'nat',
                              'net': '127.0.1.0/24'})
            resp = self.request('/networks', req, 'POST')
            self.assertEquals(201, resp.status)
            # Delete the network
            rollback.prependDefer(self.request,
                                  '/networks/test-network', '{}', 'DELETE')

            ifaces = json.loads(self.request('/vms/test-vm/ifaces').read())
            self.assertEquals(1, len(ifaces))

            for iface in ifaces:
                res = json.loads(self.request('/vms/test-vm/ifaces/%s' %
                                              iface['mac']).read())
                self.assertEquals('default', res['network'])
                self.assertEquals(17, len(res['mac']))
                self.assertEquals(get_template_default('old', 'nic_model'),
                                  res['model'])

            # try to attach an interface without specifying 'model'
            req = json.dumps({'type': 'network'})
            resp = self.request('/vms/test-vm/ifaces', req, 'POST')
            self.assertEquals(400, resp.status)

            # attach network interface to vm
            req = json.dumps({"type": "network",
                              "network": "test-network",
                              "model": "virtio"})
            resp = self.request('/vms/test-vm/ifaces', req, 'POST')
            self.assertEquals(201, resp.status)
            iface = json.loads(resp.read())

            self.assertEquals('test-network', iface['network'])
            self.assertEquals(17, len(iface['mac']))
            self.assertEquals('virtio', iface['model'])
            self.assertEquals('network', iface['type'])

            # update vm interface
            newMacAddr = '54:50:e3:44:8a:af'
            req = json.dumps({"network": "default", "model": "virtio",
                             "type": "network", "mac": newMacAddr})
            resp = self.request('/vms/test-vm/ifaces/%s' % iface['mac'],
                                req, 'PUT')
            self.assertEquals(303, resp.status)
            iface = json.loads(self.request('/vms/test-vm/ifaces/%s' %
                                            newMacAddr).read())
            self.assertEquals(newMacAddr, iface['mac'])

            # detach network interface from vm
            resp = self.request('/vms/test-vm/ifaces/%s' % iface['mac'],
                                '{}', 'DELETE')
            self.assertEquals(204, resp.status)
Exemplo n.º 15
0
    def test_vm_disk(self):
        disk_path = '/tmp/existent2.iso'
        open(disk_path, 'w').close()
        modern_disk_bus = get_template_default('modern', 'disk_bus')

        def _attach_disk(expect_bus=modern_disk_bus):
            disk_args = {"type": "disk",
                         "pool": pool,
                         "vol": vol}
            disk = inst.vmstorages_create(vm_name, disk_args)
            storage_list = inst.vmstorages_get_list(vm_name)
            self.assertEquals(prev_count + 1, len(storage_list))

            # Check the bus type to be 'virtio'
            disk_info = inst.vmstorage_lookup(vm_name, disk)
            self.assertEquals(u'disk', disk_info['type'])
            self.assertEquals(vol_path, disk_info['path'])
            self.assertEquals(expect_bus, disk_info['bus'])
            return disk

        inst = model.Model(objstore_loc=self.tmp_store)
        with RollbackContext() as rollback:
            path = os.path.join(os.getcwd(), 'kimchi-images')
            pool = 'test-pool'
            vol = 'test-volume.img'
            vol_path = "%s/%s" % (path, vol)
            if not os.path.exists(path):
                os.mkdir(path)
            rollback.prependDefer(shutil.rmtree, path)

            args = {'name': pool,
                    'path': path,
                    'type': 'dir'}
            inst.storagepools_create(args)
            rollback.prependDefer(inst.storagepool_delete, pool)

            # Activate the pool before adding any volume
            inst.storagepool_activate(pool)
            rollback.prependDefer(inst.storagepool_deactivate, pool)

            params = {'name': vol,
                      'capacity': 1073741824,  # 1 GiB
                      'allocation': 536870912,  # 512 MiB
                      'format': 'qcow2'}
            task_id = inst.storagevolumes_create(pool, params)['id']
            rollback.prependDefer(inst.storagevolume_delete, pool, vol)
            inst.task_wait(task_id)

            vm_name = 'kimchi-cdrom'
            params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
            inst.templates_create(params)
            rollback.prependDefer(inst.template_delete, 'test')
            params = {'name': vm_name, 'template': '/templates/test'}
            inst.vms_create(params)
            rollback.prependDefer(inst.vm_delete, vm_name)

            prev_count = len(inst.vmstorages_get_list(vm_name))
            self.assertEquals(1, prev_count)

            # Volume format with mismatched type raise error
            cdrom_args = {"type": "cdrom", "pool": pool, "vol": vol}
            self.assertRaises(InvalidParameter, inst.vmstorages_create,
                              vm_name, cdrom_args)

            # Cold plug and unplug a disk
            disk = _attach_disk()
            inst.vmstorage_delete(vm_name, disk)

            # Hot plug a disk
            inst.vm_start(vm_name)
            disk = _attach_disk()

            # VM disk still there after powered off
            inst.vm_poweroff(vm_name)
            disk_info = inst.vmstorage_lookup(vm_name, disk)
            self.assertEquals(u'disk', disk_info['type'])
            inst.vmstorage_delete(vm_name, disk)

            # Specifying pool and path at same time will fail
            disk_args = {"type": "disk",
                         "pool": pool,
                         "vol": vol,
                         "path": disk_path}
            self.assertRaises(
                InvalidParameter, inst.vmstorages_create, vm_name, disk_args)

            old_distro_iso = ISO_PATH + 'rhel4_8.iso'
            iso_gen.construct_fake_iso(old_distro_iso, True, '4.8', 'rhel')

            vm_name = 'kimchi-ide-bus-vm'
            params = {'name': 'old_distro_template', 'disks': [],
                      'cdrom': old_distro_iso}
            inst.templates_create(params)
            rollback.prependDefer(inst.template_delete, 'old_distro_template')
            params = {'name': vm_name,
                      'template': '/templates/old_distro_template'}
            inst.vms_create(params)
            rollback.prependDefer(inst.vm_delete, vm_name)

            # Need to check the right disk_bus for old distro
            disk = _attach_disk(get_template_default('old', 'disk_bus'))
            inst.vmstorage_delete('kimchi-ide-bus-vm', disk)

            # Hot plug IDE bus disk does not work
            inst.vm_start(vm_name)
            self.assertRaises(InvalidOperation, _attach_disk)
            inst.vm_poweroff(vm_name)
Exemplo n.º 16
0
    def test_vm_disk(self):
        disk_path = '/tmp/existent2.iso'
        open(disk_path, 'w').close()
        modern_disk_bus = get_template_default('modern', 'disk_bus')

        def _attach_disk(expect_bus=modern_disk_bus):
            disk_args = {"type": "disk", "pool": pool, "vol": vol}
            disk = inst.vmstorages_create(vm_name, disk_args)
            storage_list = inst.vmstorages_get_list(vm_name)
            self.assertEquals(prev_count + 1, len(storage_list))

            # Check the bus type to be 'virtio'
            disk_info = inst.vmstorage_lookup(vm_name, disk)
            self.assertEquals(u'disk', disk_info['type'])
            self.assertEquals(vol_path, disk_info['path'])
            self.assertEquals(expect_bus, disk_info['bus'])
            return disk

        inst = model.Model(objstore_loc=self.tmp_store)
        with RollbackContext() as rollback:
            path = os.path.join(os.getcwd(), 'kimchi-images')
            pool = 'test-pool'
            vol = 'test-volume.img'
            vol_path = "%s/%s" % (path, vol)
            if not os.path.exists(path):
                os.mkdir(path)
            rollback.prependDefer(shutil.rmtree, path)

            args = {'name': pool, 'path': path, 'type': 'dir'}
            inst.storagepools_create(args)
            rollback.prependDefer(inst.storagepool_delete, pool)

            # Activate the pool before adding any volume
            inst.storagepool_activate(pool)
            rollback.prependDefer(inst.storagepool_deactivate, pool)

            params = {
                'name': vol,
                'capacity': 1073741824,  # 1 GiB
                'allocation': 536870912,  # 512 MiB
                'format': 'qcow2'
            }
            task_id = inst.storagevolumes_create(pool, params)['id']
            rollback.prependDefer(inst.storagevolume_delete, pool, vol)
            inst.task_wait(task_id)

            vm_name = 'kimchi-cdrom'
            params = {'name': 'test', 'disks': [], 'cdrom': UBUNTU_ISO}
            inst.templates_create(params)
            rollback.prependDefer(inst.template_delete, 'test')
            params = {'name': vm_name, 'template': '/templates/test'}
            inst.vms_create(params)
            rollback.prependDefer(inst.vm_delete, vm_name)

            prev_count = len(inst.vmstorages_get_list(vm_name))
            self.assertEquals(1, prev_count)

            # Volume format with mismatched type raise error
            cdrom_args = {"type": "cdrom", "pool": pool, "vol": vol}
            self.assertRaises(InvalidParameter, inst.vmstorages_create,
                              vm_name, cdrom_args)

            # Cold plug and unplug a disk
            disk = _attach_disk()
            inst.vmstorage_delete(vm_name, disk)

            # Hot plug a disk
            inst.vm_start(vm_name)
            disk = _attach_disk()

            # VM disk still there after powered off
            inst.vm_poweroff(vm_name)
            disk_info = inst.vmstorage_lookup(vm_name, disk)
            self.assertEquals(u'disk', disk_info['type'])
            inst.vmstorage_delete(vm_name, disk)

            # Specifying pool and path at same time will fail
            disk_args = {
                "type": "disk",
                "pool": pool,
                "vol": vol,
                "path": disk_path
            }
            self.assertRaises(InvalidParameter, inst.vmstorages_create,
                              vm_name, disk_args)

            old_distro_iso = ISO_PATH + 'rhel4_8.iso'
            iso_gen.construct_fake_iso(old_distro_iso, True, '4.8', 'rhel')

            vm_name = 'kimchi-ide-bus-vm'
            params = {
                'name': 'old_distro_template',
                'disks': [],
                'cdrom': old_distro_iso
            }
            inst.templates_create(params)
            rollback.prependDefer(inst.template_delete, 'old_distro_template')
            params = {
                'name': vm_name,
                'template': '/templates/old_distro_template'
            }
            inst.vms_create(params)
            rollback.prependDefer(inst.vm_delete, vm_name)

            # Need to check the right disk_bus for old distro
            disk = _attach_disk(get_template_default('old', 'disk_bus'))
            inst.vmstorage_delete('kimchi-ide-bus-vm', disk)

            # Hot plug IDE bus disk does not work
            inst.vm_start(vm_name)
            self.assertRaises(InvalidOperation, _attach_disk)
            inst.vm_poweroff(vm_name)