def _test_create(self):
datacenter = schema.new(schema.DataCenter)
datacenter.name = util.random_name('dc')
datacenter.version = self.get_version()
datacenter.storage_type = 'NFS'
datacenter = self.api.create(datacenter)
assert datacenter is not None
datacenter2 = schema.new(schema.DataCenter)
datacenter2.name = util.random_name('dc')
datacenter2.version = self.get_version()
datacenter2.storage_type = 'NFS'
datacenter2 = self.api.create(datacenter2)
assert datacenter2 is not None
cluster = schema.new(schema.Cluster)
cluster.name = util.random_name('cluster')
cluster.data_center = schema.ref(datacenter)
cluster.cpu = self.get_cpu()
cluster.version = self.get_version()
cluster2 = self.api.create(cluster)
assert cluster2.id is not None
assert cluster2.href is not None
assert cluster2.data_center.id == cluster.data_center.id
assert cluster2.cpu.id == cluster.cpu.id
cluster = self.api.get(schema.Cluster, id=cluster2.id)
assert cluster is not None
assert isinstance(cluster, schema.Cluster)
assert cluster.id == cluster2.id
self.store.datacenter = datacenter
self.store.datacenter2 = datacenter2
self.store.cluster = cluster
def test_create(self):
vm = schema.new(schema.VM)
vm.name = util.random_name('vm')
vm.type = 'SERVER'
vm.memory = 512*1024**2
vm.cpu = schema.new(schema.CPU)
vm.cpu.topology = schema.new(schema.CpuTopology)
vm.cpu.topology.cores = 1
vm.cpu.topology.sockets = 1
vm.display = schema.new(schema.Display)
vm.display.type = 'VNC'
vm.os = schema.new(schema.OperatingSystem)
vm.os.type = 'RHEL5'
vm.os.boot = [schema.new(schema.Boot, dev='hd')]
# XXX: this is a bit of a kludge: #229
vm.highly_available = schema.new(schema.HighlyAvailable, True)
vm.highly_available.priority = 10
vm.cluster = schema.ref(self.store.cluster)
vm.template = schema.ref(self.store.template)
vm2 = self.api.create(vm)
assert isinstance(vm2, schema.VM)
assert vm2.id is not None
vm = self.api.get(schema.VM, name=vm2.name)
assert isinstance(vm, schema.VM)
assert vm.id == vm2.id
self.store.vm = vm
def test_create(self):
tag = schema.new(schema.Tag)
tag.name = util.random_name('tag')
tag2 = self.api.create(tag)
assert isinstance(tag2, schema.Tag)
assert tag2.id is not None
self.store.tag = tag2
def test_prepare(self):
name = self.get_config('datacenter')
if name is None:
raise SkipTest, 'Parameter "datacenter" not set.'
datacenter = self.api.get(schema.DataCenter, name=name)
if datacenter is None:
raise SkipTest, 'Datacenter not found: %s' % name
name = self.get_config('cluster')
if name is None:
raise SkipTest, 'Parameter "cluster" not set.'
cluster = self.api.get(schema.Cluster, name=name)
if cluster is None:
raise SkipTest, 'Cluster not found: %s' % name
template = self.api.get(schema.Template, name='Blank')
if template is None:
raise SkipTest, 'Template not found: Blank'
vm = schema.new(schema.VM)
vm.name = util.random_name('vm')
vm.memory = 512 * 1024**2
vm.type = 'DESKTOP'
vm.cluster = schema.ref(cluster)
vm.template = schema.ref(template)
vm2 = self.api.create(vm)
assert vm2 is not None
disk = schema.new(schema.Disk)
disk.size = 1024**3
disk.format = 'COW'
disk.sparse = True
disk.wipe_after_delete = False
disk2 = self.api.create(disk, base=vm2)
assert disk2 is not None
self.store.vm = vm2
def test_prepare(self):
dc = schema.new(schema.DataCenter)
dc.name = util.random_name('dc')
dc.storage_type = 'NFS'
dc = self.api.create(dc)
assert dc is not None
self.store.dc = dc
def test_create(self):
vm = schema.new(schema.VM)
vm.name = util.random_name('vm')
vm.type = 'server'
vm.memory = 512*1024**2
vm.cpu = schema.new(schema.CPU)
vm.cpu.topology = schema.new(schema.CpuTopology)
vm.cpu.topology.cores = 1
vm.cpu.topology.sockets = 1
vm.display = schema.new(schema.Display)
vm.display.type = 'vnc'
vm.os = schema.new(schema.OperatingSystem)
vm.os.type = 'RHEL5'
vm.os.boot = [schema.new(schema.Boot, dev='hd')]
vm.high_availability = schema.new(schema.HighAvailability)
vm.high_availability.enabled = True
vm.high_availability.priority = 50
vm.cluster = schema.ref(self.store.cluster)
vm.template = schema.ref(self.store.template)
vm2 = self.api.create(vm)
assert isinstance(vm2, schema.VM)
assert vm2.id is not None
vm = self.api.get(schema.VM, name=vm2.name)
assert isinstance(vm, schema.VM)
assert vm.id == vm2.id
self.store.vm = vm
def _test_create(self):
dc = schema.new(schema.DataCenter)
dc.name = util.random_name('dc')
dc.storage_type = 'nfs'
dc.version = self.get_version()
dc2 = self.api.create(dc)
assert dc2.id is not None
assert dc2.href is not None
assert dc2.storage_type == 'nfs'
self.store.dc = dc2
def test_create(self):
template = schema.new(schema.Template)
template.name = util.random_name('tmpl')
template.vm = schema.ref(self.store.vm)
template2 = self.api.create(template)
assert isinstance(template2, schema.Template)
assert template2.id is not None
template = self.api.get(schema.Template, name=template2.name)
assert isinstance(template, schema.Template)
assert template.id == template2.id
self.wait_for_status(template, 'OK')
self.store.template = template
def test_create_child(self):
tag = self.store.tag
child = schema.new(schema.Tag)
child.name = util.random_name('tag')
child.parent = schema.new(schema.TagParent)
child.parent.tag = schema.new(schema.Tag)
child.parent.tag.id = tag.id
child2 = self.api.create(child)
assert isinstance(child2, schema.Tag)
assert child2.id is not None
assert child2.parent.tag.id == tag.id
self.store.child = child2
def test_update(self):
template = self.store.template
template.name = util.random_name('tmpl')
# Bug: ticket #190
template2 = self.api.update(template)
assert isinstance(template2, schema.Template)
assert template2.id == template.id
assert template2.name == template.name
template = self.api.get(schema.Template, id=template2.id)
assert isinstance(template, schema.Template)
assert template.id == template2.id
assert template.name == template2.name
self.store.template = template
def test_create(self):
template = self.store.template
cluster = self.store.cluster
pool = schema.new(schema.VmPool)
pool.name = util.random_name('pool')
pool.size = 1
pool.template = schema.ref(template)
pool.cluster = schema.ref(cluster)
pool2 = self.api.create(pool)
assert isinstance(pool2, schema.VmPool)
assert pool2.id is not None
pool = self.api.get(schema.VmPool, name=pool2.name)
assert isinstance(pool, schema.VmPool)
assert pool.id == pool2.id
self.store.pool = pool
def _test_create(self):
datacenter = schema.new(schema.DataCenter)
datacenter.name = util.random_name('dc')
datacenter.version = self.get_version()
datacenter.storage_type = 'NFS'
datacenter = self.api.create(datacenter)
network = schema.new(schema.Network)
network.name = util.random_name('net')
network.description = 'foo'
network.data_center = schema.ref(datacenter)
network.stp = False
network.vlan = self.get_vlan()
network.ip = self.get_unused_ip()
network.display = False
network2 = self.api.create(network)
assert isinstance(network2, schema.Network)
assert network2.id is not None
assert network2.href is not None
assert network2.data_center.id == datacenter.id
network = self.api.get(schema.Network, id=network2.id)
assert isinstance(network, schema.Network)
assert network.id == network2.id
self.store.datacenter = datacenter
self.store.network = network
def _test_attach_network(self):
cluster = self.store.cluster
network = schema.new(schema.Network)
network.name = util.random_name('net')
network.description = 'foo'
network.data_center = schema.ref(self.store.datacenter)
network.stp = False
network.vlan = self.get_vlan()
network.ip = self.get_unused_ip()
network.display = False
network = self.api.create(network)
assert network is not None
atnetwork = self.api.create(network, base=cluster)
networks = self.api.getall(schema.Network, base=cluster)
assert util.contains_id(networks, atnetwork.id)
self.store.network = network
self.store.atnetwork = atnetwork
def test_prepare(self):
name = self.get_config('datacenter')
if name is None:
raise SkipTest, 'Parameter "datacenter" not set.'
datacenter = self.api.get(schema.DataCenter, name=name)
if datacenter is None:
raise SkipTest, 'Datacenter not found: %s' % name
name = self.get_config('cluster')
if name is None:
raise SkipTest, 'Parameter "cluster" not set.'
cluster = self.api.get(schema.Cluster, name=name)
if cluster is None:
raise SkipTest, 'Cluster not found: %s' % name
template = self.api.get(schema.Template, name='Blank')
if template is None:
raise SkipTest, 'Template not found: Blank'
storagedomain = self.api.get(schema.StorageDomain, base=datacenter,
filter={'type': 'DATA'})
if storagedomain is None:
raise SkipTest, 'No data domain found in datacenter'
exportdomain = self.api.get(schema.StorageDomain, base=datacenter,
filter={'type': 'EXPORT'})
vm = schema.new(schema.VM)
vm.name = util.random_name('vm')
vm.memory = 512 * 1024**2
vm.type = 'DESKTOP'
vm.cluster = schema.ref(cluster)
vm.template = schema.ref(template)
vm2 = self.api.create(vm)
assert vm2 is not None
disk = schema.new(schema.Disk)
disk.size = 1024**3
disk.format = 'COW'
disk.sparse = True
disk.wipe_after_delete = False
disk2 = self.api.create(disk, base=vm2)
assert disk2 is not None
self.wait_for_status(vm2, 'DOWN') # LOCKED -> DOWN
self.store.datacenter = datacenter
self.store.cluster = cluster
self.store.storagedomain = storagedomain
self.store.exportdomain = exportdomain
self.store.vm = vm2
def _test_create_iso(self, name):
host = self.store.host
address = self.get_config('address', name)
if address is None:
raise SkipTest, 'Parameter "address" not set in [%s]' % name
path = self.get_config('path', name)
if path is None:
raise SkipTest, 'Parameter "path" not set in [%s]' % name
domain = schema.new(schema.StorageDomain)
domain.name = util.random_name('iso')
domain.type = 'ISO'
domain.storage = schema.new(schema.Storage)
domain.storage.type = 'NFS'
domain.storage.address = address
domain.storage.path = path
domain.host = schema.ref(host)
domain2 = self.api.create(domain)
assert isinstance(domain2, schema.StorageDomain)
assert domain2.id is not None
self.store.isodomain = domain2
def _test_create_nfs_data(self):
host = self.store.host
datacenter = self.store.datacenter
domain = schema.new(schema.StorageDomain)
domain.name = util.random_name('sd')
domain.type = 'DATA'
domain.storage = schema.new(schema.Storage)
domain.storage.type = 'NFS'
domain.storage.address = self.store.address
domain.storage.path = self.store.path
domain.host = schema.ref(host)
domain2 = self.api.create(domain)
assert isinstance(domain2, schema.StorageDomain)
assert domain2.id is not None
domain = self.api.get(schema.StorageDomain, id=domain2.id)
assert isinstance(domain, schema.StorageDomain)
assert domain.id == domain2.id
assert domain.storage.type == 'NFS'
assert domain.storage.address == self.store.address
assert domain.storage.path == self.store.path
self.store.storagedomain = domain
self.store.attachdomain = None
def _prepare_network(self, vlan):
host = self.store.host
nic = self.store.nic
if nic and nic.network:
return
host = self.store.host
cluster = self.store.cluster
datacenter = self.store.datacenter
network = schema.new(schema.Network)
network.name = util.random_name('net')
if vlan:
network.vlan = schema.new(schema.VLAN)
network.vlan.id = vlan
network.stp = True
network.data_center = schema.ref(datacenter)
network = self.api.create(network)
assert network is not None
clnet = self.api.create(schema.ref(network), base=cluster)
assert network.id == clnet.id
# Is the following good or bad?
assert network.href != clnet.href
self.store.network = network
self.store.vlan = vlan
def _test_create_block_data(self):
host = self.store.host
datacenter = self.store.datacenter
domain = schema.new(schema.StorageDomain)
domain.name = util.random_name('sd')
domain.type = 'DATA'
domain.storage = schema.new(schema.Storage)
domain.storage.type = self.store.type
if self.store.luns:
luns = [schema.ref(lun) for lun in self.store.luns ]
domain.storage.logical_unit = luns
elif self.store.volume_group:
domain.storage.volume_group = [schema.ref(self.store.volume_group)]
domain.host = schema.ref(host)
domain2 = self.api.create(domain)
assert isinstance(domain2, schema.StorageDomain)
assert domain2.id is not None
domain = self.api.get(schema.StorageDomain, id=domain2.id)
assert isinstance(domain, schema.StorageDomain)
assert domain.id == domain2.id
assert domain.href == domain2.href
assert domain.storage.type == self.store.type
self.store.storagedomain = domain
self.store.attachdomain = None
def test_wait(self):
vm = schema.new(schema.VM)
vm.name = util.random_name('vm')
vm.type = 'SERVER'
vm.memory = 512*1024*1024
vm.cluster = schema.new(schema.Cluster)
vm.cluster.name = self.get_config('cluster')
vm.template = schema.new(schema.Template)
vm.template.name = self.get_config('template')
vm = self.api.create(vm)
assert isinstance(vm, schema.VM)
disk = schema.new(schema.Disk)
disk.format = 'COW'
disk.size = 2024**3
disk.sparse = True
disk = self.api.create(disk, base=vm)
assert isinstance(disk, schema.Disk)
assert self.api.wait(vm, exists=True)
assert self.api.wait(vm, status='DOWN')
self.api.action(vm, 'start')
assert self.api.wait(vm, status='UP')
self.api.action(vm, 'stop')
assert self.api.wait(vm, status='DOWN')
self.api.delete(vm)
def _prepare(self, name):
type = self.get_config('type', name)
if type is None:
raise SkipTest, 'Missing parameter "type" in [%s]' % name
if type == 'NFS':
params = ('address', 'path')
elif type == 'ISCSI':
params = ('address', 'port', 'target', 'username', 'password')
elif type == 'FCP':
params = ()
else:
raise SkipTest, 'Uknown storage type %s in [%s]' % (type, name)
values = { 'type': type }
for param in params:
value = self.get_config(param, name)
if value is None:
raise SkipTest, 'Missing parameter "%s" in [%s]' % (param, name)
values[param] = value
if values['type'] in ('ISCSI', 'FCP'):
luns = self.get_config('luns', name)
if luns is None:
volume_group = self.get_config('volume_group', name)
if volume_group is None:
raise SkipTest, 'Either "luns" or "volume_group" has to' \
'be specified in [%s].' % name
luns = None
else:
luns = luns.split()
volume_group = None
values['luns'] = luns
values['volume_group'] = volume_group
hosts = self.get_config('hosts').split()
if len(hosts) == 0:
raise SkipTest, 'No hosts configured.'
host = self.api.get(schema.Host, name=hosts[0])
if host is None:
raise SkipTest, 'Host not found: %s' % hosts[0]
values['host'] = host
cpu = self.get_config('cpu', host.name)
if cpu is None:
raise SkipTest, 'Missing parameter "cpu" in [%s]' % host.name
values['cpu'] = cpu
for key in values:
setattr(self.store, key, values[key])
datacenter = schema.new(schema.DataCenter)
datacenter.name = util.random_name('dc')
datacenter.storage_type = self.store.type
datacenter = self.api.create(datacenter)
assert isinstance(datacenter, schema.DataCenter)
assert datacenter.id is not None
cluster = schema.new(schema.Cluster)
cluster.name = util.random_name('cluster')
cluster.cpu = schema.new(schema.CPU)
cluster.cpu.id = self.store.cpu
cluster.data_center = schema.ref(datacenter)
cluster.version = datacenter.version
cluster = self.api.create(cluster)
assert isinstance(cluster, schema.Cluster)
assert cluster.id is not None
self.store.datacenter = datacenter
self.store.cluster = cluster
# BUG: cannot change cluster ID of a host. Ticket #171. This needs
# the patch attached to that ticket.
if host.status != 'MAINTENANCE':
assert self.retry_action(host, 'deactivate')
assert self.wait_for_status(host, 'MAINTENANCE')
self.store.clusterid = host.cluster.id
host.cluster = schema.ref(cluster)
self.api.update(host)
assert host.cluster.id == cluster.id
self.api.action(host, 'activate')
assert self.wait_for_status(host, 'UP')
def _test_update(self):
domain = self.store.storagedomain
domain.name = util.random_name('sd')
domain2 = self.api.update(domain)
assert domain2.id == domain.id
assert domain2.name == domain.name
