def create(self, params, ignore_errors=False):
"""
Create an image using qemu_img or dd.
:param params: Dictionary containing the test parameters.
:param ignore_errors: Whether to ignore errors on the image creation
cmd.
:note: params should contain:
image_name
name of the image file, without extension
image_format
format of the image (qcow2, raw etc)
image_cluster_size (optional)
cluster size for the image
image_size
requested size of the image (a string qemu-img can
understand, such as '10G')
create_with_dd
use dd to create the image (raw format only)
base_image(optional)
the base image name when create snapshot
base_format(optional)
the format of base image
encrypted(optional)
if the image is encrypted, allowed values: on and off.
Default is "off"
preallocated(optional)
if preallocation when create image, allowed values: off,
metadata. Default is "off"
:return: tuple (path to the image created, process.CmdResult object
containing the result of the creation command).
"""
if params.get(
"create_with_dd") == "yes" and self.image_format == "raw":
# maps K,M,G,T => (count, bs)
human = {'K': (1, 1),
'M': (1, 1024),
'G': (1024, 1024),
'T': (1024, 1048576),
}
if self.size[-1] in human:
block_size = human[self.size[-1]][1]
size = int(self.size[:-1]) * human[self.size[-1]][0]
qemu_img_cmd = ("dd if=/dev/zero of=%s count=%s bs=%sK"
% (self.image_filename, size, block_size))
else:
qemu_img_cmd = self.image_cmd
qemu_img_cmd += " create"
qemu_img_cmd += " -f %s" % self.image_format
image_cluster_size = params.get("image_cluster_size", None)
preallocated = params.get("preallocated", "off")
encrypted = params.get("encrypted", "off")
image_extra_params = params.get("image_extra_params", "")
has_backing_file = params.get('has_backing_file')
qemu_img_cmd += " -o "
if self.image_format == "qcow2":
if preallocated != "off":
qemu_img_cmd += "preallocation=%s," % preallocated
if encrypted != "off":
qemu_img_cmd += "encryption=%s," % encrypted
if image_cluster_size:
qemu_img_cmd += "cluster_size=%s," % image_cluster_size
if has_backing_file == "yes":
backing_param = params.object_params("backing_file")
backing_file = storage.get_image_filename(backing_param,
self.root_dir)
backing_fmt = backing_param.get("image_format")
qemu_img_cmd += "backing_file=%s," % backing_file
qemu_img_cmd += "backing_fmt=%s," % backing_fmt
if image_extra_params:
qemu_img_cmd += "%s," % image_extra_params
qemu_img_cmd = qemu_img_cmd.rstrip(" -o")
qemu_img_cmd = qemu_img_cmd.rstrip(",")
if self.base_tag:
qemu_img_cmd += " -b %s" % self.base_image_filename
if self.base_format:
qemu_img_cmd += " -F %s" % self.base_format
qemu_img_cmd += " %s" % self.image_filename
qemu_img_cmd += " %s" % self.size
if (params.get("image_backend", "filesystem") == "filesystem"):
image_dirname = os.path.dirname(self.image_filename)
if image_dirname and not os.path.isdir(image_dirname):
e_msg = ("Parent directory of the image file %s does "
"not exist" % self.image_filename)
logging.error(e_msg)
logging.error("This usually means a serious setup exceptions.")
logging.error("Please verify if your data dir contains the "
"expected directory structure")
logging.error("Backing data dir: %s",
data_dir.get_backing_data_dir())
logging.error("Directory structure:")
for root, _, _ in os.walk(data_dir.get_backing_data_dir()):
logging.error(root)
logging.warning("We'll try to proceed by creating the dir. "
"Other errors may ensue")
os.makedirs(image_dirname)
msg = "Create image by command: %s" % qemu_img_cmd
error_context.context(msg, logging.info)
cmd_result = process.run(
qemu_img_cmd, shell=True, verbose=False, ignore_status=True)
if cmd_result.exit_status != 0 and not ignore_errors:
raise exceptions.TestError("Failed to create image %s" %
self.image_filename)
cmd_result.stdout = results_stdout_52lts(cmd_result)
cmd_result.stderr = results_stderr_52lts(cmd_result)
return self.image_filename, cmd_result
def create(self, params, ignore_errors=False):
"""
Create an image using qemu_img or dd.
:param params: Dictionary containing the test parameters.
:param ignore_errors: Whether to ignore errors on the image creation
cmd.
:note: params should contain:
image_name
name of the image file, without extension
image_format
format of the image (qcow2, raw etc)
image_cluster_size (optional)
cluster size for the image
image_size
requested size of the image (a string qemu-img can
understand, such as '10G')
create_with_dd
use dd to create the image (raw format only)
base_image(optional)
the base image name when create snapshot
base_format(optional)
the format of base image
encrypted(optional)
if the image is encrypted, allowed values: on and off.
Default is "off"
preallocated(optional)
if preallocation when create image, allowed values: off,
metadata. Default is "off"
:return: tuple (path to the image created, process.CmdResult object
containing the result of the creation command).
"""
if params.get(
"create_with_dd") == "yes" and self.image_format == "raw":
# maps K,M,G,T => (count, bs)
human = {
'K': (1, 1),
'M': (1, 1024),
'G': (1024, 1024),
'T': (1024, 1048576),
}
if self.size[-1] in human:
block_size = human[self.size[-1]][1]
size = int(self.size[:-1]) * human[self.size[-1]][0]
qemu_img_cmd = ("dd if=/dev/zero of=%s count=%s bs=%sK" %
(self.image_filename, size, block_size))
else:
cmd_dict = {}
cmd_dict["image_format"] = self.image_format
if self.base_tag:
# if base image has secret, use json representation
base_key_secrets = self.encryption_config.base_key_secrets
if self.base_tag in [s.image_id for s in base_key_secrets]:
base_params = params.object_params(self.base_tag)
cmd_dict["backing_file"] = "'%s'" % \
get_image_json(self.base_tag, base_params,
self.root_dir)
else:
cmd_dict["backing_file"] = self.base_image_filename
if self.base_format:
cmd_dict["backing_format"] = self.base_format
secret_objects = self._secret_objects
if secret_objects:
cmd_dict["secret_object"] = " ".join(secret_objects)
cmd_dict["image_filename"] = self.image_filename
cmd_dict["image_size"] = self.size
options = self._parse_options(params)
if options:
cmd_dict["options"] = ",".join(options)
qemu_img_cmd = self.image_cmd + " " + \
self._cmd_formatter.format(self.create_cmd, **cmd_dict)
if (params.get("image_backend", "filesystem") == "filesystem"):
image_dirname = os.path.dirname(self.image_filename)
if image_dirname and not os.path.isdir(image_dirname):
e_msg = ("Parent directory of the image file %s does "
"not exist" % self.image_filename)
logging.error(e_msg)
logging.error("This usually means a serious setup exceptions.")
logging.error("Please verify if your data dir contains the "
"expected directory structure")
logging.error("Backing data dir: %s",
data_dir.get_backing_data_dir())
logging.error("Directory structure:")
for root, _, _ in os.walk(data_dir.get_backing_data_dir()):
logging.error(root)
logging.warning("We'll try to proceed by creating the dir. "
"Other errors may ensue")
os.makedirs(image_dirname)
msg = "Create image by command: %s" % qemu_img_cmd
error_context.context(msg, logging.info)
cmd_result = process.run(qemu_img_cmd,
shell=True,
verbose=False,
ignore_status=True)
if cmd_result.exit_status != 0 and not ignore_errors:
raise exceptions.TestError("Failed to create image %s\n%s" %
(self.image_filename, cmd_result))
if self.encryption_config.key_secret:
self.encryption_config.key_secret.save_to_file()
cmd_result.stdout = results_stdout_52lts(cmd_result)
cmd_result.stderr = results_stderr_52lts(cmd_result)
return self.image_filename, cmd_result
def create(self, params, ignore_errors=False):
"""
Create an image using qemu_img or dd.
:param params: Dictionary containing the test parameters.
:param ignore_errors: Whether to ignore errors on the image creation
cmd.
:note: params should contain:
image_name
name of the image file, without extension
image_format
format of the image (qcow2, raw etc)
image_cluster_size (optional)
cluster size for the image
image_size
requested size of the image (a string qemu-img can
understand, such as '10G')
create_with_dd
use dd to create the image (raw format only)
base_image(optional)
the base image name when create snapshot
base_format(optional)
the format of base image
encrypted(optional)
if the image is encrypted, allowed values: on and off.
Default is "off"
preallocated(optional)
if preallocation when create image, allowed values: off,
metadata. Default is "off"
:return: tuple (path to the image created, process.CmdResult object
containing the result of the creation command).
"""
if params.get(
"create_with_dd") == "yes" and self.image_format == "raw":
# maps K,M,G,T => (count, bs)
human = {'K': (1, 1),
'M': (1, 1024),
'G': (1024, 1024),
'T': (1024, 1048576),
}
if self.size[-1] in human:
block_size = human[self.size[-1]][1]
size = int(self.size[:-1]) * human[self.size[-1]][0]
qemu_img_cmd = ("dd if=/dev/zero of=%s count=%s bs=%sK"
% (self.image_filename, size, block_size))
else:
qemu_img_cmd = self.image_cmd
qemu_img_cmd += " create"
qemu_img_cmd += " -f %s" % self.image_format
image_cluster_size = params.get("image_cluster_size", None)
preallocated = params.get("preallocated", "off")
encrypted = params.get("encrypted", "off")
image_extra_params = params.get("image_extra_params", "")
has_backing_file = params.get('has_backing_file')
qemu_img_cmd += " -o "
if self.image_format == "qcow2":
if preallocated != "off":
qemu_img_cmd += "preallocation=%s," % preallocated
if encrypted != "off":
qemu_img_cmd += "encryption=%s," % encrypted
if image_cluster_size:
qemu_img_cmd += "cluster_size=%s," % image_cluster_size
if has_backing_file == "yes":
backing_param = params.object_params("backing_file")
backing_file = storage.get_image_filename(backing_param,
self.root_dir)
backing_fmt = backing_param.get("image_format")
qemu_img_cmd += "backing_file=%s," % backing_file
qemu_img_cmd += "backing_fmt=%s," % backing_fmt
if image_extra_params:
qemu_img_cmd += "%s," % image_extra_params
qemu_img_cmd = qemu_img_cmd.rstrip(" -o")
qemu_img_cmd = qemu_img_cmd.rstrip(",")
if self.base_tag:
qemu_img_cmd += " -b %s" % self.base_image_filename
if self.base_format:
qemu_img_cmd += " -F %s" % self.base_format
qemu_img_cmd += " %s" % self.image_filename
qemu_img_cmd += " %s" % self.size
if (params.get("image_backend", "filesystem") == "filesystem"):
image_dirname = os.path.dirname(self.image_filename)
if image_dirname and not os.path.isdir(image_dirname):
e_msg = ("Parent directory of the image file %s does "
"not exist" % self.image_filename)
logging.error(e_msg)
logging.error("This usually means a serious setup exceptions.")
logging.error("Please verify if your data dir contains the "
"expected directory structure")
logging.error("Backing data dir: %s",
data_dir.get_backing_data_dir())
logging.error("Directory structure:")
for root, _, _ in os.walk(data_dir.get_backing_data_dir()):
logging.error(root)
logging.warning("We'll try to proceed by creating the dir. "
"Other errors may ensue")
os.makedirs(image_dirname)
msg = "Create image by command: %s" % qemu_img_cmd
error_context.context(msg, logging.info)
cmd_result = process.run(
qemu_img_cmd, shell=True, verbose=False, ignore_status=True)
if cmd_result.exit_status != 0 and not ignore_errors:
raise exceptions.TestError("Failed to create image %s" %
self.image_filename)
cmd_result.stdout = results_stdout_52lts(cmd_result)
cmd_result.stderr = results_stderr_52lts(cmd_result)
return self.image_filename, cmd_result
