def test_copy_volume_to_image(self):
drv = self._driver
vol = db_fakes.get_fake_volume_info()
image_meta = db_fakes.get_fake_image_meta()
self.stubs.Set(drv, 'local_path', self.fake_local_path)
self.mox.StubOutWithMock(image_utils, 'upload_volume')
temp_vhd_path = os.path.join(CONF.image_conversion_dir,
str(image_meta['id']) + ".vhd")
image_utils.upload_volume(None, None, image_meta, temp_vhd_path, 'vpc')
self.mox.StubOutWithMock(windows_utils.WindowsUtils,
'copy_vhd_disk')
windows_utils.WindowsUtils.copy_vhd_disk(self.fake_local_path(vol),
temp_vhd_path)
self.mox.ReplayAll()
drv.copy_volume_to_image(None, vol, None, image_meta)
def _copy_volume_to_image(self, context, volume, image_service,
image_meta):
"""Copy the volume to the specified image."""
# If snapshots exist, flatten to a temporary image, and upload it
active_file = self.get_active_image_from_info(volume)
active_file_path = os.path.join(self._local_volume_dir(volume),
active_file)
info = self._qemu_img_info(active_file_path)
backing_file = info.backing_file
root_file_fmt = info.file_format
tmp_params = {
'prefix': '%s.temp_image.%s' % (volume['id'], image_meta['id']),
'suffix': '.img'
}
with image_utils.temporary_file(**tmp_params) as temp_path:
if backing_file or (root_file_fmt != 'raw'):
# Convert due to snapshots
# or volume data not being stored in raw format
# (upload_volume assumes raw format input)
image_utils.convert_image(active_file_path, temp_path, 'raw')
upload_path = temp_path
else:
upload_path = active_file_path
image_utils.upload_volume(context, image_service, image_meta,
upload_path)
def test_upload_volume_with_bps_limit(self, mock_stat):
bps_limit = 1048576
image_meta = {"id": 1, "disk_format": "qcow2"}
TEST_RET = (
"image: qemu.qcow2\n"
"file_format: qcow2 \n"
"virtual_size: 50M (52428800 bytes)\n"
"cluster_size: 65536\n"
"disk_size: 196K (200704 bytes)"
)
self.override_config("volume_copy_bps_limit", bps_limit)
prefix = ("cgexec", "-g", "blkio:test")
cmd = prefix + ("qemu-img", "convert", "-O", "qcow2", mox.IgnoreArg(), mox.IgnoreArg())
m = self._mox
m.StubOutWithMock(utils, "execute")
m.StubOutWithMock(volume_utils, "setup_blkio_cgroup")
m.StubOutWithMock(volume_utils, "check_for_odirect_support")
volume_utils.setup_blkio_cgroup(mox.IgnoreArg(), mox.IgnoreArg(), bps_limit).AndReturn(prefix)
utils.execute(*cmd, run_as_root=True)
utils.execute("env", "LC_ALL=C", "qemu-img", "info", mox.IgnoreArg(), run_as_root=True).AndReturn(
(TEST_RET, "ignored")
)
m.ReplayAll()
image_utils.upload_volume(context, FakeImageService(), image_meta, "/dev/loop1")
m.VerifyAll()
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
with temp_lvm_device(self, volume):
image_utils.upload_volume(context,
image_service,
image_meta,
self._mapper_path(volume))
def upload_volume(context,
image_service,
image_meta,
volume_path,
volume,
volume_format='raw',
run_as_root=True,
compress=True):
# retrieve store information from extra-specs
store_id = volume.volume_type.extra_specs.get('image_service:store_id')
# This fetches the image_id from volume glance metadata and pass
# it to the driver calling it during upload volume to image operation
base_image_ref = None
if volume.glance_metadata:
base_image_ref = volume.glance_metadata.get('image_id')
image_utils.upload_volume(context,
image_service,
image_meta,
volume_path,
volume_format=volume_format,
run_as_root=run_as_root,
compress=compress,
store_id=store_id,
base_image_ref=base_image_ref)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# If snapshots exist, flatten to a temporary image, and upload it
active_file = self.get_active_image_from_info(volume)
active_file_path = os.path.join(self._local_volume_dir(volume),
active_file)
backing_file = self._vhdutils.get_vhd_parent_path(active_file_path)
root_file_fmt = self.get_volume_format(volume)
temp_path = None
try:
if backing_file:
temp_file_name = '%s.temp_image.%s.%s' % (
volume.id, image_meta['id'], root_file_fmt)
temp_path = os.path.join(self._local_volume_dir(volume),
temp_file_name)
self._vhdutils.convert_vhd(active_file_path, temp_path)
upload_path = temp_path
else:
upload_path = active_file_path
image_utils.upload_volume(context, image_service, image_meta,
upload_path, root_file_fmt)
finally:
if temp_path:
self._delete(temp_path)
def test_upload_volume(self, bps_limit=0):
image_meta = {'id': 1, 'disk_format': 'qcow2'}
TEST_RET = "image: qemu.qcow2\n"\
"file_format: qcow2 \n"\
"virtual_size: 50M (52428800 bytes)\n"\
"cluster_size: 65536\n"\
"disk_size: 196K (200704 bytes)"
if bps_limit:
CONF.set_override('volume_copy_bps_limit', bps_limit)
prefix = ('cgexec', '-g', 'blkio:test')
postfix = ('-t', 'none')
else:
prefix = postfix = ()
cmd = prefix + ('qemu-img', 'convert', '-O', 'qcow2',
mox.IgnoreArg(), mox.IgnoreArg()) + postfix
m = self._mox
m.StubOutWithMock(utils, 'execute')
m.StubOutWithMock(volume_utils, 'setup_blkio_cgroup')
volume_utils.setup_blkio_cgroup(mox.IgnoreArg(), mox.IgnoreArg(),
bps_limit).AndReturn(prefix)
utils.execute(*cmd, run_as_root=True)
utils.execute(
'env', 'LC_ALL=C', 'qemu-img', 'info',
mox.IgnoreArg(), run_as_root=True).AndReturn(
(TEST_RET, 'ignored')
)
m.ReplayAll()
image_utils.upload_volume(context, FakeImageService(),
image_meta, '/dev/loop1')
m.VerifyAll()
def test_copy_volume_to_image(self):
mox = self._mox
drv = self._driver
vol = db_fakes.get_fake_volume_info()
image_meta = db_fakes.get_fake_image_meta()
self.stubs.Set(drv, 'local_path', self.fake_local_path)
mox.StubOutWithMock(image_utils, 'upload_volume')
temp_vhd_path = os.path.join(CONF.image_conversion_dir,
str(image_meta['id']) + ".vhd")
image_utils.upload_volume(None, None, image_meta, temp_vhd_path, 'vpc')
self._mox.StubOutWithMock(windows_utils.WindowsUtils,
'copy_vhd_disk')
windows_utils.WindowsUtils.copy_vhd_disk(self.fake_local_path(vol),
temp_vhd_path)
mox.ReplayAll()
drv.copy_volume_to_image(None, vol, None, image_meta)
mox.VerifyAll()
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.error('begin time of COPY_VOLUME_TO_IMAGE is %s' %
(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
container_format = image_meta.get('container_format')
file_name = image_meta.get('id')
full_url = None
if container_format in ['fs_vgw_url', 'vcloud_vgw_url', 'aws_vgw_url']:
LOG.debug('get the vgw url')
vgw_url = CONF.vgw.vgw_url.get(container_format)
if vgw_url:
full_url = vgw_url + '/' + file_name
image_utils.upload_volume_to_vgw(context,
image_service, image_meta,
self.local_path(volume), volume,
full_url)
#create a empty file to glance
with image_utils.temporary_file() as tmp:
image_utils.upload_volume(context, image_service, image_meta,
tmp)
fileutils.delete_if_exists(tmp)
LOG.error('end time of COPY_VOLUME_TO_IMAGE is %s' %
(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
else:
image_utils.upload_volume(context, image_service, image_meta,
self.local_path(volume))
def copy_volume_to_image(self, context, volume, image_service, image_meta):
if not os.path.exists(
self.configuration.provider_image_conversion_dir):
fileutils.ensure_tree(
self.configuration.provider_image_conversion_dir)
provider_volume_id = self._get_provider_volumeid_from_volume(volume)
task_ret = self.adpter.export_volume(
provider_volume_id,
self.configuration.provider_image_conversion_dir,
str(image_meta['id']),
cgw_host_id=self.configuration.cgw_host_id,
cgw_host_ip=self.configuration.cgw_host_ip,
cgw_username=self.configuration.cgw_username,
cgw_certificate=self.configuration.cgw_certificate,
transfer_station=self.configuration.storage_tmp_dir)
if not task_ret:
raise exception_ex.ProviderExportVolumeError
temp_path = os.path.join(
self.configuration.provider_image_conversion_dir,
str(image_meta['id']))
upload_image = temp_path
try:
image_utils.upload_volume(context, image_service, image_meta,
upload_image)
finally:
fileutils.delete_if_exists(upload_image)
def test_upload_volume_with_bps_limit(self, mock_stat):
bps_limit = 1048576
image_meta = {'id': 1, 'disk_format': 'qcow2'}
TEST_RET = "image: qemu.qcow2\n"\
"file_format: qcow2 \n"\
"virtual_size: 50M (52428800 bytes)\n"\
"cluster_size: 65536\n"\
"disk_size: 196K (200704 bytes)"
self.override_config('volume_copy_bps_limit', bps_limit)
prefix = ('cgexec', '-g', 'blkio:test')
cmd = prefix + ('qemu-img', 'convert', '-O', 'qcow2', mox.IgnoreArg(),
mox.IgnoreArg())
m = self._mox
m.StubOutWithMock(utils, 'execute')
m.StubOutWithMock(volume_utils, 'setup_blkio_cgroup')
m.StubOutWithMock(volume_utils, 'check_for_odirect_support')
volume_utils.setup_blkio_cgroup(mox.IgnoreArg(), mox.IgnoreArg(),
bps_limit).AndReturn(prefix)
utils.execute(*cmd, run_as_root=True)
utils.execute('env',
'LC_ALL=C',
'qemu-img',
'info',
mox.IgnoreArg(),
run_as_root=True).AndReturn((TEST_RET, 'ignored'))
m.ReplayAll()
image_utils.upload_volume(context, FakeImageService(), image_meta,
'/dev/loop1')
m.VerifyAll()
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# If snapshots exist, flatten to a temporary image, and upload it
active_file = self.get_active_image_from_info(volume)
active_file_path = os.path.join(self._local_volume_dir(volume),
active_file)
backing_file = self._vhdutils.get_vhd_parent_path(active_file_path)
root_file_fmt = self.get_volume_format(volume)
temp_path = None
try:
if backing_file:
temp_file_name = '%s.temp_image.%s.%s' % (
volume.id,
image_meta['id'],
root_file_fmt)
temp_path = os.path.join(self._local_volume_dir(volume),
temp_file_name)
self._vhdutils.convert_vhd(active_file_path, temp_path)
upload_path = temp_path
else:
upload_path = active_file_path
image_utils.upload_volume(context,
image_service,
image_meta,
upload_path,
root_file_fmt)
finally:
if temp_path:
self._delete(temp_path)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
with temp_lvm_device(self, volume):
image_utils.upload_volume(context,
image_service,
image_meta,
self._mapper_path(volume))
def test_upload_volume(self):
image_meta = {'id': 1, 'disk_format': 'qcow2'}
TEST_RET = "image: qemu.qcow2\n"\
"file_format: qcow2 \n"\
"virtual_size: 50M (52428800 bytes)\n"\
"cluster_size: 65536\n"\
"disk_size: 196K (200704 bytes)"
m = self._mox
m.StubOutWithMock(utils, 'execute')
utils.execute('qemu-img',
'convert',
'-O',
'qcow2',
mox.IgnoreArg(),
mox.IgnoreArg(),
run_as_root=True)
utils.execute('env',
'LC_ALL=C',
'LANG=C',
'qemu-img',
'info',
mox.IgnoreArg(),
run_as_root=True).AndReturn((TEST_RET, 'ignored'))
m.ReplayAll()
image_utils.upload_volume(context, FakeImageService(), image_meta,
'/dev/loop1')
m.VerifyAll()
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
volume['provider_location'] = (
self.create_export(context, volume, None)['provider_location'])
connection_data = self.initialize_connection(volume, None)['data']
target_connector = (
connector.InitiatorConnector.factory(initiator.NVME,
utils.get_root_helper()))
try:
device_info = target_connector.connect_volume(connection_data)
except Exception:
LOG.info('Could not connect SPDK target device')
return
connection_data['device_path'] = device_info['path']
try:
image_utils.upload_volume(context,
image_service,
image_meta,
device_info['path'])
finally:
target_connector.disconnect_volume(connection_data, volume)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# If snapshots exist, flatten to a temporary image, and upload it
active_file = self.get_active_image_from_info(volume)
active_file_path = "%s/%s" % (self._local_volume_dir(volume), active_file)
backing_file = self._get_backing_file_for_path(active_file_path)
if backing_file is not None:
snapshots_exist = True
else:
snapshots_exist = False
root_file_fmt = self._get_file_format_for_path(self._local_path_volume(volume))
temp_path = None
try:
if snapshots_exist or (root_file_fmt != "raw"):
# Convert due to snapshots
# or volume data not being stored in raw format
# (upload_volume assumes raw format input)
temp_path = "%s/%s.temp_image.%s" % (self._local_volume_dir(volume), volume["id"], image_meta["id"])
image_utils.convert_image(active_file_path, temp_path, "raw")
upload_path = temp_path
else:
upload_path = active_file_path
image_utils.upload_volume(context, image_service, image_meta, upload_path)
finally:
if temp_path is not None:
self._execute("rm", "-f", temp_path)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# retrieve store information from extra-specs
store_id = volume.volume_type.extra_specs.get('image_service:store_id')
volume['provider_location'] = (self.create_export(
context, volume, None)['provider_location'])
connection_data = self.initialize_connection(volume, None)['data']
target_connector = (connector.InitiatorConnector.factory(
initiator.NVME, utils.get_root_helper()))
try:
device_info = target_connector.connect_volume(connection_data)
except Exception:
LOG.info('Could not connect SPDK target device')
return
connection_data['device_path'] = device_info['path']
try:
image_utils.upload_volume(context,
image_service,
image_meta,
device_info['path'],
store_id=store_id)
finally:
target_connector.disconnect_volume(connection_data, volume)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# If snapshots exist, flatten to a temporary image, and upload it
active_file = self.get_active_image_from_info(volume)
active_file_path = '%s/%s' % (self._local_volume_dir(volume),
active_file)
info = self._qemu_img_info(active_file_path)
backing_file = info.backing_file
if backing_file:
snapshots_exist = True
else:
snapshots_exist = False
root_file_fmt = info.file_format
tmp_params = {
'prefix': '%s.temp_image.%s' % (volume['id'], image_meta['id']),
'suffix': '.img'
}
with image_utils.temporary_file(**tmp_params) as temp_path:
if snapshots_exist or (root_file_fmt != 'raw'):
# Convert due to snapshots
# or volume data not being stored in raw format
# (upload_volume assumes raw format input)
image_utils.convert_image(active_file_path, temp_path, 'raw')
upload_path = temp_path
else:
upload_path = active_file_path
image_utils.upload_volume(context,
image_service,
image_meta,
upload_path)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.error('begin time of COPY_VOLUME_TO_IMAGE is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
container_format=image_meta.get('container_format')
file_name=image_meta.get('id')
full_url=None
if container_format in ['fs_vgw_url','vcloud_vgw_url','aws_vgw_url']:
LOG.debug('get the vgw url')
vgw_url = CONF.vgw.vgw_url.get(container_format)
if vgw_url:
full_url=vgw_url+'/'+file_name
image_utils.upload_volume_to_vgw(context, image_service, image_meta, self.local_path(volume), volume, full_url)
#create a empty file to glance
with image_utils.temporary_file() as tmp:
image_utils.upload_volume(context,
image_service,
image_meta,
tmp)
fileutils.delete_if_exists(tmp)
LOG.error('end time of COPY_VOLUME_TO_IMAGE is %s' %(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())))
else:
image_utils.upload_volume(context,
image_service,
image_meta,
self.local_path(volume))
def _unused():
# todo(wangfeng)
# pdb.set_trace()
# 1. get the vmdk file.
volume_id = volume['id']
if volume['attach_status'] == 'attached':
# nova_client = nova.novaclient(context)
# node_name = nova_client.servers.get(instance_id)._
# info['OS-EXT-SRV-ATTR:hypervisor_hostname']
the_vapp = self._get_vcloud_vapp(volume['instance_uuid'])
vmdk_url = self._query_vmdk_url(the_vapp)
local_file_name = '%s/%s.vmdk' % (
CONF.vcloud.vcloud_conversion_dir, volume_id)
self._download_vmdk_from_vcloud(context, vmdk_url,
local_file_name)
# volume_id = volume['id']
# create_info = {'snapshot_id':volume['snapshot_id'],
# 'type':'qcow2',
# 'new_file':'snapshot_file'}
# self._nova_api.create_volume_snapshot(context,volume_id,create_info)
# local_file_name = '%s/%s.vmdk' % (CONVERT_DIR, volume_id)
else:
local_file_name = '%s/%s.vmdk' % (
CONF.vcloud.vcloud_volumes_dir, volume_id)
if not os.path.exists(local_file_name):
LOG.error('volume file %s do not exist' %
local_file_name)
return
# 1. the file is vmdk, convert it to qcow2
# converted_file_name = '%s/converted-file.qcow2' %
# CONF.vcloud.vcloud_conversion_dir
# convert_commond = "qemu-img convert -f %s -O %s %s %s" % \
# ('vmdk',
# 'qcow2',
# local_file_name,
# converted_file_name)
# convert_result = subprocess.call([convert_commond],shell=True)
# if convert_result != 0:
# do something, change metadata
# LOG.error('converting file failed')
# 2. upload to glance
# file_size = os.path.getsize(converted_file_name)
# The properties and other fields that we need to set for the image.
# image_meta['disk_format'] = 'qcow2'
# image_meta['status'] = 'active'
# image_meta['size'] = file_size
# image_meta['properties'] = {'owner_id': volume['project_id']}
# image_utils.upload_volume(context,image_service,image_meta,converted_file_name,'qcow2')
image_utils.upload_volume(context, image_service, image_meta,
local_file_name, 'vmdk')
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# Copy the volume to the image conversion dir
temp_vhd_path = os.path.join(self.configuration.image_conversion_dir,
str(image_meta['id']) + ".vhd")
self.utils.copy_vhd_disk(self.local_path(volume), temp_vhd_path)
image_utils.upload_volume(context, image_service, image_meta,
temp_vhd_path, 'vpc')
def _use_image_utils_to_upload_volume(self, context, volume, image_service,
image_meta):
sr_uuid, vdi_uuid = volume['provider_location'].split('/')
with self.nfs_ops.volume_attached_here(FLAGS.xenapi_nfs_server,
FLAGS.xenapi_nfs_serverpath,
sr_uuid, vdi_uuid,
True) as device:
image_utils.upload_volume(context, image_service, image_meta,
device)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy a volume to a new image."""
LOG.debug("Enter in copy image to volume for disco.")
try:
device_info = self._attach_volume(volume)
image_utils.upload_volume(context, image_service, image_meta,
device_info['path'])
finally:
self._detach_volume(volume)
def test_copy_volume_to_image(self):
"""Expected behaviour for copy_volume_to_image."""
self.mox.StubOutWithMock(image_utils, "upload_volume")
image_utils.upload_volume(context, self.TEST_IMAGE_SERVICE, self.TEST_IMAGE_META, self.TEST_VOLPATH)
self.mox.ReplayAll()
self._driver.copy_volume_to_image(context, self.TEST_VOLUME, self.TEST_IMAGE_SERVICE, self.TEST_IMAGE_META)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# Copy the volume to the image conversion dir
temp_vhd_path = os.path.join(self.configuration.image_conversion_dir,
str(image_meta['id']) + ".vhd")
self.utils.copy_vhd_disk(self.local_path(volume), temp_vhd_path)
image_utils.upload_volume(context, image_service, image_meta,
temp_vhd_path, 'vpc')
def copy_volume_to_image(self, context, volume, image_service, image_meta):
tmp_dir = self._image_conversion_dir()
tmp_file = os.path.join(tmp_dir, volume["name"] + "-" + image_meta["id"])
with fileutils.remove_path_on_error(tmp_file):
args = ["rbd", "export", "--pool", self.configuration.rbd_pool, volume["name"], tmp_file]
args.extend(self._ceph_args())
self._try_execute(*args)
image_utils.upload_volume(context, image_service, image_meta, tmp_file)
os.unlink(tmp_file)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
# retrieve store information from extra-specs
store_id = volume.volume_type.extra_specs.get('image_service:store_id')
image_utils.upload_volume(context,
image_service,
image_meta,
self.local_path(volume),
store_id=store_id)
def test_copy_volume_to_image(self):
fake_image_service = "fake-image-service"
fake_image_meta = "fake-image-meta"
self.mox.StubOutWithMock(image_utils, "upload_volume")
image_utils.upload_volume({}, fake_image_service, fake_image_meta, self.fake_dev_path)
self.mox.ReplayAll()
self.driver.copy_volume_to_image({}, fake_volume, fake_image_service, fake_image_meta)
self.mox.VerifyAll()
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(_("copy_volume_to_image %s.") % volume["name"])
connector = {"initiator": self._get_iscsi_initiator(), "host": socket.gethostname()}
iscsi_properties, volume_path = self._attach_volume(context, volume, connector)
try:
image_utils.upload_volume(context, image_service, image_meta, volume_path)
finally:
self.terminate_connection(volume, connector)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(("copy_volume_to_image %s.") % volume["name"])
properties = utils.brick_get_connector_properties()
attach_info = self._attach_volume(context, volume, properties)
try:
image_utils.upload_volume(context, image_service, image_meta, attach_info["device"]["path"])
finally:
self._detach_volume(context, attach_info, volume, properties)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy a volume to a new image."""
LOG.debug("Enter in copy image to volume for disco.")
try:
device_info = self._attach_volume(volume)
image_utils.upload_volume(context,
image_service,
image_meta,
device_info['path'])
finally:
self._detach_volume(volume)
def _use_image_utils_to_upload_volume(self, context, volume, image_service,
image_meta):
sr_uuid, vdi_uuid = volume['provider_location'].split('/')
with self.nfs_ops.volume_attached_here(CONF.xenapi_nfs_server,
CONF.xenapi_nfs_serverpath,
sr_uuid, vdi_uuid,
True) as device:
image_utils.upload_volume(context,
image_service,
image_meta,
device)
def test_upload_volume_with_raw_image(self):
image_meta = {"id": 1, "disk_format": "raw"}
mox = self._mox
mox.StubOutWithMock(image_utils, "convert_image")
mox.ReplayAll()
with tempfile.NamedTemporaryFile() as f:
image_utils.upload_volume(context, FakeImageService(), image_meta, f.name)
mox.VerifyAll()
def _unused():
# todo(wangfeng)
# pdb.set_trace()
# 1. get the vmdk file.
volume_id = volume['id']
if volume['attach_status']=='attached':
# nova_client = nova.novaclient(context)
# node_name = nova_client.servers.get(instance_id)._
# info['OS-EXT-SRV-ATTR:hypervisor_hostname']
the_vapp = self._get_vcloud_vapp(volume['instance_uuid'])
vmdk_url = self._query_vmdk_url(the_vapp)
local_file_name = '%s/%s.vmdk' % (CONF.vcloud.vcloud_conversion_dir, volume_id)
self._download_vmdk_from_vcloud(context, vmdk_url,local_file_name)
# volume_id = volume['id']
# create_info = {'snapshot_id':volume['snapshot_id'],
# 'type':'qcow2',
# 'new_file':'snapshot_file'}
# self._nova_api.create_volume_snapshot(context,volume_id,create_info)
# local_file_name = '%s/%s.vmdk' % (CONVERT_DIR, volume_id)
else:
local_file_name = '%s/%s.vmdk' % (CONF.vcloud.vcloud_volumes_dir, volume_id)
if not os.path.exists(local_file_name):
LOG.error('volume file %s do not exist' % local_file_name)
return
# 1. the file is vmdk, convert it to qcow2
# converted_file_name = '%s/converted-file.qcow2' %
# CONF.vcloud.vcloud_conversion_dir
# convert_commond = "qemu-img convert -f %s -O %s %s %s" % \
# ('vmdk',
# 'qcow2',
# local_file_name,
# converted_file_name)
# convert_result = subprocess.call([convert_commond],shell=True)
# if convert_result != 0:
# do something, change metadata
# LOG.error('converting file failed')
# 2. upload to glance
# file_size = os.path.getsize(converted_file_name)
# The properties and other fields that we need to set for the image.
# image_meta['disk_format'] = 'qcow2'
# image_meta['status'] = 'active'
# image_meta['size'] = file_size
# image_meta['properties'] = {'owner_id': volume['project_id']}
# image_utils.upload_volume(context,image_service,image_meta,converted_file_name,'qcow2')
image_utils.upload_volume(context,image_service,image_meta,local_file_name,'vmdk')
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
(properties, attach_info) = self._attach_volume_syc(context, volume)
try:
image_utils.upload_volume(context, image_service, image_meta,
attach_info['device']['path'])
finally:
self._detach_and_terminate_syc(context, attach_info, volume,
properties)
def test_copy_volume_to_image(self):
TEST_VOLUME = {'provider_location': '1 2 3 /dev/loop1'}
TEST_IMAGE_SERVICE = "image_service"
TEST_IMAGE_META = "image_meta"
self.mox.StubOutWithMock(image_utils, 'upload_volume')
self.mox.StubOutWithMock(self.drv, 'local_path')
self.drv.local_path(TEST_VOLUME).AndReturn('/dev/loop1')
image_utils.upload_volume(context, TEST_IMAGE_SERVICE, TEST_IMAGE_META,
'/dev/loop1')
self.mox.ReplayAll()
self.drv.copy_volume_to_image(context, TEST_VOLUME, TEST_IMAGE_SERVICE,
TEST_IMAGE_META)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy a volume to a new image."""
LOG.debug("Enter in copy image to volume for disco.")
try:
attach_detach_volume = (
disco_attach_detach.AttachDetachDiscoVolume(
self.configuration))
device_info = attach_detach_volume._attach_volume(volume)
image_utils.upload_volume(context, image_service, image_meta,
device_info['path'])
finally:
attach_detach_volume._detach_volume(volume)
def test_copy_volume_to_image(self):
TEST_VOLUME = {'provider_location': '1 2 3 /dev/loop1'}
TEST_IMAGE_SERVICE = "image_service"
TEST_IMAGE_META = "image_meta"
self.mox.StubOutWithMock(image_utils, 'upload_volume')
self.mox.StubOutWithMock(self.drv, 'local_path')
self.drv.local_path(TEST_VOLUME).AndReturn('/dev/loop1')
image_utils.upload_volume(context, TEST_IMAGE_SERVICE,
TEST_IMAGE_META, '/dev/loop1')
self.mox.ReplayAll()
self.drv.copy_volume_to_image(context, TEST_VOLUME, TEST_IMAGE_SERVICE,
TEST_IMAGE_META)
def test_copy_volume_to_image(self):
"""Expected behaviour for copy_volume_to_image."""
self.mox.StubOutWithMock(image_utils, 'upload_volume')
image_utils.upload_volume(context, self.TEST_IMAGE_SERVICE,
self.TEST_IMAGE_META, self.TEST_VOLPATH)
self.mox.ReplayAll()
self._driver.copy_volume_to_image(context, self.TEST_VOLUME,
self.TEST_IMAGE_SERVICE,
self.TEST_IMAGE_META)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
properties = utils.brick_get_connector_properties()
attach_info = self._attach_volume(context, volume, properties)
try:
image_utils.upload_volume(context, image_service, image_meta,
attach_info['device']['path'])
finally:
self._detach_volume(context, attach_info, volume, properties)
def test_upload_volume_with_raw_image(self):
image_meta = {'id': 1, 'disk_format': 'raw'}
mox = self._mox
mox.StubOutWithMock(image_utils, 'convert_image')
mox.ReplayAll()
with tempfile.NamedTemporaryFile() as f:
image_utils.upload_volume(context, FakeImageService(), image_meta,
f.name)
mox.VerifyAll()
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.info("ScaleIO copy_volume_to_image volume: "+str(volume) + " image service: " + str(image_service) + " image meta: " + str(image_meta))
properties = utils.brick_get_connector_properties()
sdc_ip = properties['ip']
LOG.debug("SDC ip is: {0}".format(sdc_ip))
try:
image_utils.upload_volume(context,
image_service,
image_meta,
self._attach_volume (volume, sdc_ip))
finally:
self._detach_volume(volume, sdc_ip)
def test_copy_volume_to_image(self):
fake_image_service = 'fake-image-service'
fake_image_meta = 'fake-image-meta'
self.mox.StubOutWithMock(image_utils, 'upload_volume')
image_utils.upload_volume({}, fake_image_service, fake_image_meta,
self.fake_dev_path)
self.mox.ReplayAll()
self.driver.copy_volume_to_image({}, fake_volume, fake_image_service,
fake_image_meta)
self.mox.VerifyAll()
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
(properties,attach_info) = self._attach_volume_syc(context, volume)
try:
image_utils.upload_volume(context,
image_service,
image_meta,
attach_info['device']['path'])
finally:
self._detach_and_terminate_syc(context,attach_info,volume,properties)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
tmp_dir = self._image_conversion_dir()
tmp_file = os.path.join(tmp_dir,
volume['name'] + '-' + image_meta['id'])
with fileutils.remove_path_on_error(tmp_file):
args = ['rbd', 'export',
'--pool', self.configuration.rbd_pool,
volume['name'], tmp_file]
args.extend(self._ceph_args())
self._try_execute(*args)
image_utils.upload_volume(context, image_service,
image_meta, tmp_file)
os.unlink(tmp_file)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.info("ScaleIO copy_volume_to_image volume: " + str(volume) +
" image service: " + str(image_service) + " image meta: " +
str(image_meta))
properties = utils.brick_get_connector_properties()
sdc_ip = properties['ip']
LOG.debug("SDC ip is: {0}".format(sdc_ip))
try:
image_utils.upload_volume(context, image_service, image_meta,
self._attach_volume(volume, sdc_ip))
finally:
self._detach_volume(volume, sdc_ip)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
tmp_dir = self._image_conversion_dir()
tmp_file = os.path.join(tmp_dir, volume.name + '-' + image_meta['id'])
with fileutils.remove_path_on_error(tmp_file):
args = [
'rbd', 'export', '--pool', self.configuration.rbd_pool,
volume.name, tmp_file
]
args.extend(self._ceph_args())
self._try_execute(*args)
image_utils.upload_volume(context, image_service, image_meta,
tmp_file)
os.unlink(tmp_file)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
self._ensure_tmp_exists()
tmp_dir = self.configuration.volume_tmp_dir or '/tmp'
tmp_file = os.path.join(tmp_dir,
volume['name'] + '-' + image_meta['id'])
with utils.remove_path_on_error(tmp_file):
self._try_execute('rbd', 'export',
'--pool', self.configuration.rbd_pool,
volume['name'], tmp_file)
image_utils.upload_volume(context, image_service,
image_meta, tmp_file)
os.unlink(tmp_file)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.info(
_LI("ScaleIO copy_volume_to_image volume: %(vol)s image service: "
"%(service)s image meta: %(meta)s."), {
'vol': volume,
'service': six.text_type(image_service),
'meta': six.text_type(image_meta)
})
try:
image_utils.upload_volume(context, image_service, image_meta,
self._sio_attach_volume(volume))
finally:
self._sio_detach_volume(volume)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy a volume to a new image."""
LOG.debug("Enter in copy image to volume for disco.")
try:
attach_detach_volume = (
disco_attach_detach.AttachDetachDiscoVolume(
self.configuration))
device_info = attach_detach_volume._attach_volume(volume)
image_utils.upload_volume(context,
image_service,
image_meta,
device_info['path'])
finally:
attach_detach_volume._detach_volume(volume)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
properties = utils.brick_get_connector_properties()
attach_info = self._attach_volume(context, volume, properties)
try:
image_utils.upload_volume(context,
image_service,
image_meta,
attach_info['device']['path'])
finally:
self._detach_volume(attach_info)
self.terminate_connection(volume, properties)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.info(_LI(
"ScaleIO copy_volume_to_image volume: %(vol)s image service: "
"%(service)s image meta: %(meta)s."),
{'vol': volume,
'service': six.text_type(image_service),
'meta': six.text_type(image_meta)})
try:
image_utils.upload_volume(context,
image_service,
image_meta,
self._sio_attach_volume(volume))
finally:
self._sio_detach_volume(volume)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
disk_format = self._tgt_utils.get_supported_disk_format()
temp_vhd_path = os.path.join(CONF.image_conversion_dir,
str(image_meta['id']) + '.' + disk_format)
try:
with self._temporary_snapshot(volume['name']) as tmp_snap_name:
# qemu-img cannot access VSS snapshots, for which reason it
# must be exported first.
self._tgt_utils.export_snapshot(tmp_snap_name, temp_vhd_path)
image_utils.upload_volume(context, image_service, image_meta,
temp_vhd_path, 'vhd')
finally:
fileutils.delete_if_exists(temp_vhd_path)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
disk_format = self._tgt_utils.get_supported_disk_format()
temp_vhd_path = os.path.join(CONF.image_conversion_dir,
str(image_meta['id']) + '.' + disk_format)
try:
with self._temporary_snapshot(volume.name) as tmp_snap_name:
# qemu-img cannot access VSS snapshots, for which reason it
# must be exported first.
self._tgt_utils.export_snapshot(tmp_snap_name, temp_vhd_path)
image_utils.upload_volume(context, image_service, image_meta,
temp_vhd_path, 'vhd')
finally:
fileutils.delete_if_exists(temp_vhd_path)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
connector = {'initiator': self._get_iscsi_initiator(),
'host': socket.gethostname()}
iscsi_properties, volume_path = self._attach_volume(
context, volume, connector)
try:
image_utils.upload_volume(context,
image_service,
image_meta,
volume_path)
finally:
self.terminate_connection(volume, connector)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.debug(_('copy_volume_to_image %s.') % volume['name'])
initiator = self._get_iscsi_initiator()
connector = {}
connector['initiator'] = initiator
iscsi_properties, volume_path = self._attach_volume(
context, volume, connector)
try:
image_utils.upload_volume(context,
image_service,
image_meta,
volume_path)
finally:
self.terminate_connection(volume, connector)
def _copy_volume_to_image(self, context, volume, image_service,
image_meta):
"""Copy the volume to the specified image."""
volume_format = self.get_volume_format(volume)
if volume_format == DISK_FORMAT_PLOOP:
with PloopDevice(self.local_path(volume),
execute=self._execute) as dev:
image_utils.upload_volume(context,
image_service,
image_meta,
dev,
volume_format='raw')
else:
super(VZStorageDriver,
self)._copy_volume_to_image(context, volume, image_service,
image_meta)
def copy_volume_to_image(self, context, volume, image_service, image_meta):
"""Copy the volume to the specified image."""
LOG.info(
_LI("ScaleIO copy_volume_to_image volume: %(vol)s image service: "
"%(service)s image meta: %(meta)s."), {
'vol': volume,
'service': six.text_type(image_service),
'meta': six.text_type(image_meta)
})
properties = utils.brick_get_connector_properties()
sdc_ip = properties['ip']
LOG.debug("SDC ip is: {0}".format(sdc_ip))
try:
image_utils.upload_volume(context, image_service, image_meta,
self._sio_attach_volume(volume, sdc_ip))
finally:
self._sio_detach_volume(volume, sdc_ip)
def _copy_volume_to_image(self, context, volume, image_service,
image_meta):
"""Copy the volume to the specified image."""
volume_format = self.get_volume_format(volume)
if volume_format == DISK_FORMAT_PLOOP:
with PloopDevice(self.local_path(volume),
execute=self._execute) as dev:
image_utils.upload_volume(context,
image_service,
image_meta,
dev,
volume_format='raw')
else:
super(VZStorageDriver, self)._copy_volume_to_image(context, volume,
image_service,
image_meta)
