581 lines
22 KiB
Python
581 lines
22 KiB
Python
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright 2013 IBM Corp.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import hashlib
|
|
import os
|
|
import re
|
|
|
|
from oslo.config import cfg
|
|
|
|
from nova.compute import flavors
|
|
from nova.compute import task_states
|
|
from nova.image import glance
|
|
from nova.openstack.common import excutils
|
|
from nova.openstack.common import log as logging
|
|
from nova.openstack.common import processutils
|
|
from nova.virt import images
|
|
from nova.virt.powervm import command
|
|
from nova.virt.powervm import common
|
|
from nova.virt.powervm import constants
|
|
from nova.virt.powervm import exception
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
CONF = cfg.CONF
|
|
|
|
|
|
class PowerVMDiskAdapter(object):
|
|
"""PowerVM disk adapter interface
|
|
Provides a contract to implement multiple ways to generate
|
|
and attach volumes to virtual machines using local and/or
|
|
external storage
|
|
"""
|
|
|
|
def create_volume(self, size):
|
|
"""Creates a volume with a minimum size
|
|
|
|
:param size: size of the volume in bytes
|
|
:returns: string -- the name of the disk device.
|
|
"""
|
|
pass
|
|
|
|
def delete_volume(self, volume_info):
|
|
"""Removes the disk and its associated vSCSI connection
|
|
|
|
:param volume_info: dictionary with volume info including name of
|
|
disk device in /dev/
|
|
"""
|
|
pass
|
|
|
|
def create_volume_from_image(self, context, instance, image_id):
|
|
"""Creates a Volume and copies the specified image to it
|
|
|
|
:param context: nova context used to retrieve image from glance
|
|
:param instance: instance to create the volume for
|
|
:param image_id: image_id reference used to locate image in glance
|
|
:returns: dictionary with the name of the created
|
|
disk device in 'device_name' key
|
|
"""
|
|
pass
|
|
|
|
def create_image_from_volume(self, device_name, context,
|
|
image_id, image_meta, update_task_state):
|
|
"""Capture the contents of a volume and upload to glance
|
|
|
|
:param device_name: device in /dev/ to capture
|
|
:param context: nova context for operation
|
|
:param image_id: image reference to pre-created image in glance
|
|
:param image_meta: metadata for new image
|
|
:param update_task_state: Function reference that allows for updates
|
|
to the instance task state
|
|
"""
|
|
pass
|
|
|
|
def migrate_volume(self, lv_name, src_host, dest, image_path,
|
|
instance_name=None):
|
|
"""Copy a logical volume to file, compress, and transfer
|
|
|
|
:param lv_name: volume device name
|
|
:param src_host: source IP or DNS name.
|
|
:param dest: destination IP or DNS name
|
|
:param image_path: path to remote image storage directory
|
|
:param instance_name: name of instance that is being migrated
|
|
:returns: file path on destination of image file that was moved
|
|
"""
|
|
pass
|
|
|
|
def attach_volume_to_host(self, *args, **kargs):
|
|
"""
|
|
Attaches volume to host using info passed in *args and **kargs
|
|
"""
|
|
pass
|
|
|
|
def detach_volume_from_host(self, *args, **kargs):
|
|
"""
|
|
Detaches volume from host using info passed in *args and **kargs
|
|
"""
|
|
pass
|
|
|
|
|
|
class PowerVMLocalVolumeAdapter(PowerVMDiskAdapter):
|
|
"""Default block device providor for PowerVM
|
|
|
|
This disk adapter uses logical volumes on the hosting VIOS
|
|
to provide backing block devices for instances/LPARs
|
|
"""
|
|
|
|
def __init__(self, connection):
|
|
super(PowerVMLocalVolumeAdapter, self).__init__()
|
|
|
|
self.command = command.IVMCommand()
|
|
|
|
self._connection = None
|
|
self.connection_data = connection
|
|
|
|
def _set_connection(self):
|
|
# create a new connection or verify an existing connection
|
|
# and re-establish if the existing connection is dead
|
|
self._connection = common.check_connection(self._connection,
|
|
self.connection_data)
|
|
|
|
def create_volume(self, size):
|
|
"""Creates a logical volume with a minimum size
|
|
|
|
:param size: size of the logical volume in bytes
|
|
:returns: string -- the name of the new logical volume.
|
|
:raises: PowerVMNoSpaceLeftOnVolumeGroup
|
|
"""
|
|
return self._create_logical_volume(size)
|
|
|
|
def delete_volume(self, volume_info):
|
|
"""Removes the Logical Volume and its associated vSCSI connection
|
|
|
|
:param volume_info: Dictionary with volume info including name of
|
|
Logical Volume device in /dev/ via device_name key
|
|
"""
|
|
disk_name = volume_info["device_name"]
|
|
LOG.debug(_("Removing the logical volume '%s'") % disk_name)
|
|
self._remove_logical_volume(disk_name)
|
|
|
|
def create_volume_from_image(self, context, instance, image_id):
|
|
"""Creates a Logical Volume and copies the specified image to it
|
|
|
|
:param context: nova context used to retrieve image from glance
|
|
:param instance: instance to create the volume for
|
|
:param image_id: image_id reference used to locate image in glance
|
|
:returns: dictionary with the name of the created
|
|
Logical Volume device in 'device_name' key
|
|
"""
|
|
|
|
file_name = '.'.join([image_id, 'gz'])
|
|
file_path = os.path.join(CONF.powervm_img_local_path,
|
|
file_name)
|
|
|
|
if not os.path.isfile(file_path):
|
|
LOG.debug(_("Fetching image '%s' from glance") % image_id)
|
|
images.fetch(context, image_id, file_path,
|
|
instance['user_id'],
|
|
instance['project_id'])
|
|
else:
|
|
LOG.debug((_("Using image found at '%s'") % file_path))
|
|
|
|
LOG.debug(_("Ensuring image '%s' exists on IVM") % file_path)
|
|
remote_path = CONF.powervm_img_remote_path
|
|
remote_file_name, size = self._copy_image_file(file_path, remote_path)
|
|
|
|
# calculate root device size in bytes
|
|
# we respect the minimum root device size in constants
|
|
instance_type = flavors.extract_flavor(instance)
|
|
size_gb = max(instance_type['root_gb'], constants.POWERVM_MIN_ROOT_GB)
|
|
size = size_gb * 1024 * 1024 * 1024
|
|
|
|
disk_name = None
|
|
try:
|
|
LOG.debug(_("Creating logical volume of size %s bytes") % size)
|
|
disk_name = self._create_logical_volume(size)
|
|
|
|
LOG.debug(_("Copying image to the device '%s'") % disk_name)
|
|
self._copy_file_to_device(remote_file_name, disk_name)
|
|
except Exception:
|
|
LOG.error(_("Error while creating logical volume from image. "
|
|
"Will attempt cleanup."))
|
|
# attempt cleanup of logical volume before re-raising exception
|
|
with excutils.save_and_reraise_exception():
|
|
if disk_name is not None:
|
|
try:
|
|
self.delete_volume(disk_name)
|
|
except Exception:
|
|
msg = _('Error while attempting cleanup of failed '
|
|
'deploy to logical volume.')
|
|
LOG.exception(msg)
|
|
|
|
return {'device_name': disk_name}
|
|
|
|
def create_image_from_volume(self, device_name, context,
|
|
image_id, image_meta, update_task_state):
|
|
"""Capture the contents of a volume and upload to glance
|
|
|
|
:param device_name: device in /dev/ to capture
|
|
:param context: nova context for operation
|
|
:param image_id: image reference to pre-created image in glance
|
|
:param image_meta: metadata for new image
|
|
:param update_task_state: Function reference that allows for updates
|
|
to the instance task state.
|
|
"""
|
|
# Updating instance task state before capturing instance as a file
|
|
update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD)
|
|
|
|
# do the disk copy
|
|
dest_file_path = common.aix_path_join(CONF.powervm_img_remote_path,
|
|
image_id)
|
|
self._copy_device_to_file(device_name, dest_file_path)
|
|
|
|
# compress and copy the file back to the nova-compute host
|
|
snapshot_file_path = self._copy_image_file_from_host(
|
|
dest_file_path, CONF.powervm_img_local_path,
|
|
compress=True)
|
|
|
|
# get glance service
|
|
glance_service, image_id = glance.get_remote_image_service(
|
|
context, image_id)
|
|
|
|
# Updating instance task state before uploading image
|
|
# Snapshot will complete but instance state will not change
|
|
# to none in compute manager if expected state is not correct
|
|
update_task_state(task_state=task_states.IMAGE_UPLOADING,
|
|
expected_state=task_states.IMAGE_PENDING_UPLOAD)
|
|
|
|
# upload snapshot file to glance
|
|
with open(snapshot_file_path, 'r') as img_file:
|
|
glance_service.update(context,
|
|
image_id,
|
|
image_meta,
|
|
img_file)
|
|
LOG.debug(_("Snapshot added to glance."))
|
|
|
|
# clean up local image file
|
|
try:
|
|
os.remove(snapshot_file_path)
|
|
except OSError:
|
|
LOG.warn(_("Failed to clean up snapshot file %s"),
|
|
snapshot_file_path)
|
|
|
|
def migrate_volume(self, lv_name, src_host, dest, image_path,
|
|
instance_name=None):
|
|
"""Copy a logical volume to file, compress, and transfer
|
|
|
|
:param lv_name: logical volume device name
|
|
:param dest: destination IP or DNS name
|
|
:param image_path: path to remote image storage directory
|
|
:param instance_name: name of instance that is being migrated
|
|
:returns: file path on destination of image file that was moved
|
|
"""
|
|
if instance_name:
|
|
file_name = ''.join([instance_name, '_rsz'])
|
|
else:
|
|
file_name = ''.join([lv_name, '_rsz'])
|
|
file_path = os.path.join(image_path, file_name)
|
|
self._copy_device_to_file(lv_name, file_path)
|
|
cmds = 'gzip %s' % file_path
|
|
self.run_vios_command_as_root(cmds)
|
|
file_path = file_path + '.gz'
|
|
# If destination is not same host
|
|
# transfer file to destination VIOS system
|
|
if (src_host != dest):
|
|
with common.vios_to_vios_auth(self.connection_data.host,
|
|
dest,
|
|
self.connection_data) as key_name:
|
|
cmd = ' '.join(['scp -o "StrictHostKeyChecking no"',
|
|
('-i %s' % key_name),
|
|
file_path,
|
|
'%s@%s:%s' % (self.connection_data.username,
|
|
dest,
|
|
image_path)
|
|
])
|
|
# do the remote copy
|
|
self.run_vios_command(cmd)
|
|
|
|
# cleanup local file only if transferring to remote system
|
|
# otherwise keep the file to boot from locally and clean up later
|
|
cleanup_cmd = 'rm %s' % file_path
|
|
self.run_vios_command_as_root(cleanup_cmd)
|
|
|
|
return file_path
|
|
|
|
def attach_volume_to_host(self, *args, **kargs):
|
|
pass
|
|
|
|
def detach_volume_from_host(self, *args, **kargs):
|
|
pass
|
|
|
|
def _create_logical_volume(self, size):
|
|
"""Creates a logical volume with a minimum size.
|
|
|
|
:param size: size of the logical volume in bytes
|
|
:returns: string -- the name of the new logical volume.
|
|
:raises: PowerVMNoSpaceLeftOnVolumeGroup
|
|
"""
|
|
vgs = self.run_vios_command(self.command.lsvg())
|
|
cmd = self.command.lsvg('%s -field vgname freepps -fmt :' %
|
|
' '.join(vgs))
|
|
output = self.run_vios_command(cmd)
|
|
found_vg = None
|
|
|
|
# If it's not a multiple of 1MB we get the next
|
|
# multiple and use it as the megabyte_size.
|
|
megabyte = 1024 * 1024
|
|
if (size % megabyte) != 0:
|
|
megabyte_size = int(size / megabyte) + 1
|
|
else:
|
|
megabyte_size = size / megabyte
|
|
|
|
# Search for a volume group with enough free space for
|
|
# the new logical volume.
|
|
for vg in output:
|
|
# Returned output example: 'rootvg:396 (25344 megabytes)'
|
|
match = re.search(r'^(\w+):\d+\s\((\d+).+$', vg)
|
|
if match is None:
|
|
continue
|
|
vg_name, avail_size = match.groups()
|
|
if megabyte_size <= int(avail_size):
|
|
found_vg = vg_name
|
|
break
|
|
|
|
if not found_vg:
|
|
LOG.error(_('Could not create logical volume. '
|
|
'No space left on any volume group.'))
|
|
raise exception.PowerVMNoSpaceLeftOnVolumeGroup()
|
|
|
|
cmd = self.command.mklv('%s %sB' % (found_vg, size / 512))
|
|
lv_name = self.run_vios_command(cmd)[0]
|
|
return lv_name
|
|
|
|
def _remove_logical_volume(self, lv_name):
|
|
"""Removes the lv and the connection between its associated vscsi.
|
|
|
|
:param lv_name: a logical volume name
|
|
"""
|
|
cmd = self.command.rmvdev('-vdev %s -rmlv' % lv_name)
|
|
self.run_vios_command(cmd)
|
|
|
|
def _copy_file_to_device(self, source_path, device, decompress=True):
|
|
"""Copy file to device.
|
|
|
|
:param source_path: path to input source file
|
|
:param device: output device name
|
|
:param decompress: if True (default) the file will be decompressed
|
|
on the fly while being copied to the drive
|
|
"""
|
|
if decompress:
|
|
cmd = ('gunzip -c %s | dd of=/dev/%s bs=1024k' %
|
|
(source_path, device))
|
|
else:
|
|
cmd = 'dd if=%s of=/dev/%s bs=1024k' % (source_path, device)
|
|
self.run_vios_command_as_root(cmd)
|
|
|
|
def _copy_device_to_file(self, device_name, file_path):
|
|
"""Copy a device to a file using dd
|
|
|
|
:param device_name: device name to copy from
|
|
:param file_path: output file path
|
|
"""
|
|
cmd = 'dd if=/dev/%s of=%s bs=1024k' % (device_name, file_path)
|
|
self.run_vios_command_as_root(cmd)
|
|
|
|
def _md5sum_remote_file(self, remote_path):
|
|
# AIX6/VIOS cannot md5sum files with sizes greater than ~2GB
|
|
cmd = ("perl -MDigest::MD5 -e 'my $file = \"%s\"; open(FILE, $file); "
|
|
"binmode(FILE); "
|
|
"print Digest::MD5->new->addfile(*FILE)->hexdigest, "
|
|
"\" $file\n\";'" % remote_path)
|
|
|
|
output = self.run_vios_command_as_root(cmd)
|
|
return output[0]
|
|
|
|
def _checksum_local_file(self, source_path):
|
|
"""Calculate local file checksum.
|
|
|
|
:param source_path: source file path
|
|
:returns: string -- the md5sum of local file
|
|
"""
|
|
with open(source_path, 'r') as img_file:
|
|
hasher = hashlib.md5()
|
|
block_size = 0x10000
|
|
buf = img_file.read(block_size)
|
|
while len(buf) > 0:
|
|
hasher.update(buf)
|
|
buf = img_file.read(block_size)
|
|
source_cksum = hasher.hexdigest()
|
|
return source_cksum
|
|
|
|
def _copy_image_file(self, source_path, remote_path, decompress=False):
|
|
"""Copy file to VIOS, decompress it, and return its new size and name.
|
|
|
|
:param source_path: source file path
|
|
:param remote_path remote file path
|
|
:param decompress: if True, decompressess the file after copying;
|
|
if False (default), just copies the file
|
|
"""
|
|
# Calculate source image checksum
|
|
source_cksum = self._checksum_local_file(source_path)
|
|
|
|
comp_path = os.path.join(remote_path, os.path.basename(source_path))
|
|
if comp_path.endswith(".gz"):
|
|
uncomp_path = os.path.splitext(comp_path)[0]
|
|
else:
|
|
uncomp_path = comp_path
|
|
if not decompress:
|
|
final_path = comp_path
|
|
else:
|
|
final_path = uncomp_path
|
|
|
|
# Check whether the image is already on IVM
|
|
output = self.run_vios_command("ls %s" % final_path,
|
|
check_exit_code=False)
|
|
|
|
# If the image does not exist already
|
|
if not output:
|
|
try:
|
|
# Copy file to IVM
|
|
common.ftp_put_command(self.connection_data, source_path,
|
|
remote_path)
|
|
except exception.PowerVMFTPTransferFailed:
|
|
with excutils.save_and_reraise_exception():
|
|
cmd = "/usr/bin/rm -f %s" % final_path
|
|
self.run_vios_command_as_root(cmd)
|
|
|
|
# Verify image file checksums match
|
|
output = self._md5sum_remote_file(final_path)
|
|
if not output:
|
|
LOG.error(_("Unable to get checksum"))
|
|
# Cleanup inconsistent remote file
|
|
cmd = "/usr/bin/rm -f %s" % final_path
|
|
self.run_vios_command_as_root(cmd)
|
|
|
|
raise exception.PowerVMFileTransferFailed(file_path=final_path)
|
|
if source_cksum != output.split(' ')[0]:
|
|
LOG.error(_("Image checksums do not match"))
|
|
# Cleanup inconsistent remote file
|
|
cmd = "/usr/bin/rm -f %s" % final_path
|
|
self.run_vios_command_as_root(cmd)
|
|
|
|
raise exception.PowerVMFileTransferFailed(file_path=final_path)
|
|
|
|
if decompress:
|
|
# Unzip the image
|
|
cmd = "/usr/bin/gunzip %s" % comp_path
|
|
output = self.run_vios_command_as_root(cmd)
|
|
|
|
# Remove existing image file
|
|
cmd = "/usr/bin/rm -f %s.*" % uncomp_path
|
|
output = self.run_vios_command_as_root(cmd)
|
|
|
|
# Rename unzipped image
|
|
cmd = "/usr/bin/mv %s %s" % (uncomp_path, final_path)
|
|
output = self.run_vios_command_as_root(cmd)
|
|
|
|
# Remove compressed image file
|
|
cmd = "/usr/bin/rm -f %s" % comp_path
|
|
output = self.run_vios_command_as_root(cmd)
|
|
|
|
else:
|
|
LOG.debug(_("Image found on host at '%s'") % final_path)
|
|
|
|
# Calculate file size in multiples of 512 bytes
|
|
output = self.run_vios_command("ls -o %s|awk '{print $4}'" %
|
|
final_path, check_exit_code=False)
|
|
if output:
|
|
size = int(output[0])
|
|
else:
|
|
LOG.error(_("Uncompressed image file not found"))
|
|
raise exception.PowerVMFileTransferFailed()
|
|
if (size % 512 != 0):
|
|
size = (int(size / 512) + 1) * 512
|
|
|
|
return final_path, size
|
|
|
|
def _copy_image_file_from_host(self, remote_source_path, local_dest_dir,
|
|
compress=False):
|
|
"""
|
|
Copy a file from IVM to the nova-compute host,
|
|
and return the location of the copy
|
|
|
|
:param remote_source_path remote source file path
|
|
:param local_dest_dir local destination directory
|
|
:param compress: if True, compress the file before transfer;
|
|
if False (default), copy the file as is
|
|
"""
|
|
|
|
temp_str = common.aix_path_join(local_dest_dir,
|
|
os.path.basename(remote_source_path))
|
|
local_file_path = temp_str + '.gz'
|
|
|
|
if compress:
|
|
copy_from_path = remote_source_path + '.gz'
|
|
else:
|
|
copy_from_path = remote_source_path
|
|
|
|
if compress:
|
|
# Gzip the file
|
|
cmd = "/usr/bin/gzip %s" % remote_source_path
|
|
self.run_vios_command_as_root(cmd)
|
|
|
|
# Cleanup uncompressed remote file
|
|
cmd = "/usr/bin/rm -f %s" % remote_source_path
|
|
self.run_vios_command_as_root(cmd)
|
|
|
|
# Get file checksum
|
|
output = self._md5sum_remote_file(copy_from_path)
|
|
if not output:
|
|
LOG.error(_("Unable to get checksum"))
|
|
msg_args = {'file_path': copy_from_path}
|
|
raise exception.PowerVMFileTransferFailed(**msg_args)
|
|
else:
|
|
source_chksum = output.split(' ')[0]
|
|
|
|
# Copy file to host
|
|
common.ftp_get_command(self.connection_data,
|
|
copy_from_path,
|
|
local_file_path)
|
|
|
|
# Calculate copied image checksum
|
|
dest_chksum = self._checksum_local_file(local_file_path)
|
|
|
|
# do comparison
|
|
if source_chksum and dest_chksum != source_chksum:
|
|
LOG.error(_("Image checksums do not match"))
|
|
raise exception.PowerVMFileTransferFailed(
|
|
file_path=local_file_path)
|
|
|
|
# Cleanup transferred remote file
|
|
cmd = "/usr/bin/rm -f %s" % copy_from_path
|
|
output = self.run_vios_command_as_root(cmd)
|
|
|
|
return local_file_path
|
|
|
|
def run_vios_command(self, cmd, check_exit_code=True):
|
|
"""Run a remote command using an active ssh connection.
|
|
|
|
:param command: String with the command to run.
|
|
"""
|
|
self._set_connection()
|
|
stdout, stderr = processutils.ssh_execute(
|
|
self._connection, cmd, check_exit_code=check_exit_code)
|
|
|
|
error_text = stderr.strip()
|
|
if error_text:
|
|
LOG.debug(_("Found error stream for command \"%(cmd)s\": "
|
|
"%(error_text)s"),
|
|
{'cmd': cmd, 'error_text': error_text})
|
|
|
|
return stdout.strip().splitlines()
|
|
|
|
def run_vios_command_as_root(self, command, check_exit_code=True):
|
|
"""Run a remote command as root using an active ssh connection.
|
|
|
|
:param command: List of commands.
|
|
"""
|
|
self._set_connection()
|
|
stdout, stderr = common.ssh_command_as_root(
|
|
self._connection, command, check_exit_code=check_exit_code)
|
|
|
|
error_text = stderr.read()
|
|
if error_text:
|
|
LOG.debug(_("Found error stream for command \"%(command)s\":"
|
|
" %(error_text)s"),
|
|
{'command': command, 'error_text': error_text})
|
|
|
|
return stdout.read().splitlines()
|