def _create_node(self, node_info=None, nic_info=None):
result = {}
if node_info is None:
node_info = bm_db_utils.new_bm_node(id=123, service_host="test_host", cpus=2, memory_mb=2048)
if nic_info is None:
nic_info = [
{"address": "01:23:45:67:89:01", "datapath_id": "0x1", "port_no": 1},
{"address": "01:23:45:67:89:02", "datapath_id": "0x2", "port_no": 2},
]
result["node_info"] = node_info
result["nic_info"] = nic_info
result["node"] = db.bm_node_create(self.context, node_info)
for nic in nic_info:
db.bm_interface_create(
self.context, result["node"]["id"], nic["address"], nic["datapath_id"], nic["port_no"]
)
result["instance"] = utils.get_test_instance()
result["instance"]["node"] = result["node"]["uuid"]
result["spawn_params"] = dict(
admin_password="******",
block_device_info=None,
context=self.context,
image_meta=utils.get_test_image_info(None, result["instance"]),
injected_files=[("/fake/path", "hello world")],
instance=result["instance"],
network_info=utils.get_test_network_info(),
)
result["destroy_params"] = dict(
instance=result["instance"],
network_info=result["spawn_params"]["network_info"],
block_device_info=result["spawn_params"]["block_device_info"],
)
return result
def test_create_container(self, image_info=None):
instance_href = utils.get_test_instance()
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info["disk_format"] = "raw"
image_info["container_format"] = "docker"
self.connection.spawn(self.context, instance_href, image_info, "fake_files", "fake_password")
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
network_info = test_utils.get_test_network_info()
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt, instance_ref, image_info,
[], 'herp', network_info=network_info)
return instance_ref, network_info
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
network_info = test_utils.get_test_network_info()
network_info[0]["network"]["subnets"][0]["meta"]["dhcp_server"] = "1.1.1.1"
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt, instance_ref, image_info, [], "herp", network_info=network_info)
return instance_ref, network_info
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
network_info = test_utils.get_test_network_info()
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt, instance_ref, image_info,
[], 'herp', network_info=network_info)
return instance_ref, network_info
def test_create_container_wrong_image(self):
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'invalid_format'
self.assertRaises(exception.InstanceDeployFailure,
self.test_create_container, image_info)
def test_create_container(self, image_info=None):
instance_href = utils.get_test_instance()
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
def test_create_container(self, image_info=None):
instance_href = utils.get_test_instance()
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
def test_create_container_wrong_image(self):
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'invalid_format'
self.assertRaises(exception.InstanceDeployFailure,
self.test_create_container,
image_info, instance_href)
def _get_running_instance(self):
instance_ref = utils.get_test_instance()
network_info = utils.get_test_network_info()
network_info[0]["network"]["subnets"][0]["meta"]["dhcp_server"] = "1.1.1.1"
image_info = utils.get_test_image_info(None, instance_ref)
image_info["disk_format"] = "raw"
image_info["container_format"] = "docker"
self.connection.spawn(self.ctxt, instance_ref, image_info, [], "herp", network_info=network_info)
return instance_ref, network_info
def _get_running_instance(self, obj=False):
instance_ref = test_utils.get_test_instance(obj=obj)
network_info = test_utils.get_test_network_info()
network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \
'1.1.1.1'
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt, instance_ref, image_info,
[], 'herp', network_info=network_info)
return instance_ref, network_info
def _get_running_instance(self, obj=False):
instance_ref = test_utils.get_test_instance(obj=obj)
network_info = test_utils.get_test_network_info()
network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \
'1.1.1.1'
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt, instance_ref, image_info,
[], 'herp', network_info=network_info)
return instance_ref, network_info
def _create_node(self, node_info=None, nic_info=None, ephemeral=True):
result = {}
if node_info is None:
node_info = bm_db_utils.new_bm_node(
id=123,
service_host='test_host',
cpus=2,
memory_mb=2048,
)
if nic_info is None:
nic_info = [
{
'address': '01:23:45:67:89:01',
'datapath_id': '0x1',
'port_no': 1
},
{
'address': '01:23:45:67:89:02',
'datapath_id': '0x2',
'port_no': 2
},
]
result['node_info'] = node_info
result['nic_info'] = nic_info
result['node'] = db.bm_node_create(self.context, node_info)
for nic in nic_info:
db.bm_interface_create(
self.context,
result['node']['id'],
nic['address'],
nic['datapath_id'],
nic['port_no'],
)
if ephemeral:
result['instance'] = utils.get_test_instance()
else:
flavor = utils.get_test_flavor(options={'ephemeral_gb': 0})
result['instance'] = utils.get_test_instance(flavor=flavor)
result['instance']['node'] = result['node']['uuid']
result['spawn_params'] = dict(
admin_password='******',
block_device_info=None,
context=self.context,
image_meta=utils.get_test_image_info(None, result['instance']),
injected_files=[('/fake/path', 'hello world')],
instance=result['instance'],
network_info=utils.get_test_network_info(),
)
result['destroy_params'] = dict(
context=self.context,
instance=result['instance'],
network_info=result['spawn_params']['network_info'],
block_device_info=result['spawn_params']['block_device_info'],
)
return result
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
instance_ref['instance_type_id'] = self.router_type_id
network_info = test_utils.get_test_network_info()
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt, instance=instance_ref,
image_meta=image_info,
network_info=network_info)
return instance_ref, network_info
def test_create_container_vcpus_2(self, image_info=None):
flavor = utils.get_test_flavor(options={"name": "vcpu_2", "flavorid": "vcpu_2", "vcpus": 2})
instance_href = utils.get_test_instance(flavor=flavor)
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info["disk_format"] = "raw"
image_info["container_format"] = "docker"
self.connection.spawn(self.context, instance_href, image_info, "fake_files", "fake_password")
self._assert_cpu_shares(instance_href, vcpus=2)
def test_get_image_name(self):
instance_ref = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_ref)
image_info['container_format'] = 'docker'
image_info['name'] = 'MiXeDcAsE-image'
repo = self.connection._get_image_name(self.context,
instance_ref, image_info)
# image_name = repo.split("/")[1]
self.assertEqual(image_info['name'], repo)
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
instance_ref['system_metadata'] = [
_system_metadata('node', str(self.node_id)),
]
network_info = test_utils.get_test_network_info()
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt, instance_ref, image_info,
[], 'herp', network_info=network_info)
return instance_ref, network_info
def test_list_instances(self):
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
instances = self.connection.list_instances()
self.assertIn(instance_href.name, instances)
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
instance_ref['instance_type_id'] = self.router_type_id
network_info = test_utils.get_test_network_info()
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt,
instance=instance_ref,
image_meta=image_info,
network_info=network_info)
return instance_ref, network_info
def test_cache_image(self):
self.mox.StubOutWithMock(os, "makedirs")
self.mox.StubOutWithMock(os.path, "exists")
os.makedirs(pxe.get_image_dir_path(self.instance)).AndReturn(True)
os.path.exists(pxe.get_image_file_path(self.instance)).AndReturn(True)
self.mox.ReplayAll()
image_meta = utils.get_test_image_info(self.context, self.instance)
self.driver._cache_image(self.context, self.instance, image_meta)
self.mox.VerifyAll()
def test_list_instances(self):
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
instances = self.connection.list_instances()
self.assertIn(instance_href.name, instances)
def test_get_image_name(self):
instance_ref = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_ref)
image_info['container_format'] = 'docker'
image_info['name'] = 'MiXeDcAsE-image'
repo = self.connection._get_image_name(self.context, instance_ref,
image_info)
# image_name = repo.split("/")[1]
self.assertEqual(image_info['name'], repo)
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
network_info = test_utils.get_test_network_info(legacy_model=False)
network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \
'1.1.1.1'
image_info = test_utils.get_test_image_info(None, instance_ref)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.ctxt, instance_ref, image_info,
[], 'herp', network_info=network_info)
return instance_ref, network_info
def _get_running_instance(self, obj=False):
instance_ref = utils.get_test_instance(obj=obj)
network_info = utils.get_test_network_info()
network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \
'1.1.1.1'
image_info = utils.get_test_image_info(None, instance_ref)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.ctxt, jsonutils.to_primitive(instance_ref),
image_info, [], 'herp', network_info=network_info)
return instance_ref, network_info
def test_create_container(self, image_info=None):
instance_href = utils.get_test_instance()
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
self._assert_cpu_shares(instance_href)
self.assertEqual(self.mock_client.name, "nova-{0}".format(
instance_href['uuid']))
def _get_running_instance(self, obj=False):
instance_ref = utils.get_test_instance(obj=obj)
network_info = utils.get_test_network_info()
network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \
'1.1.1.1'
image_info = utils.get_test_image_info(None, instance_ref)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.ctxt, jsonutils.to_primitive(instance_ref),
image_info, [], 'herp', network_info=network_info)
return instance_ref, network_info
def test_create_container(self, image_info=None):
instance_href = utils.get_test_instance()
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
self._assert_cpu_shares(instance_href)
self.assertEqual(self.mock_client.name,
"nova-{0}".format(instance_href['uuid']))
def test_cache_image(self):
self.mox.StubOutWithMock(os, 'makedirs')
self.mox.StubOutWithMock(os.path, 'exists')
os.makedirs(tilera.get_image_dir_path(self.instance)).\
AndReturn(True)
os.path.exists(tilera.get_image_file_path(self.instance)).\
AndReturn(True)
self.mox.ReplayAll()
image_meta = utils.get_test_image_info(self.context, self.instance)
self.driver._cache_image(self.context, self.instance, image_meta)
self.mox.VerifyAll()
def _create_node(self, node_info=None, nic_info=None, ephemeral=True):
result = {}
if node_info is None:
node_info = bm_db_utils.new_bm_node(
id=123,
service_host='test_host',
cpus=2,
memory_mb=2048,
)
if nic_info is None:
nic_info = [
{'address': '01:23:45:67:89:01', 'datapath_id': '0x1',
'port_no': 1},
{'address': '01:23:45:67:89:02', 'datapath_id': '0x2',
'port_no': 2},
]
result['node_info'] = node_info
result['nic_info'] = nic_info
result['node'] = db.bm_node_create(self.context, node_info)
for nic in nic_info:
db.bm_interface_create(
self.context,
result['node']['id'],
nic['address'],
nic['datapath_id'],
nic['port_no'],
)
if ephemeral:
result['instance'] = utils.get_test_instance()
else:
flavor = utils.get_test_instance_type(options={'ephemeral_gb': 0})
result['instance'] = utils.get_test_instance(instance_type=flavor)
result['instance']['node'] = result['node']['uuid']
result['spawn_params'] = dict(
admin_password='******',
block_device_info=None,
context=self.context,
image_meta=utils.get_test_image_info(
None, result['instance']),
injected_files=[('/fake/path', 'hello world')],
instance=result['instance'],
network_info=utils.get_test_network_info(),
)
result['destroy_params'] = dict(
context=self.context,
instance=result['instance'],
network_info=result['spawn_params']['network_info'],
block_device_info=result['spawn_params']['block_device_info'],
)
return result
def test_list_instances_no_inspect_race(self):
"""Assures containers that cannot be inspected are not listed."""
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
with mock.patch.object(self.mock_client, 'inspect_container',
return_value={}):
instances = self.connection.list_instances()
self.assertFalse(instances)
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
instance_ref['system_metadata'] = [
_system_metadata('node', str(self.node_id)),
]
network_info = test_utils.get_test_network_info()
image_info = test_utils.get_test_image_info(None, instance_ref)
self.connection.spawn(self.ctxt,
instance_ref,
image_info, [],
'herp',
network_info=network_info)
return instance_ref, network_info
def test_create_container_vcpus_2(self, image_info=None):
flavor = utils.get_test_flavor(options={
'name': 'vcpu_2',
'flavorid': 'vcpu_2',
'vcpus': 2
})
instance_href = utils.get_test_instance(flavor=flavor)
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
self._assert_cpu_shares(instance_href, vcpus=2)
def test_create_container_vcpus_2(self, image_info=None):
flavor = utils.get_test_flavor(options={
'name': 'vcpu_2',
'flavorid': 'vcpu_2',
'vcpus': 2
})
instance_href = utils.get_test_instance(flavor=flavor)
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
self._assert_cpu_shares(instance_href, vcpus=2)
def test_cache_image(self):
self.mox.StubOutWithMock(os, "makedirs")
self.mox.StubOutWithMock(os, "unlink")
self.mox.StubOutWithMock(os.path, "exists")
os.makedirs(tilera.get_image_dir_path(self.instance)).AndReturn(True)
disk_path = os.path.join(tilera.get_image_dir_path(self.instance), "disk")
os.path.exists(disk_path).AndReturn(True)
os.unlink(disk_path).AndReturn(None)
os.path.exists(tilera.get_image_file_path(self.instance)).AndReturn(True)
self.mox.ReplayAll()
image_meta = utils.get_test_image_info(self.context, self.instance)
self.driver._cache_image(self.context, self.instance, image_meta)
self.mox.VerifyAll()
def _get_running_instance(self):
instance_ref = test_utils.get_test_instance()
network_info = test_utils.get_test_network_info(legacy_model=False)
network_info[0]['network']['subnets'][0]['meta']['dhcp_server'] = \
'1.1.1.1'
image_info = test_utils.get_test_image_info(None, instance_ref)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.ctxt,
instance_ref,
image_info, [],
'herp',
network_info=network_info)
return instance_ref, network_info
def test_list_instances_no_inspect_race(self):
"""Assures containers that cannot be inspected are not listed."""
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
with mock.patch('novadocker.tests.virt.docker.mock_client.'
'MockClient.inspect_container',
return_value={}):
instances = self.connection.list_instances()
self.assertFalse(instances)
def _create_node(self):
self.node = db.bm_node_create(self.context, self.node_info)
for nic in self.nic_info:
db.bm_interface_create(self.context, self.node["id"], nic["address"], nic["datapath_id"], nic["port_no"])
self.instance["node"] = self.node["id"]
self.spawn_params = dict(
admin_password="******",
block_device_info=self.test_block_device_info,
context=self.context,
image_meta=utils.get_test_image_info(None, self.instance),
injected_files=[("/fake/path", "hello world")],
instance=self.instance,
network_info=self.test_network_info,
)
def test_cache_image(self):
self.mox.StubOutWithMock(os, 'makedirs')
self.mox.StubOutWithMock(os, 'unlink')
self.mox.StubOutWithMock(os.path, 'exists')
os.makedirs(pxe.get_image_dir_path(self.instance)).AndReturn(True)
disk_path = os.path.join(pxe.get_image_dir_path(self.instance), 'disk')
os.unlink(disk_path).AndReturn(None)
os.path.exists(disk_path).AndReturn(True)
os.path.exists(pxe.get_image_file_path(self.instance)).\
AndReturn(True)
self.mox.ReplayAll()
image_meta = utils.get_test_image_info(self.context, self.instance)
self.driver._cache_image(self.context, self.instance, image_meta)
self.mox.VerifyAll()
def test_create_container_empty_cmd(self, image_info=None,
instance_href=None,
network_info=None):
if instance_href is None:
instance_href = utils.get_test_instance()
instance_href = utils.get_test_instance()
if image_info is None:
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
with mock.patch.object(self.mock_client, 'create_container') as mc:
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password',
network_info=network_info)
command = mc.call_args[1]['command']
self.assertEqual(['sh'], command)
def _create_node(self):
# File injection is off by default, but we should continue to test it
# until it is removed.
CONF.set_override("use_file_injection", True, "baremetal")
self.node = db.bm_node_create(self.context, self.node_info)
for nic in self.nic_info:
db.bm_interface_create(self.context, self.node["id"], nic["address"], nic["datapath_id"], nic["port_no"])
self.instance["node"] = self.node["id"]
self.spawn_params = dict(
admin_password="******",
block_device_info=self.test_block_device_info,
context=self.context,
image_meta=utils.get_test_image_info(None, self.instance),
injected_files=[("/fake/path", "hello world")],
instance=self.instance,
network_info=self.test_network_info,
)
def test_get_image_name(self):
instance_ref = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_ref)
image_info['container_format'] = 'docker'
image_info['name'] = 'MiXeDcAsE-image'
repo = self.connection._get_image_name(self.context,
instance_ref, image_info)
# Assure the repository name pushed into the docker registry is valid.
self.assertIn(":" + str(self.connection._get_registry_port()) + "/",
repo)
self.assertEqual(repo.count(":"), 1)
self.assertEqual(repo.count("/"), 1)
# That the lower-case snapshot name matches the name pushed
image_name = repo.split("/")[1]
self.assertEqual(image_info['name'].lower(), image_name)
def test_get_image_name(self):
instance_ref = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_ref)
image_info['container_format'] = 'docker'
image_info['name'] = 'MiXeDcAsE-image'
repo = self.connection._get_image_name(self.context, instance_ref,
image_info)
# Assure the repository name pushed into the docker registry is valid.
self.assertIn(":" + str(self.connection._get_registry_port()) + "/",
repo)
self.assertEqual(repo.count(":"), 1)
self.assertEqual(repo.count("/"), 1)
# That the lower-case snapshot name matches the name pushed
image_name = repo.split("/")[1]
self.assertEqual(image_info['name'].lower(), image_name)
def test_soft_delete_restore_container(self):
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
container_id = self.connection._find_container_by_name(
instance_href['name']).get('id')
self.connection.soft_delete(instance_href)
info = self.connection.docker.inspect_container(container_id)
self.assertFalse(info['State']['Running'])
self.connection.restore(instance_href)
info = self.connection.docker.inspect_container(container_id)
self.assertTrue(info['State']['Running'])
def test_soft_delete_restore_container(self):
instance_href = utils.get_test_instance()
image_info = utils.get_test_image_info(None, instance_href)
image_info['disk_format'] = 'raw'
image_info['container_format'] = 'docker'
self.connection.spawn(self.context, instance_href, image_info,
'fake_files', 'fake_password')
container_id = self.connection._find_container_by_name(
instance_href['name']).get('id')
self.connection.soft_delete(instance_href)
info = self.connection.docker.inspect_container(container_id)
self.assertFalse(info['State']['Running'])
self.connection.restore(instance_href)
info = self.connection.docker.inspect_container(container_id)
self.assertTrue(info['State']['Running'])
def _create_node(self):
self.node = db.bm_node_create(self.context, self.node_info)
for nic in self.nic_info:
db.bm_interface_create(
self.context,
self.node['id'],
nic['address'],
nic['datapath_id'],
nic['port_no'],
)
self.instance['node'] = self.node['id']
self.spawn_params = dict(
admin_password='******',
block_device_info=self.test_block_device_info,
context=self.context,
image_meta=utils.get_test_image_info(None, self.instance),
injected_files=[('/fake/path', 'hello world')],
instance=self.instance,
network_info=self.test_network_info,
)
def test_spawn(self):
context = test_utils.get_test_admin_context()
instance = test_utils.get_test_instance()
instance['uuid'] = '12345'
network_info = test_utils.get_test_network_info()
block_device_info = None
image_meta = test_utils.get_test_image_info(None, instance)
drv = c.BareMetalDriver()
drv.spawn(context,
instance=instance,
image_meta=image_meta,
injected_files=[('/foo', 'bar'), ('/abc', 'xyz')],
admin_password='******',
network_info=network_info,
block_device_info=block_device_info)
n = bmdb.bm_node_get(context, self.node_id)
self.assertEqual(n['instance_uuid'], instance['uuid'])
self.assertEqual(n['task_state'], baremetal_states.ACTIVE)
def _create_node(self):
self.node = db.bm_node_create(self.context, self.node_info)
for nic in self.nic_info:
db.bm_interface_create(
self.context,
self.node['id'],
nic['address'],
nic['datapath_id'],
nic['port_no'],
)
self.instance['node'] = self.node['id']
self.spawn_params = dict(
admin_password='******',
block_device_info=self.test_block_device_info,
context=self.context,
image_meta=utils.get_test_image_info(None,
self.instance),
injected_files=[('/fake/path', 'hello world')],
instance=self.instance,
network_info=self.test_network_info,
)
def setUp(self):
self.flags(**COMMON_FLAGS)
utils.clear_tables()
super(BaremetalDriverSpawnTestCase, self).setUp()
fake_image.stub_out_image_service(self.stubs)
self.context = test_utils.get_test_admin_context()
self.instance = test_utils.get_test_instance()
self.instance['uuid'] = '12345'
self.network_info = test_utils.get_test_network_info()
self.block_device_info = None
self.image_meta = test_utils.get_test_image_info(None, self.instance)
self.node = _create_baremetal_stuff()
self.node_id = self.node['id']
self.driver = bm_driver.BareMetalDriver()
self.kwargs = dict(context=self.context,
instance=self.instance,
image_meta=self.image_meta,
injected_files=[('/foo', 'bar'), ('/abc', 'xyz')],
admin_password='******',
network_info=self.network_info,
block_device_info=self.block_device_info)
def _create_node(self):
# File injection is off by default, but we should continue to test it
# until it is removed.
CONF.set_override('use_file_injection', True, 'baremetal')
self.node = db.bm_node_create(self.context, self.node_info)
for nic in self.nic_info:
db.bm_interface_create(
self.context,
self.node['id'],
nic['address'],
nic['datapath_id'],
nic['port_no'],
)
self.instance['node'] = self.node['id']
self.spawn_params = dict(
admin_password='******',
block_device_info=self.test_block_device_info,
context=self.context,
image_meta=utils.get_test_image_info(None, self.instance),
injected_files=[('/fake/path', 'hello world')],
instance=self.instance,
network_info=self.test_network_info,
)
def setUp(self):
super(BaremetalDriverSpawnTestCase, self).setUp()
self.flags(**COMMON_FLAGS)
fake_image.stub_out_image_service(self.stubs)
self.node = _create_baremetal_stuff()
self.node_id = self.node['id']
self.context = test_utils.get_test_admin_context()
self.instance = test_utils.get_test_instance()
self.network_info = test_utils.get_test_network_info()
self.block_device_info = None
self.image_meta = test_utils.get_test_image_info(None, self.instance)
self.driver = bm_driver.BareMetalDriver(None)
self.kwargs = dict(
context=self.context,
instance=self.instance,
image_meta=self.image_meta,
injected_files=[('/foo', 'bar'), ('/abc', 'xyz')],
admin_password='******',
network_info=self.network_info,
block_device_info=self.block_device_info)
self.addCleanup(fake_image.FakeImageService_reset)
def _create_node(self):
# File injection is off by default, but we should continue to test it
# until it is removed.
CONF.set_override('use_file_injection', True, 'baremetal')
self.node = db.bm_node_create(self.context, self.node_info)
for nic in self.nic_info:
db.bm_interface_create(
self.context,
self.node['id'],
nic['address'],
nic['datapath_id'],
nic['port_no'],
)
self.instance['node'] = self.node['id']
self.spawn_params = dict(
admin_password='******',
block_device_info=self.test_block_device_info,
context=self.context,
image_meta=utils.get_test_image_info(None,
self.instance),
injected_files=[('/fake/path', 'hello world')],
instance=self.instance,
network_info=self.test_network_info,
)
