class PCSDriver(driver.ComputeDriver):
capabilities = {
"has_imagecache": True,
"supports_recreate": False,
}
def __init__(self, virtapi, read_only=False):
super(PCSDriver, self).__init__(virtapi)
LOG.info("__init__")
self.host = None
self._host_state = None
self._initiator = None
if CONF.firewall_driver != "nova.virt.firewall.NoopFirewallDriver":
raise NotImplementedError(firewall_msg)
self.vif_driver = PCSVIFDriver()
self.image_cache_manager = imagecache.ImageCacheManager(self)
self.image_cache = template.LZRWImageCache()
self.volume_drivers = driver.driver_dict_from_config(
CONF.pcs_volume_drivers, self)
@property
def host_state(self):
if not self._host_state:
self._host_state = HostState(self)
return self._host_state
def init_host(self, host=socket.gethostname()):
LOG.info("init_host")
if not self.host:
self.host = host
prlsdkapi_proxy.sdk.init_server_sdk()
self.psrv = prlsdkapi_proxy.sdk.Server()
self.psrv.login('localhost', CONF.pcs_login, CONF.pcs_password).wait()
self
def list_instances(self):
LOG.info("list_instances")
flags = pc.PVTF_CT | pc.PVTF_VM
ves = self.psrv.get_vm_list_ex(nFlags=flags).wait()
return map(lambda x: x.get_name(), ves)
def list_instance_uuids(self):
LOG.info("list_instance_uuids")
flags = pc.PVTF_CT | pc.PVTF_VM
ves = self.psrv.get_vm_list_ex(nFlags=flags).wait()
return map(lambda x: x.get_uuid()[1:-1], ves)
def instance_exists(self, instance_id):
LOG.info("instance_exists: %s" % instance_id)
try:
self._get_ve_by_name(instance_id)
return True
except exception.InstanceNotFound:
return False
def _get_ve_by_name(self, name):
try:
ve = self.psrv.get_vm_config(name,
pc.PGVC_SEARCH_BY_NAME).wait()[0]
except prlsdkapi_proxy.sdk.PrlSDKError as e:
if e.error_code == get_sdk_errcode('PRL_ERR_VM_UUID_NOT_FOUND'):
raise exception.InstanceNotFound(instance_id=name)
raise
return ve
def _start(self, sdk_ve):
sdk_ve.start().wait()
def _stop(self, sdk_ve, kill=False):
if kill:
sdk_ve.stop_ex(pc.PSM_KILL, pc.PSF_FORCE).wait()
else:
sdk_ve.stop_ex(pc.PSM_ACPI, pc.PSF_FORCE).wait()
def _suspend(self, sdk_ve):
sdk_ve.suspend().wait()
def _resume(self, sdk_ve):
sdk_ve.resume().wait()
def _pause(self, sdk_ve):
sdk_ve.pause().wait()
def _unpause(self, sdk_ve):
sdk_ve.start().wait()
def _get_state(self, sdk_ve):
vm_info = sdk_ve.get_state().wait().get_param()
return vm_info.get_state()
def _wait_intermediate_state(self, sdk_ve):
intermediate_states = [
pc.VMS_COMPACTING,
pc.VMS_CONTINUING,
pc.VMS_DELETING_STATE,
pc.VMS_MIGRATING,
pc.VMS_PAUSING,
pc.VMS_RESETTING,
pc.VMS_RESTORING,
pc.VMS_RESUMING,
pc.VMS_SNAPSHOTING,
pc.VMS_STARTING,
pc.VMS_STOPPING,
pc.VMS_SUSPENDING,
pc.VMS_SUSPENDING_SYNC,
]
while True:
state = self._get_state(sdk_ve)
if state not in intermediate_states:
break
LOG.info('VE "%s" is in %s state, waiting' %
(sdk_ve.get_name(), PCS_STATE_NAMES[state]))
time.sleep(1)
def _set_started_state(self, sdk_ve):
self._wait_intermediate_state(sdk_ve)
state = self._get_state(sdk_ve)
LOG.info("Switch VE to RUNNING state, current is %s" %
PCS_STATE_NAMES[state])
if state == pc.VMS_STOPPED:
self._start(sdk_ve)
elif state == pc.VMS_SUSPENDED:
self._resume(sdk_ve)
elif state == pc.VMS_PAUSED:
self._unpause(sdk_ve)
def _set_stopped_state(self, sdk_ve, kill):
self._wait_intermediate_state(sdk_ve)
state = self._get_state(sdk_ve)
LOG.info("Switch VE to STOPPED state, current is %s" %
PCS_STATE_NAMES[state])
if state == pc.VMS_RUNNING:
self._stop(sdk_ve, kill)
elif state == pc.VMS_SUSPENDED:
self._resume(sdk_ve)
self._stop(sdk_ve, kill)
elif state == pc.VMS_PAUSED:
self._unpause(sdk_ve)
self._stop(sdk_ve, kill)
def _set_paused_state(self, sdk_ve):
self._wait_intermediate_state(sdk_ve)
state = self._get_state(sdk_ve)
LOG.info("Switch VE to PAUSED state, current is %s" %
PCS_STATE_NAMES[state])
if state == pc.VMS_RUNNING:
self._pause(sdk_ve)
elif state == pc.VMS_SUSPENDED:
self._resume(sdk_ve)
self._pause(sdk_ve)
elif state == pc.VMS_STOPPED:
self._start(sdk_ve)
self._pause(sdk_ve)
def _set_suspended_state(self, sdk_ve):
self._wait_intermediate_state(sdk_ve)
state = self._get_state(sdk_ve)
LOG.info("Switch VE to SUSPENDED state, current is %s" %
PCS_STATE_NAMES[state])
if state == pc.VMS_RUNNING:
self._suspend(sdk_ve)
elif state == pc.VMS_PAUSED:
self._unpause(sdk_ve)
self._suspend(sdk_ve)
elif state == pc.VMS_STOPPED:
self._start(sdk_ve)
self._suspend(sdk_ve)
def _sync_ve_state(self, sdk_ve, instance):
req_state = instance['power_state']
if req_state == power_state.NOSTATE:
return
if req_state == power_state.RUNNING:
self._set_started_state(sdk_ve)
elif req_state == power_state.PAUSED:
self._set_paused_state(sdk_ve)
elif req_state == power_state.SHUTDOWN:
self._set_stopped_state(sdk_ve, False)
elif req_state == power_state.CRASHED:
self._set_stopped_state(sdk_ve, True)
elif req_state == power_state.SUSPENDED:
self._set_suspended_state(sdk_ve)
def _plug_vifs(self, instance, sdk_ve, network_info):
for vif in network_info:
self.vif_driver.plug(self, instance, sdk_ve, vif)
def plug_vifs(self, instance, network_info):
LOG.info("plug_vifs: %s" % instance['name'])
if not self.instance_exists(instance['name']):
return
sdk_ve = self._get_ve_by_name(instance['name'])
if self._get_state(sdk_ve) in [pc.VMS_RUNNING, pc.VMS_PAUSED]:
self._plug_vifs(instance, sdk_ve, network_info)
def _unplug_vifs(self, instance, sdk_ve, network_info):
for vif in network_info:
self.vif_driver.unplug(self, instance, sdk_ve, vif)
def unplug_vifs(self, instance, network_info):
LOG.info("unplug_vifs: %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
self._unplug_vifs(instance, sdk_ve, network_info)
def _apply_flavor(self, instance, sdk_ve, resize_root_disk):
metadata = instance.system_metadata
sdk_ve.begin_edit().wait()
sdk_ve.set_cpu_count(int(metadata['instance_type_vcpus']))
sdk_ve.set_ram_size(int(metadata['instance_type_memory_mb']))
if sdk_ve.get_vm_type() == pc.PVT_CT:
# Can't tune physpages and swappages for VMs
physpages = int(metadata['instance_type_memory_mb']) << 8
sdk_ve.set_resource(pc.PCR_PHYSPAGES, physpages, physpages)
swappages = int(metadata['instance_type_swap']) << 8
sdk_ve.set_resource(pc.PCR_SWAPPAGES, swappages, swappages)
sdk_ve.commit().wait()
# TODO(dguryanov): tune swap size in VMs
if not resize_root_disk:
return
ndisks = sdk_ve.get_devs_count_by_type(pc.PDE_HARD_DISK)
if ndisks != 1:
raise Exception("More than one disk in container")
disk = sdk_ve.get_dev_by_type(pc.PDE_HARD_DISK, 0)
disk_size = int(metadata['instance_type_root_gb']) << 10
disk.resize_image(disk_size, 0).wait()
def _set_admin_password(self, sdk_ve, admin_password):
if sdk_ve.get_vm_type() == pc.PVT_VM:
# FIXME(dguryanov): waiting for system boot is broken for VMs
LOG.info("Skip setting admin password")
return
session = sdk_ve.login_in_guest(
PRL_PRIVILEGED_GUEST_OS_SESSION, '', 0).wait()[0]
session.set_user_passwd('root', admin_password, 0).wait()
session.logout(0)
def _create_blank_vm(self, instance):
# create an empty VM
sdk_ve = self.psrv.create_vm()
srv_cfg = self.psrv.get_srv_config().wait().get_param()
os_ver = getattr(pc, "PVS_GUEST_VER_LIN_REDHAT")
sdk_ve.set_default_config(srv_cfg, os_ver, True)
sdk_ve.set_uuid('{%s}' % instance['uuid'])
sdk_ve.set_name(instance['name'])
sdk_ve.set_vm_type(pc.PVT_VM)
# remove unneded devices
n = sdk_ve.get_devs_count_by_type(pc.PDE_HARD_DISK)
for i in xrange(n):
dev = sdk_ve.get_dev_by_type(pc.PDE_HARD_DISK, i)
dev.remove()
n = sdk_ve.get_devs_count_by_type(pc.PDE_GENERIC_NETWORK_ADAPTER)
for i in xrange(n):
dev = sdk_ve.get_dev_by_type(pc.PDE_GENERIC_NETWORK_ADAPTER, i)
dev.remove()
sdk_ve.reg('', True).wait()
return sdk_ve
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 _set_boot_device(self, sdk_ve, hdd):
sdk_ve.begin_edit().wait()
b = sdk_ve.create_boot_dev()
b.set_type(pc.PDE_HARD_DISK)
b.set_index(hdd.get_index())
b.set_sequence_index(0)
b.set_in_use(1)
sdk_ve.commit().wait()
def spawn(self, context, instance, image_meta, injected_files,
admin_password, network_info=None, block_device_info=None):
LOG.info("spawn: %s" % (instance['name']))
boot_hdd = None
booted_from_volume = False
if instance['image_ref']:
tmpl = template.get_template(self, context, instance, image_meta)
sdk_ve = tmpl.create_instance()
boot_hdd = sdk_ve.get_dev_by_type(pc.PDE_HARD_DISK, 0)
else:
sdk_ve = self._create_blank_vm(instance)
self._apply_flavor(instance, sdk_ve,
resize_root_disk=bool(instance['image_ref']))
self._reset_network(sdk_ve)
for vif in network_info:
self.vif_driver.setup_dev(self, instance, sdk_ve, vif)
block_device_mapping = driver.block_device_info_get_mapping(
block_device_info)
for vol in block_device_mapping:
connection_info = vol['connection_info']
disk_info = {
'dev': vol['mount_device'],
'mount_device': vol['mount_device']}
hdd = self.volume_driver_method('connect_volume',
connection_info, sdk_ve, disk_info)
if instance['root_device_name'] == vol['mount_device']:
self._set_boot_device(sdk_ve, hdd)
boot_hdd = hdd
booted_from_volume = True
if not boot_hdd:
raise Exception("Boot disk is missing")
if CONF.pcs_inject_partition != -2:
if booted_from_volume:
LOG.warn(('File injection into a boot from volume'
'instance is not supported'), instance=instance)
else:
self._inject_files(sdk_ve, boot_hdd, instance,
network_info=network_info,
files=injected_files,
admin_pass=admin_password)
sdk_ve.start_ex(pc.PSM_VM_START, pc.PNSF_VM_START_WAIT).wait()
self._plug_vifs(instance, sdk_ve, network_info)
self._set_admin_password(sdk_ve, admin_password)
def destroy(self, context, instance, network_info, block_device_info=None,
destroy_disks=True):
LOG.info("destroy: %s" % instance['name'])
try:
sdk_ve = self._get_ve_by_name(instance['name'])
except exception.InstanceNotFound:
return
self._unplug_vifs(instance, sdk_ve, network_info)
self._set_stopped_state(sdk_ve, True)
block_device_mapping = driver.block_device_info_get_mapping(
block_device_info)
for vol in block_device_mapping:
connection_info = vol['connection_info']
disk_info = {
'dev': vol['mount_device'],
'mount_device': vol['mount_device']}
self.volume_driver_method('disconnect_volume',
connection_info, sdk_ve, disk_info, True)
sdk_ve.delete().wait()
def get_info(self, instance):
LOG.info("get_info: %s %s" % (instance['id'], instance['name']))
sdk_ve = self._get_ve_by_name(instance['name'])
vm_info = sdk_ve.get_state().wait().get_param()
data = {}
data['state'] = PCS_POWER_STATE[vm_info.get_state()]
data['max_mem'] = sdk_ve.get_ram_size()
data['mem'] = data['max_mem']
data['num_cpu'] = sdk_ve.get_cpu_count()
data['cpu_time'] = 1000
return data
def get_host_stats(self, refresh=False):
LOG.info("get_host_stats")
return self.host_state.get_host_stats(refresh=refresh)
def get_available_resource(self, nodename):
LOG.info("get_available_resource")
return self.host_state.get_host_stats(refresh=True)
@staticmethod
def get_host_ip_addr():
return CONF.my_ip
def reboot(self, context, instance, network_info, reboot_type='SOFT',
block_device_info=None, bad_volumes_callback=None):
LOG.info("reboot %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
if self._get_state(sdk_ve) == pc.VMS_RUNNING \
and reboot_type == 'SOFT':
sdk_ve.restart().wait()
else:
kill = not (reboot_type == 'SOFT')
self._set_stopped_state(sdk_ve, kill)
self._set_started_state(sdk_ve)
self._plug_vifs(instance, sdk_ve, network_info)
def suspend(self, instance):
LOG.info("suspend %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
self._set_suspended_state(sdk_ve)
def resume(self, resume, instance, network_info, block_device_info=None):
LOG.info("resume %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
self._set_started_state(sdk_ve)
self._plug_vifs(instance, sdk_ve, network_info)
def pause(self, instance):
LOG.info("suspend %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
if sdk_ve.get_vm_type() != pc.PVT_VM:
raise NotImplementedError()
self._set_paused_state(sdk_ve)
def unpause(self, instance, network_info, block_device_info=None):
LOG.info("resume %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
if sdk_ve.get_vm_type() != pc.PVT_VM:
raise NotImplementedError()
self._set_started_state(sdk_ve)
def power_off(self, instance):
LOG.info("power_off %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
self._set_stopped_state(sdk_ve, kill=False)
def power_on(self, context, instance, network_info,
block_device_info=None):
LOG.info("power_on %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
self._set_started_state(sdk_ve)
self._unplug_vifs(instance, sdk_ve, network_info)
self._plug_vifs(instance, sdk_ve, network_info)
def get_vnc_console(self, context, instance):
LOG.info("get_vnc_console %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
if sdk_ve.get_vncmode() != pc.PRD_AUTO:
sdk_ve.begin_edit().wait()
sdk_ve.set_vncmode(pc.PRD_AUTO)
sdk_ve.commit().wait()
sdk_ve.refresh_config()
sleep_time = 0.5
for attempt in xrange(5):
#FIXME: it's possible a bug in dispatcher: sometimes when
# you setup VNC, port still 0 for some short time.
port = sdk_ve.get_vncport()
if port:
break
time.sleep(sleep_time)
sleep_time = sleep_time * 2
sdk_ve.refresh_config()
return {'host': self.host, 'port': port, 'internal_access_path': None}
def _reset_network(self, sdk_ve):
"""Remove all network adapters (except for venet,
which can't be removed).
"""
ndevs = sdk_ve.get_devs_count_by_type(
pc.PDE_GENERIC_NETWORK_ADAPTER)
sdk_ve.begin_edit().wait()
for i in xrange(ndevs):
dev = sdk_ve.get_dev_by_type(pc.PDE_GENERIC_NETWORK_ADAPTER, i)
if dev.get_emulated_type() != pc.PNA_ROUTED:
dev.remove()
sdk_ve.commit().wait()
def _snapshot_ve(self, context, instance, image_id, update_task_state, ve):
def upload(context, image_service, image_id, metadata, f):
LOG.info("Start uploading image %s ..." % image_id)
image_service.update(context, image_id, metadata, f)
LOG.info("Image %s uploading complete." % image_id)
_image_service = glance.get_remote_image_service(context, image_id)
snapshot_image_service, snapshot_image_id = _image_service
snapshot = snapshot_image_service.show(context, snapshot_image_id)
disk_format = CONF.pcs_snapshot_disk_format
metadata = {'is_public': False,
'status': 'active',
'name': snapshot['name'],
'container_format': 'bare',
'disk_format': disk_format,
}
props = {}
metadata['properties'] = props
if ve.get_vm_type() == pc.PVT_VM:
props['vm_mode'] = 'hvm'
else:
props['vm_mode'] = 'exe'
update_task_state(task_state=task_states.IMAGE_UPLOADING,
expected_state=task_states.IMAGE_PENDING_UPLOAD)
hdd = pcsutils.get_boot_disk(ve)
hdd_path = hdd.get_image_path()
props['pcs_ostemplate'] = ve.get_os_template()
if disk_format == 'ploop':
xml_path = os.path.join(hdd_path, "DiskDescriptor.xml")
cmd = ['ploop', 'snapshot-list', '-H', '-o', 'fname', xml_path]
out, err = utils.execute(*cmd, run_as_root=True)
image_path = out.strip()
with open(xml_path) as f:
props['pcs_disk_descriptor'] = f.read().replace('\n', '')
with open(image_path) as f:
upload(context, snapshot_image_service, image_id, metadata, f)
elif disk_format == 'cploop':
uploader = pcsutils.CPloopUploader(hdd_path)
f = uploader.start()
try:
upload(context, snapshot_image_service, image_id, metadata, f)
finally:
uploader.wait()
else:
dst = tempfile.mktemp(dir=os.path.dirname(hdd_path))
LOG.info("Convert image %s to %s format ..." %
(image_id, disk_format))
pcsutils.convert_image(hdd_path, dst, disk_format,
root_helper=utils._get_root_helper())
with open(dst) as f:
upload(context, snapshot_image_service, image_id, metadata, f)
os.unlink(dst)
def snapshot(self, context, instance, image_id, update_task_state):
LOG.info("snapshot %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD)
tmpl_ve_name = "tmpl-" + image_id
tmpl_ve = sdk_ve.clone_ex(tmpl_ve_name, CONF.pcs_snapshot_dir,
pc.PCVF_CLONE_TO_TEMPLATE).wait().get_param()
ve_dir = tmpl_ve.get_home_path()
if tmpl_ve.get_vm_type() == pc.PVT_VM:
# for containers get_home_path returns path
# to private area, but for VMs - path to VM
# config file.
ve_dir = os.path.dirname(ve_dir)
utils.execute('chown', '-R', 'nova:nova', ve_dir, run_as_root=True)
try:
self._snapshot_ve(context, instance, image_id,
update_task_state, tmpl_ve)
finally:
tmpl_ve.delete().wait()
def set_admin_password(self, context, instance_id, new_pass=None):
LOG.info("set_admin_password %s %s" % (instance_id, new_pass))
sdk_ve = self._get_ve_by_name(instance_id)
self._set_admin_password(sdk_ve, new_pass)
def manage_image_cache(self, context, all_instances):
LOG.info("manage_image_cache")
self.image_cache_manager.update(context, all_instances)
def volume_driver_method(self, method_name, connection_info,
*args, **kwargs):
driver_type = connection_info.get('driver_volume_type')
if driver_type not in self.volume_drivers:
raise exception.VolumeDriverNotFound(driver_type=driver_type)
driver = self.volume_drivers[driver_type]
method = getattr(driver, method_name)
return method(connection_info, *args, **kwargs)
def get_volume_connector(self, instance):
if not self._initiator:
self._initiator = get_iscsi_initiator()
if not self._initiator:
LOG.debug(_('Could not determine iscsi initiator name'),
instance=instance)
connector = {'ip': CONF.my_ip,
'host': CONF.host}
if self._initiator:
connector['initiator'] = self._initiator
return connector
def get_disk_dev_path(self, hdd):
#FIXME: add snapshots support
xml_path = os.path.join(hdd.get_sys_name(), "DiskDescriptor.xml")
cmd = ['ploop', 'snapshot-list', '-H', '-o', 'fname', xml_path]
out, err = utils.execute(*cmd, run_as_root=True)
return out.strip()
def get_used_block_devices(self):
ves = self.psrv.get_vm_list_ex(nFlags=pc.PVTF_VM).wait()
devices = []
for sdk_ve in ves:
n = sdk_ve.get_devs_count_by_type(pc.PDE_HARD_DISK)
for i in xrange(n):
dev = sdk_ve.get_dev_by_type(pc.PDE_HARD_DISK, i)
if dev.get_emulated_type() == pc.PDT_USE_REAL_HDD:
devices.append(self.get_disk_dev_path(dev))
return devices
def attach_volume(self, context, connection_info, instance, mountpoint,
encryption=None):
LOG.info("attach_volume %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
if sdk_ve.get_vm_type() == pc.PVT_CT:
raise Exception("Can't attach volume to a container")
disk_info = {
'dev': mountpoint,
'mount_device': mountpoint}
hdd = self.volume_driver_method('connect_volume',
connection_info, sdk_ve, disk_info)
def detach_volume(self, connection_info, instance, mountpoint,
encryption=None):
LOG.info("detach_volume %s" % instance['name'])
sdk_ve = self._get_ve_by_name(instance['name'])
if sdk_ve.get_vm_type() == pc.PVT_CT:
raise Exception("Can't detach volume from a container")
if self._get_state(sdk_ve) != pc.VMS_STOPPED:
raise Exception("You can't detach volume from running VM")
disk_info = {
'dev': mountpoint,
'mount_device': mountpoint}
self.volume_driver_method('disconnect_volume',
connection_info, sdk_ve, disk_info, True)