def test_inject_data(self):
orig_os_stat = os.stat
def fake_stat(arg):
if arg == '/some/file': # fake success
return posix.stat_result((16877, 2, 2049L, 23, 0, 0, 4096,
1381787843, 1381635971, 1381635971))
else:
return orig_os_stat(arg)
self.useFixture(fixtures.MonkeyPatch('os.stat', fake_stat))
self.assertTrue(diskapi.inject_data("/some/file", use_cow=True))
self.assertTrue(
diskapi.inject_data("/some/file", mandatory=('files', )))
self.assertTrue(
diskapi.inject_data("/some/file",
key="mysshkey",
mandatory=('key', )))
os_name = os.name
os.name = 'nt' # Cause password injection to fail
self.assertRaises(exception.NovaException,
diskapi.inject_data,
"/some/file",
admin_password="******",
mandatory=('admin_password', ))
self.assertFalse(diskapi.inject_data("/some/file", admin_password="******"))
os.name = os_name
self.assertFalse(diskapi.inject_data("/some/fail/file"))
def test_inject_into_image(self):
self._create_node()
files = []
self.instance['hostname'] = 'fake hostname'
files.append(('/etc/hostname', 'fake hostname'))
self.instance['key_data'] = 'fake ssh key'
net_info = utils.get_test_network_info(1)
net = tilera.build_network_config(net_info)
admin_password = '******'
self.mox.StubOutWithMock(disk_api, 'inject_data')
disk_api.inject_data(
admin_password=admin_password,
image=tilera.get_image_file_path(self.instance),
key='fake ssh key',
metadata=None,
partition=None,
net=net,
files=files,
).AndReturn(True)
self.mox.ReplayAll()
self.driver._inject_into_image(
self.context, self.node, self.instance,
network_info=net_info,
admin_password=admin_password,
injected_files=None)
self.mox.VerifyAll()
def test_inject_into_image(self):
# NOTE(deva): we could also test this method by stubbing
# nova.virt.disk.api._inject_*_into_fs
self._create_node()
files = []
self.instance['hostname'] = 'fake hostname'
files.append(('/etc/hostname', 'fake hostname'))
self.instance['key_data'] = 'fake ssh key'
net_info = utils.get_test_network_info(1)
net = pxe.build_network_config(net_info)
admin_password = '******'
self.mox.StubOutWithMock(disk_api, 'inject_data')
disk_api.inject_data(
admin_password=admin_password,
image=pxe.get_image_file_path(self.instance),
key='fake ssh key',
metadata=None,
partition=None,
net=net,
files=files, # this is what we're really testing
).AndReturn(True)
self.mox.ReplayAll()
self.driver._inject_into_image(self.context,
self.node,
self.instance,
network_info=net_info,
admin_password=admin_password,
injected_files=None)
self.mox.VerifyAll()
def test_inject_data(self):
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_QCOW2)))
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
mandatory=('files',)))
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
key="mysshkey",
mandatory=('key',)))
os_name = os.name
os.name = 'nt' # Cause password injection to fail
self.assertRaises(exception.NovaException,
diskapi.inject_data,
imgmodel.LocalFileImage("/some/file",
imgmodel.FORMAT_RAW),
admin_password="******",
mandatory=('admin_password',))
self.assertFalse(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
admin_password="******"))
os.name = os_name
self.assertFalse(diskapi.inject_data(
imgmodel.LocalFileImage("/some/fail/file", imgmodel.FORMAT_RAW),
key="mysshkey"))
def test_inject_data(self):
orig_os_stat = os.stat
def fake_stat(arg):
if arg == '/some/file': # fake success
return stat_result((16877, 2, 2049L,
23, 0, 0,
4096, 1381787843,
1381635971, 1381635971))
else:
return orig_os_stat(arg)
self.useFixture(fixtures.MonkeyPatch('os.stat', fake_stat))
self.assertTrue(diskapi.inject_data("/some/file", use_cow=True))
self.assertTrue(diskapi.inject_data("/some/file",
mandatory=('files',)))
self.assertTrue(diskapi.inject_data("/some/file", key="mysshkey",
mandatory=('key',)))
os_name = os.name
os.name = 'nt' # Cause password injection to fail
self.assertRaises(exception.NovaException,
diskapi.inject_data,
"/some/file", admin_password="******",
mandatory=('admin_password',))
self.assertFalse(diskapi.inject_data("/some/file", admin_password="******"))
os.name = os_name
self.assertFalse(diskapi.inject_data("/some/fail/file"))
def test_inject_into_image(self):
# NOTE(deva): we could also test this method by stubbing
# nova.virt.disk.api._inject_*_into_fs
self._create_node()
files = []
self.instance['hostname'] = 'fake hostname'
files.append(('/etc/hostname', 'fake hostname'))
self.instance['key_data'] = 'fake ssh key'
net_info = utils.get_test_network_info(1)
net = pxe.build_network_config(net_info)
admin_password = '******'
self.mox.StubOutWithMock(disk_api, 'inject_data')
disk_api.inject_data(
admin_password=admin_password,
image=pxe.get_image_file_path(self.instance),
key='fake ssh key',
metadata=None,
partition=None,
net=net,
files=files, # this is what we're really testing
).AndReturn(True)
self.mox.ReplayAll()
self.driver._inject_into_image(
self.context, self.node, self.instance,
network_info=net_info,
admin_password=admin_password,
injected_files=None)
self.mox.VerifyAll()
def test_inject_data(self):
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_QCOW2)))
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
mandatory=('files',)))
self.assertTrue(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
key="mysshkey",
mandatory=('key',)))
os_name = os.name
os.name = 'nt' # Cause password injection to fail
self.assertRaises(exception.NovaException,
diskapi.inject_data,
imgmodel.LocalFileImage("/some/file",
imgmodel.FORMAT_RAW),
admin_password="******",
mandatory=('admin_password',))
self.assertFalse(diskapi.inject_data(
imgmodel.LocalFileImage("/some/file", imgmodel.FORMAT_RAW),
admin_password="******"))
os.name = os_name
self.assertFalse(diskapi.inject_data(
imgmodel.LocalFileImage("/some/fail/file", imgmodel.FORMAT_RAW),
key="mysshkey"))
def test_inject_into_image(self):
self._create_node()
files = []
self.instance["hostname"] = "fake hostname"
files.append(("/etc/hostname", "fake hostname"))
self.instance["key_data"] = "fake ssh key"
net_info = utils.get_test_network_info(1)
net = tilera.build_network_config(net_info)
admin_password = "******"
self.mox.StubOutWithMock(os.path, "exists")
os.path.exists(mox.IgnoreArg()).AndReturn(True)
self.mox.StubOutWithMock(disk_api, "inject_data")
disk_api.inject_data(
admin_password=admin_password,
image=tilera.get_image_file_path(self.instance),
key="fake ssh key",
metadata=None,
partition=None,
net=net,
files=files,
).AndReturn(True)
self.mox.ReplayAll()
self.driver._inject_into_image(
self.context,
self.node,
self.instance,
network_info=net_info,
admin_password=admin_password,
injected_files=None,
)
self.mox.VerifyAll()
def inject_into_image(image, key, net, metadata, admin_password,
files, partition, use_cow=False):
try:
disk_api.inject_data(image, key, net, metadata, admin_password,
files, partition, use_cow)
except Exception as e:
LOG.warn(_("Failed to inject data into image %(image)s. "
"Error: %(e)s") % locals())
def inject_into_image(image, key, net, metadata, admin_password,
files, partition, use_cow=False):
try:
disk_api.inject_data(image, key, net, metadata, admin_password,
files, partition, use_cow)
except Exception as e:
LOG.warn(_("Failed to inject data into image %(image)s. "
"Error: %(e)s") % locals())
def inject_into_image(image, key, net, metadata, admin_password, files,
partition, use_cow=False):
try:
if os.path.exists(image):
disk_api.inject_data(image, key, net, metadata, admin_password,
files, partition, use_cow)
else:
LOG.warning(_('Image %s not found on disk storage. '
'Continue without injecting data'), image)
except Exception as e:
LOG.warn(_("Failed to inject data into image %(image)s. "
"Error: %(e)s"), {'image': image, 'e': e})
def test_inject_data(self):
self.assertTrue(diskapi.inject_data("/some/file", use_cow=True))
self.assertTrue(diskapi.inject_data("/some/file",
mandatory=('files',)))
self.assertTrue(diskapi.inject_data("/some/file", key="mysshkey",
mandatory=('key',)))
os_name = os.name
os.name = 'nt' # Cause password injection to fail
self.assertRaises(exception.NovaException,
diskapi.inject_data,
"/some/file", admin_password="******",
mandatory=('admin_password',))
self.assertFalse(diskapi.inject_data("/some/file", admin_password="******"))
os.name = os_name
def _inject_files(self, sdk_ve, boot_hdd, instance, network_info=None,
files=None, admin_pass=None):
disk_path = boot_hdd.get_image_path()
target_partition = CONF.pcs_inject_partition
if target_partition == 0:
target_partition = None
key = str(instance['key_data'])
net = netutils.get_injected_network_template(network_info)
metadata = instance.get('metadata')
if any((key, net, metadata, admin_pass, files)):
# If we're not using config_drive, inject into root fs
LOG.info('Injecting files')
try:
img_id = instance['image_ref']
for inj, val in [('key', key),
('net', net),
('metadata', metadata),
('admin_pass', admin_pass),
('files', files)]:
if val:
LOG.info(_('Injecting %(inj)s into image '
'%(img_id)s'),
{'inj': inj, 'img_id': img_id},
instance=instance)
with pcsutils.PloopMount(disk_path, chown=True,
root_helper=utils._get_root_helper()) as dev:
disk.inject_data(dev, key, net, metadata,
admin_pass, files,
partition=target_partition,
use_cow=False,
mandatory=('files',))
except Exception as e:
with excutils.save_and_reraise_exception():
LOG.error(_('Error injecting data into image '
'%(img_id)s (%(e)s)'),
{'img_id': img_id, 'e': e},
instance=instance)
def inject_into_image(image,
key,
net,
metadata,
admin_password,
files,
partition,
use_cow=False):
try:
if os.path.exists(image):
disk_api.inject_data(image, key, net, metadata, admin_password,
files, partition, use_cow)
else:
LOG.warning(
_('Image %s not found on disk storage. '
'Continue without injecting data'), image)
except Exception as e:
LOG.warn(
_("Failed to inject data into image %(image)s. "
"Error: %(e)s"), {
'image': image,
'e': e
})
def test_inject_into_image(self):
# NOTE(deva): we could also test this method by stubbing
# nova.virt.disk.api._inject_*_into_fs
self._create_node()
files = []
self.instance["hostname"] = "fake hostname"
files.append(("/etc/hostname", "fake hostname"))
self.instance["key_data"] = "fake ssh key"
net_info = utils.get_test_network_info(1)
net = pxe.build_network_config(net_info)
admin_password = "******"
self.mox.StubOutWithMock(os.path, "exists")
os.path.exists(mox.IgnoreArg()).AndReturn(True)
self.mox.StubOutWithMock(disk_api, "inject_data")
disk_api.inject_data(
admin_password=admin_password,
image=pxe.get_image_file_path(self.instance),
key="fake ssh key",
metadata=None,
partition=None,
net=net,
files=files, # this is what we're really testing
).AndReturn(True)
self.mox.ReplayAll()
self.driver._inject_into_image(
self.context,
self.node,
self.instance,
network_info=net_info,
admin_password=admin_password,
injected_files=None,
)
self.mox.VerifyAll()
def _inject_to_image(self, context, target, node, inst, network_info,
injected_files=None, admin_password=None):
# For now, we assume that if we're not using a kernel, we're using a
# partitioned disk image where the target partition is the first
# partition
target_partition = None
if not inst['kernel_id']:
target_partition = "1"
if inst['key_data']:
key = str(inst['key_data'])
else:
key = None
net = ""
nets = []
ifc_template = open(FLAGS.baremetal_injected_network_template).read()
ifc_num = -1
have_injected_networks = False
for (network_ref, mapping) in network_info:
ifc_num += 1
# always inject
#if not network_ref['injected']:
# continue
have_injected_networks = True
address = mapping['ips'][0]['ip']
netmask = mapping['ips'][0]['netmask']
address_v6 = None
gateway_v6 = None
netmask_v6 = None
if FLAGS.use_ipv6:
address_v6 = mapping['ip6s'][0]['ip']
netmask_v6 = mapping['ip6s'][0]['netmask']
gateway_v6 = mapping['gateway_v6']
name = 'eth%d' % ifc_num
net_info = {'name': name,
'address': address,
'netmask': netmask,
'gateway': mapping['gateway'],
'broadcast': mapping['broadcast'],
'dns': ' '.join(mapping['dns']),
'address_v6': address_v6,
'gateway_v6': gateway_v6,
'netmask_v6': netmask_v6,
'hwaddress': mapping['mac']}
nets.append(net_info)
if have_injected_networks:
_late_load_cheetah()
net = str(Template(ifc_template,
searchList=[{'interfaces': nets,
'use_ipv6': FLAGS.use_ipv6}]))
bootif_name = "eth0"
net += "\n"
net += "auto %s\n" % bootif_name
net += "iface %s inet dhcp\n" % bootif_name
admin_password = None
metadata = inst.get('metadata')
if any((key, net, metadata, admin_password)):
inst_name = inst['name']
img_id = inst['image_ref']
for injection in ('metadata', 'key', 'net', 'admin_password'):
if locals()[injection]:
LOG.info(_('instance %(inst_name)s: injecting '
'%(injection)s into image %(img_id)s'),
locals(), instance=inst)
try:
disk.inject_data(target,
key, net, metadata, admin_password,
files=injected_files,
partition=target_partition,
use_cow=False)
except Exception as e:
# This could be a windows image, or a vmdk format disk
LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
' data into image %(img_id)s (%(e)s)') % locals(),
instance=inst)
def _inject_to_image(self,
context,
target,
node,
inst,
network_info,
injected_files=None,
admin_password=None):
# For now, we assume that if we're not using a kernel, we're using a
# partitioned disk image where the target partition is the first
# partition
target_partition = None
if not inst['kernel_id']:
target_partition = "1"
if inst['key_data']:
key = str(inst['key_data'])
else:
key = None
net = ""
nets = []
ifc_template = open(FLAGS.baremetal_injected_network_template).read()
ifc_num = -1
have_injected_networks = False
for (network_ref, mapping) in network_info:
ifc_num += 1
# always inject
#if not network_ref['injected']:
# continue
have_injected_networks = True
address = mapping['ips'][0]['ip']
netmask = mapping['ips'][0]['netmask']
address_v6 = None
gateway_v6 = None
netmask_v6 = None
if FLAGS.use_ipv6:
address_v6 = mapping['ip6s'][0]['ip']
netmask_v6 = mapping['ip6s'][0]['netmask']
gateway_v6 = mapping['gateway_v6']
name = 'eth%d' % ifc_num
net_info = {
'name': name,
'address': address,
'netmask': netmask,
'gateway': mapping['gateway'],
'broadcast': mapping['broadcast'],
'dns': ' '.join(mapping['dns']),
'address_v6': address_v6,
'gateway_v6': gateway_v6,
'netmask_v6': netmask_v6,
'hwaddress': mapping['mac']
}
nets.append(net_info)
if have_injected_networks:
_late_load_cheetah()
net = str(
Template(ifc_template,
searchList=[{
'interfaces': nets,
'use_ipv6': FLAGS.use_ipv6
}]))
bootif_name = "eth0"
net += "\n"
net += "auto %s\n" % bootif_name
net += "iface %s inet dhcp\n" % bootif_name
admin_password = None
metadata = inst.get('metadata')
if any((key, net, metadata, admin_password)):
inst_name = inst['name']
img_id = inst['image_ref']
for injection in ('metadata', 'key', 'net', 'admin_password'):
if locals()[injection]:
LOG.info(_('instance %(inst_name)s: injecting '
'%(injection)s into image %(img_id)s'),
locals(),
instance=inst)
try:
disk.inject_data(target,
key,
net,
metadata,
admin_password,
files=injected_files,
partition=target_partition,
use_cow=False)
except Exception as e:
# This could be a windows image, or a vmdk format disk
LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
' data into image %(img_id)s (%(e)s)') % locals(),
instance=inst)
def _create_image(self,
context,
inst,
xml,
suffix='',
disk_images=None,
network_info=None,
block_device_info=None):
if not suffix:
suffix = ''
# syntactic nicety
def basepath(fname='', suffix=suffix):
return os.path.join(FLAGS.instances_path, inst['name'],
fname + suffix)
# ensure directories exist and are writable
libvirt_utils.ensure_tree(basepath(suffix=''))
utils.execute('chmod', '0777', basepath(suffix=''))
LOG.info(_('instance %s: Creating image'), inst['name'], instance=inst)
if FLAGS.baremetal_type == 'lxc':
container_dir = '%s/rootfs' % basepath(suffix='')
libvirt_utils.ensure_tree(container_dir)
# NOTE(vish): No need add the suffix to console.log
libvirt_utils.write_to_file(basepath('console.log', ''), '', 007)
if not disk_images:
disk_images = {
'image_id': inst['image_ref'],
'kernel_id': inst['kernel_id'],
'ramdisk_id': inst['ramdisk_id']
}
if disk_images['kernel_id']:
fname = disk_images['kernel_id']
self._cache_image(fn=libvirt_utils.fetch_image,
context=context,
target=basepath('kernel'),
fname=fname,
cow=False,
image_id=disk_images['kernel_id'],
user_id=inst['user_id'],
project_id=inst['project_id'])
if disk_images['ramdisk_id']:
fname = disk_images['ramdisk_id']
self._cache_image(fn=libvirt_utils.fetch_image,
context=context,
target=basepath('ramdisk'),
fname=fname,
cow=False,
image_id=disk_images['ramdisk_id'],
user_id=inst['user_id'],
project_id=inst['project_id'])
root_fname = hashlib.sha1(str(disk_images['image_id'])).hexdigest()
size = inst['root_gb'] * 1024 * 1024 * 1024
inst_type_id = inst['instance_type_id']
inst_type = instance_types.get_instance_type(inst_type_id)
if inst_type['name'] == 'm1.tiny' or suffix == '.rescue':
size = None
root_fname += "_sm"
else:
root_fname += "_%d" % inst['root_gb']
self._cache_image(
fn=libvirt_utils.fetch_image,
context=context,
target=basepath('root'),
fname=root_fname,
cow=False, # FLAGS.use_cow_images,
image_id=disk_images['image_id'],
user_id=inst['user_id'],
project_id=inst['project_id'])
# For now, we assume that if we're not using a kernel, we're using a
# partitioned disk image where the target partition is the first
# partition
target_partition = None
if not inst['kernel_id']:
target_partition = "1"
if FLAGS.baremetal_type == 'lxc':
target_partition = None
if inst['key_data']:
key = str(inst['key_data'])
else:
key = None
net = None
nets = []
ifc_template = open(FLAGS.injected_network_template).read()
ifc_num = -1
have_injected_networks = False
admin_context = nova_context.get_admin_context()
for (network_ref, mapping) in network_info:
ifc_num += 1
if not network_ref['injected']:
continue
have_injected_networks = True
address = mapping['ips'][0]['ip']
netmask = mapping['ips'][0]['netmask']
address_v6 = None
gateway_v6 = None
netmask_v6 = None
if FLAGS.use_ipv6:
address_v6 = mapping['ip6s'][0]['ip']
netmask_v6 = mapping['ip6s'][0]['netmask']
gateway_v6 = mapping['gateway_v6']
net_info = {
'name': 'eth%d' % ifc_num,
'address': address,
'netmask': netmask,
'gateway': mapping['gateway'],
'broadcast': mapping['broadcast'],
'dns': ' '.join(mapping['dns']),
'address_v6': address_v6,
'gateway_v6': gateway_v6,
'netmask_v6': netmask_v6
}
nets.append(net_info)
if have_injected_networks:
net = str(
Template(ifc_template,
searchList=[{
'interfaces': nets,
'use_ipv6': FLAGS.use_ipv6
}]))
metadata = inst.get('metadata')
if any((key, net, metadata)):
inst_name = inst['name']
injection_path = basepath('root')
img_id = inst.image_ref
disable_auto_fsck = True
for injection in ('metadata', 'key', 'net'):
if locals()[injection]:
LOG.info(_('instance %(inst_name)s: injecting '
'%(injection)s into image %(img_id)s'),
locals(),
instance=inst)
try:
disk.inject_data(
injection_path,
key,
net,
metadata,
partition=target_partition,
use_cow=False, # FLAGS.use_cow_images,
disable_auto_fsck=disable_auto_fsck)
except Exception as e:
# This could be a windows image, or a vmdk format disk
LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
' data into image %(img_id)s (%(e)s)') % locals(),
instance=inst)
def _create_image(self, context, inst, xml, suffix="", disk_images=None, network_info=None, block_device_info=None):
if not suffix:
suffix = ""
# syntactic nicety
def basepath(fname="", suffix=suffix):
return os.path.join(FLAGS.instances_path, inst["name"], fname + suffix)
# ensure directories exist and are writable
libvirt_utils.ensure_tree(basepath(suffix=""))
utils.execute("chmod", "0777", basepath(suffix=""))
LOG.info(_("instance %s: Creating image"), inst["name"], instance=inst)
if FLAGS.baremetal_type == "lxc":
container_dir = "%s/rootfs" % basepath(suffix="")
libvirt_utils.ensure_tree(container_dir)
# NOTE(vish): No need add the suffix to console.log
libvirt_utils.write_to_file(basepath("console.log", ""), "", 007)
if not disk_images:
disk_images = {
"image_id": inst["image_ref"],
"kernel_id": inst["kernel_id"],
"ramdisk_id": inst["ramdisk_id"],
}
if disk_images["kernel_id"]:
fname = disk_images["kernel_id"]
self._cache_image(
fn=libvirt_utils.fetch_image,
context=context,
target=basepath("kernel"),
fname=fname,
cow=False,
image_id=disk_images["kernel_id"],
user_id=inst["user_id"],
project_id=inst["project_id"],
)
if disk_images["ramdisk_id"]:
fname = disk_images["ramdisk_id"]
self._cache_image(
fn=libvirt_utils.fetch_image,
context=context,
target=basepath("ramdisk"),
fname=fname,
cow=False,
image_id=disk_images["ramdisk_id"],
user_id=inst["user_id"],
project_id=inst["project_id"],
)
root_fname = hashlib.sha1(str(disk_images["image_id"])).hexdigest()
size = inst["root_gb"] * 1024 * 1024 * 1024
inst_type_id = inst["instance_type_id"]
inst_type = instance_types.get_instance_type(inst_type_id)
if inst_type["name"] == "m1.tiny" or suffix == ".rescue":
size = None
root_fname += "_sm"
else:
root_fname += "_%d" % inst["root_gb"]
self._cache_image(
fn=libvirt_utils.fetch_image,
context=context,
target=basepath("root"),
fname=root_fname,
cow=False, # FLAGS.use_cow_images,
image_id=disk_images["image_id"],
user_id=inst["user_id"],
project_id=inst["project_id"],
)
# For now, we assume that if we're not using a kernel, we're using a
# partitioned disk image where the target partition is the first
# partition
target_partition = None
if not inst["kernel_id"]:
target_partition = "1"
if FLAGS.baremetal_type == "lxc":
target_partition = None
if inst["key_data"]:
key = str(inst["key_data"])
else:
key = None
net = None
nets = []
ifc_template = open(FLAGS.injected_network_template).read()
ifc_num = -1
have_injected_networks = False
admin_context = nova_context.get_admin_context()
for (network_ref, mapping) in network_info:
ifc_num += 1
if not network_ref["injected"]:
continue
have_injected_networks = True
address = mapping["ips"][0]["ip"]
netmask = mapping["ips"][0]["netmask"]
address_v6 = None
gateway_v6 = None
netmask_v6 = None
if FLAGS.use_ipv6:
address_v6 = mapping["ip6s"][0]["ip"]
netmask_v6 = mapping["ip6s"][0]["netmask"]
gateway_v6 = mapping["gateway_v6"]
net_info = {
"name": "eth%d" % ifc_num,
"address": address,
"netmask": netmask,
"gateway": mapping["gateway"],
"broadcast": mapping["broadcast"],
"dns": " ".join(mapping["dns"]),
"address_v6": address_v6,
"gateway_v6": gateway_v6,
"netmask_v6": netmask_v6,
}
nets.append(net_info)
if have_injected_networks:
net = str(Template(ifc_template, searchList=[{"interfaces": nets, "use_ipv6": FLAGS.use_ipv6}]))
metadata = inst.get("metadata")
if any((key, net, metadata)):
inst_name = inst["name"]
injection_path = basepath("root")
img_id = inst.image_ref
disable_auto_fsck = True
for injection in ("metadata", "key", "net"):
if locals()[injection]:
LOG.info(
_("instance %(inst_name)s: injecting " "%(injection)s into image %(img_id)s"),
locals(),
instance=inst,
)
try:
disk.inject_data(
injection_path,
key,
net,
metadata,
partition=target_partition,
use_cow=False, # FLAGS.use_cow_images,
disable_auto_fsck=disable_auto_fsck,
)
except Exception as e:
# This could be a windows image, or a vmdk format disk
LOG.warn(
_("instance %(inst_name)s: ignoring error injecting" " data into image %(img_id)s (%(e)s)")
% locals(),
instance=inst,
)
def _inject_to_image(self,
context,
target,
node,
inst,
network_info,
injected_files=None,
admin_password=None):
# For now, we assume that if we're not using a kernel, we're using a
# partitioned disk image where the target partition is the first
# partition
target_partition = None
if not inst['kernel_id']:
target_partition = "1"
nics_in_order = []
pifs = bmdb.bm_interface_get_all_by_bm_node_id(context, node['id'])
for pif in pifs:
nics_in_order.append(pif['address'])
nics_in_order.append(node['prov_mac_address'])
# rename nics to be in the order in the DB
LOG.debug("injecting persistent net")
rules = ""
i = 0
for hwaddr in nics_in_order:
rules += 'SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ' \
'ATTR{address}=="%s", ATTR{dev_id}=="0x0", ' \
'ATTR{type}=="1", KERNEL=="eth*", NAME="eth%d"\n' \
% (hwaddr.lower(), i)
i += 1
if not injected_files:
injected_files = []
injected_files.append(
('/etc/udev/rules.d/70-persistent-net.rules', rules))
bootif_name = "eth%d" % (i - 1)
if inst['key_data']:
key = str(inst['key_data'])
else:
key = None
net = ""
nets = []
ifc_template = open(FLAGS.baremetal_injected_network_template).read()
ifc_num = -1
have_injected_networks = False
for (network_ref, mapping) in network_info:
ifc_num += 1
# always inject
#if not network_ref['injected']:
# continue
have_injected_networks = True
address = mapping['ips'][0]['ip']
netmask = mapping['ips'][0]['netmask']
address_v6 = None
gateway_v6 = None
netmask_v6 = None
if FLAGS.use_ipv6:
address_v6 = mapping['ip6s'][0]['ip']
netmask_v6 = mapping['ip6s'][0]['netmask']
gateway_v6 = mapping['gateway_v6']
name = 'eth%d' % ifc_num
if FLAGS.baremetal_use_unsafe_vlan \
and mapping['should_create_vlan'] \
and network_ref.get('vlan'):
name = 'eth%d.%d' % (ifc_num, network_ref.get('vlan'))
net_info = {
'name': name,
'address': address,
'netmask': netmask,
'gateway': mapping['gateway'],
'broadcast': mapping['broadcast'],
'dns': ' '.join(mapping['dns']),
'address_v6': address_v6,
'gateway_v6': gateway_v6,
'netmask_v6': netmask_v6,
'hwaddress': mapping['mac']
}
nets.append(net_info)
if have_injected_networks:
_late_load_cheetah()
net = str(
Template(ifc_template,
searchList=[{
'interfaces': nets,
'use_ipv6': FLAGS.use_ipv6
}]))
net += "\n"
net += "auto %s\n" % bootif_name
net += "iface %s inet dhcp\n" % bootif_name
if not FLAGS.baremetal_inject_password:
admin_password = None
metadata = inst.get('metadata')
if any((key, net, metadata, admin_password)):
inst_name = inst['name']
img_id = inst['image_ref']
for injection in ('metadata', 'key', 'net', 'admin_password'):
if locals()[injection]:
LOG.info(_('instance %(inst_name)s: injecting '
'%(injection)s into image %(img_id)s'),
locals(),
instance=inst)
try:
disk.inject_data(target,
key,
net,
metadata,
admin_password,
files=injected_files,
partition=target_partition,
use_cow=False)
except Exception as e:
# This could be a windows image, or a vmdk format disk
LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
' data into image %(img_id)s (%(e)s)') % locals(),
instance=inst)
def _inject_to_image(self, context, target, node, inst, network_info,
injected_files=None, admin_password=None):
# For now, we assume that if we're not using a kernel, we're using a
# partitioned disk image where the target partition is the first
# partition
target_partition = None
if not inst['kernel_id']:
target_partition = "1"
nics_in_order = []
pifs = bmdb.bm_interface_get_all_by_bm_node_id(context, node['id'])
for pif in pifs:
nics_in_order.append(pif['address'])
nics_in_order.append(node['prov_mac_address'])
# rename nics to be in the order in the DB
LOG.debug("injecting persistent net")
rules = ""
i = 0
for hwaddr in nics_in_order:
rules += 'SUBSYSTEM=="net", ACTION=="add", DRIVERS=="?*", ' \
'ATTR{address}=="%s", ATTR{dev_id}=="0x0", ' \
'ATTR{type}=="1", KERNEL=="eth*", NAME="eth%d"\n' \
% (hwaddr.lower(), i)
i += 1
if not injected_files:
injected_files = []
injected_files.append(('/etc/udev/rules.d/70-persistent-net.rules',
rules))
bootif_name = "eth%d" % (i - 1)
if inst['key_data']:
key = str(inst['key_data'])
else:
key = None
net = ""
nets = []
ifc_template = open(FLAGS.baremetal_injected_network_template).read()
ifc_num = -1
have_injected_networks = False
for (network_ref, mapping) in network_info:
ifc_num += 1
# always inject
#if not network_ref['injected']:
# continue
have_injected_networks = True
address = mapping['ips'][0]['ip']
netmask = mapping['ips'][0]['netmask']
address_v6 = None
gateway_v6 = None
netmask_v6 = None
if FLAGS.use_ipv6:
address_v6 = mapping['ip6s'][0]['ip']
netmask_v6 = mapping['ip6s'][0]['netmask']
gateway_v6 = mapping['gateway_v6']
name = 'eth%d' % ifc_num
if FLAGS.baremetal_use_unsafe_vlan \
and mapping['should_create_vlan'] \
and network_ref.get('vlan'):
name = 'eth%d.%d' % (ifc_num, network_ref.get('vlan'))
net_info = {'name': name,
'address': address,
'netmask': netmask,
'gateway': mapping['gateway'],
'broadcast': mapping['broadcast'],
'dns': ' '.join(mapping['dns']),
'address_v6': address_v6,
'gateway_v6': gateway_v6,
'netmask_v6': netmask_v6,
'hwaddress': mapping['mac']}
nets.append(net_info)
if have_injected_networks:
_late_load_cheetah()
net = str(Template(ifc_template,
searchList=[{'interfaces': nets,
'use_ipv6': FLAGS.use_ipv6}]))
net += "\n"
net += "auto %s\n" % bootif_name
net += "iface %s inet dhcp\n" % bootif_name
if not FLAGS.baremetal_inject_password:
admin_password = None
metadata = inst.get('metadata')
if any((key, net, metadata, admin_password)):
inst_name = inst['name']
img_id = inst['image_ref']
for injection in ('metadata', 'key', 'net', 'admin_password'):
if locals()[injection]:
LOG.info(_('instance %(inst_name)s: injecting '
'%(injection)s into image %(img_id)s'),
locals(), instance=inst)
try:
disk.inject_data(target,
key, net, metadata, admin_password,
files=injected_files,
partition=target_partition,
use_cow=False)
except Exception as e:
# This could be a windows image, or a vmdk format disk
LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
' data into image %(img_id)s (%(e)s)') % locals(),
instance=inst)
def _create_image(self, context, inst, xml, suffix='',
disk_images=None, network_info=None,
block_device_info=None):
if not suffix:
suffix = ''
# syntactic nicety
def basepath(fname='', suffix=suffix):
return os.path.join(FLAGS.instances_path,
inst['name'],
fname + suffix)
# ensure directories exist and are writable
libvirt_utils.ensure_tree(basepath(suffix=''))
utils.execute('chmod', '0777', basepath(suffix=''))
LOG.info(_('instance %s: Creating image'), inst['name'],
instance=inst)
if FLAGS.baremetal_type == 'lxc':
container_dir = '%s/rootfs' % basepath(suffix='')
libvirt_utils.ensure_tree(container_dir)
# NOTE(vish): No need add the suffix to console.log
libvirt_utils.write_to_file(basepath('console.log', ''), '', 007)
if not disk_images:
disk_images = {'image_id': inst['image_ref'],
'kernel_id': inst['kernel_id'],
'ramdisk_id': inst['ramdisk_id']}
if disk_images['kernel_id']:
fname = disk_images['kernel_id']
self._cache_image(fn=libvirt_utils.fetch_image,
context=context,
target=basepath('kernel'),
fname=fname,
cow=False,
image_id=disk_images['kernel_id'],
user_id=inst['user_id'],
project_id=inst['project_id'])
if disk_images['ramdisk_id']:
fname = disk_images['ramdisk_id']
self._cache_image(fn=libvirt_utils.fetch_image,
context=context,
target=basepath('ramdisk'),
fname=fname,
cow=False,
image_id=disk_images['ramdisk_id'],
user_id=inst['user_id'],
project_id=inst['project_id'])
root_fname = hashlib.sha1(str(disk_images['image_id'])).hexdigest()
size = inst['root_gb'] * 1024 * 1024 * 1024
inst_type_id = inst['instance_type_id']
inst_type = instance_types.get_instance_type(inst_type_id)
if inst_type['name'] == 'm1.tiny' or suffix == '.rescue':
size = None
root_fname += "_sm"
else:
root_fname += "_%d" % inst['root_gb']
self._cache_image(fn=libvirt_utils.fetch_image,
context=context,
target=basepath('root'),
fname=root_fname,
cow=False, # FLAGS.use_cow_images,
image_id=disk_images['image_id'],
user_id=inst['user_id'],
project_id=inst['project_id'])
# For now, we assume that if we're not using a kernel, we're using a
# partitioned disk image where the target partition is the first
# partition
target_partition = None
if not inst['kernel_id']:
target_partition = "1"
if FLAGS.baremetal_type == 'lxc':
target_partition = None
if inst['key_data']:
key = str(inst['key_data'])
else:
key = None
net = None
nets = []
ifc_template = open(FLAGS.injected_network_template).read()
ifc_num = -1
have_injected_networks = False
admin_context = nova_context.get_admin_context()
for (network_ref, mapping) in network_info:
ifc_num += 1
if not network_ref['injected']:
continue
have_injected_networks = True
address = mapping['ips'][0]['ip']
netmask = mapping['ips'][0]['netmask']
address_v6 = None
gateway_v6 = None
netmask_v6 = None
if FLAGS.use_ipv6:
address_v6 = mapping['ip6s'][0]['ip']
netmask_v6 = mapping['ip6s'][0]['netmask']
gateway_v6 = mapping['gateway_v6']
net_info = {'name': 'eth%d' % ifc_num,
'address': address,
'netmask': netmask,
'gateway': mapping['gateway'],
'broadcast': mapping['broadcast'],
'dns': ' '.join(mapping['dns']),
'address_v6': address_v6,
'gateway_v6': gateway_v6,
'netmask_v6': netmask_v6}
nets.append(net_info)
if have_injected_networks:
net = str(Template(ifc_template,
searchList=[{'interfaces': nets,
'use_ipv6': FLAGS.use_ipv6}]))
metadata = inst.get('metadata')
if any((key, net, metadata)):
inst_name = inst['name']
injection_path = basepath('root')
img_id = inst['image_ref']
for injection in ('metadata', 'key', 'net'):
if locals()[injection]:
LOG.info(_('instance %(inst_name)s: injecting '
'%(injection)s into image %(img_id)s'),
locals(), instance=inst)
try:
disk.inject_data(injection_path, key, net, metadata,
partition=target_partition,
use_cow=False) # FLAGS.use_cow_images
except Exception as e:
# This could be a windows image, or a vmdk format disk
LOG.warn(_('instance %(inst_name)s: ignoring error injecting'
' data into image %(img_id)s (%(e)s)') % locals(),
instance=inst)
