# Copyright 2014, 2018 IBM Corp.
#
# All Rights Reserved.
#
#    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.

"""Wrappers for virtual storage elements and adapters."""

import abc
import base64
import binascii
from oslo_log import log as logging
import six

import pypowervm.const as c
import pypowervm.entities as ent
import pypowervm.exceptions as ex
from pypowervm.i18n import _
import pypowervm.util as u
import pypowervm.wrappers.entry_wrapper as ewrap

LOG = logging.getLogger(__name__)

UDID = 'UniqueDeviceID'

# The following are common to all VSCSI storage types
# Storage QoS Constants
_STOR_READ_IOPS = 'ReadIOPS'
_STOR_WRITE_IOPS = 'WriteIOPS'
# Storage Encryption Constants
_STOR_ENCRYPTION_STATE = 'EncryptionState'
_STOR_ENCRYPTION_KEY = 'EncryptionKey'
_STOR_ENCRYPTION_AGENT = 'EncryptionAgent'
# Device tag
_STOR_TAG = 'Tag'
# Emulate model alias
_STOR_EMULATE_MODEL = 'EmulateModel'

_STOR_EL_ORDER = (_STOR_READ_IOPS, _STOR_WRITE_IOPS, _STOR_ENCRYPTION_STATE,
                  _STOR_ENCRYPTION_KEY, _STOR_ENCRYPTION_AGENT, _STOR_TAG,
                  _STOR_EMULATE_MODEL)


class _EncryptionState(object):
    """From EncryptionState.Enum.

    This class is part of an experimental API change and may be subject to
    breaking changes until it is publicized.
    """
    UNENCRYPTED = 'Unencrypted'
    FORMATTED = 'Formatted'
    UNLOCKED = 'Unlocked'


# LUKS-specific encryptor constants
_LUKS_ENCRYPTOR = 'LUKSEncryptor'
_LUKS_CIPHER = 'Cipher'
_LUKS_KEY_SIZE = 'KeySize'
_LUKS_HASH_SPEC = 'Hash'
_LUKS_EL_ORDER = [_LUKS_CIPHER, _LUKS_KEY_SIZE, _LUKS_HASH_SPEC]

# "Any" server adapters are SCSI adapters without client
# adapters that map to remote LPAR slot number 65535. They
# can map to any client and are not recommended but are
# still supported.
ANY_SLOT = 65535

# Virtual Disk Constants
DISK_ROOT = 'VirtualDisk'
_DISK_CAPACITY = 'DiskCapacity'
_DISK_LABEL = 'DiskLabel'
DISK_NAME = 'DiskName'
_DISK_MAX_LOGICAL_VOLS = 'MaxLogicalVolumes'
_DISK_PART_SIZE = 'PartitionSize'
_DISK_VG = 'VolumeGroup'
_DISK_BASE = 'BaseImage'
_DISK_UDID = UDID
_DISK_TYPE = 'VirtualDiskType'
_DISK_BACKSTORE_TYPE = 'BackStoreType'
_DISK_FILEFORMAT = 'FileFormat'
_DISK_RBD_USER = 'RbdUser'
_DISK_OPTIONAL_PARMS = 'OptionalParameters'
_VDISK_EL_ORDER = _STOR_EL_ORDER + (
    _DISK_CAPACITY, _DISK_LABEL, DISK_NAME, _DISK_MAX_LOGICAL_VOLS,
    _DISK_PART_SIZE, _DISK_VG, _DISK_BASE, _DISK_UDID, _DISK_TYPE,
    _DISK_BACKSTORE_TYPE, _DISK_FILEFORMAT, _DISK_RBD_USER,
    _DISK_OPTIONAL_PARMS)


class VDiskType(object):
    """From VirtualDiskType.Enum."""
    FILE = 'File'
    LV = 'LogicalVolume'
    RBD = 'RBD'


class BackStoreType(object):
    """From BackStoreType.Enum

    Desribes the type of backstore handler to use for VDisks.
    FILE_IO, USER_QCOW, and LOOP are used with the FileIO VDisk type.
    USER_RBD is used with the RBD VDisk type.
    """
    # A kernel-space handler that supports raw files.
    FILE_IO = 'fileio'
    # A user-space handler that supports RAW, QCOW or QCOW2 files.
    USER_QCOW = 'user:qcow'
    # Create a loop device for the file, and use the kernel-space block
    # handler. LOOP has higher performance than FILE_IO.
    LOOP = 'loop'
    # A user-space handler that supports rbd. (Used with RBD)
    USER_RBD = 'user:rbd'


class FileFormatType(object):
    """From FileFormatType.Enum

    The format type of the image that will be stored in the VDisk (aka LV).
    """
    RAW = 'raw'
    QCOW2 = 'qcow2'


# Physical Volume Constants
PVS = 'PhysicalVolumes'
PHYS_VOL = 'PhysicalVolume'
_PV_AVAIL_PHYS_PART = 'AvailablePhysicalPartitions'
_PV_VOL_DESC = 'Description'
_PV_LOC_CODE = 'LocationCode'
_PV_PERSISTENT_RESERVE = 'PersistentReserveKeyValue'
_PV_RES_POLICY = 'ReservePolicy'
_PV_RES_POLICY_ALGO = 'ReservePolicyAlgorithm'
_PV_TOTAL_PHYS_PARTS = 'TotalPhysicalPartitions'
_PV_UDID = UDID
_PV_AVAIL_FOR_USE = 'AvailableForUsage'
_PV_VOL_SIZE = 'VolumeCapacity'
_PV_VOL_NAME = 'VolumeName'
_PV_VOL_STATE = 'VolumeState'
_PV_VOL_UNIQUE_ID = 'VolumeUniqueID'
_PV_FC_BACKED = 'IsFibreChannelBacked'
_PV_STG_LABEL = 'StorageLabel'
_PV_PG83 = 'DescriptorPage83'
_PV_EL_ORDER = _STOR_EL_ORDER + (
    _PV_AVAIL_PHYS_PART, _PV_VOL_DESC, _PV_LOC_CODE, _PV_PERSISTENT_RESERVE,
    _PV_RES_POLICY, _PV_RES_POLICY_ALGO, _PV_TOTAL_PHYS_PARTS, _PV_UDID,
    _PV_AVAIL_FOR_USE, _PV_VOL_SIZE, _PV_VOL_NAME, _PV_VOL_STATE,
    _PV_VOL_UNIQUE_ID, _PV_FC_BACKED, _PV_STG_LABEL, _PV_PG83)


class PVState(object):
    ACTIVE = "active"
    MISSING = "missing"
    REMOVED = "removed"
    VARIED_OFF = "varied off"


# Virtual Optical Media Constants
VOPT_ROOT = 'VirtualOpticalMedia'
VOPT_NAME = 'MediaName'
_VOPT_UDID = 'MediaUDID'
_VOPT_MOUNT_TYPE = 'MountType'
_VOPT_SIZE = 'Size'
_VOPT_EL_ORDER = _STOR_EL_ORDER + (
    VOPT_NAME, _VOPT_UDID, _VOPT_MOUNT_TYPE, _VOPT_SIZE)

# Virtual Media Repository Constants
_VREPO_ROOT = 'VirtualMediaRepository'
_VREPO_OPTICAL_MEDIA_ROOT = 'OpticalMedia'
_VREPO_NAME = 'RepositoryName'
_VREPO_SIZE = 'RepositorySize'
_VREPO_EL_ORDER = [_VREPO_OPTICAL_MEDIA_ROOT, _VREPO_NAME, _VREPO_SIZE]

# Volume Group Constants
_VG_AVAILABLE_SIZE = 'AvailableSize'
_VG_BACKING_DEVICE_COUNT = 'BackingDeviceCount'
_VG_FREE_SPACE = 'FreeSpace'
_VG_CAPACITY = 'GroupCapacity'
_VG_NAME = 'GroupName'
_VG_SERIAL_ID = 'GroupSerialID'
_VG_STATE = 'GroupState'
_VG_MAX_LVS = 'MaximumLogicalVolumes'
_VG_MEDIA_REPOS = 'MediaRepositories'
_VG_MIN_ALLOC_SIZE = 'MinimumAllocationSize'
_VG_PHS_VOLS = PVS
_VG_UDID = UDID
_VG_VDISKS = 'VirtualDisks'
_VG_EL_ORDER = (_VG_AVAILABLE_SIZE, _VG_BACKING_DEVICE_COUNT, _VG_FREE_SPACE,
                _VG_CAPACITY, _VG_NAME, _VG_SERIAL_ID, _VG_STATE, _VG_MAX_LVS,
                _VG_MEDIA_REPOS, _VG_MIN_ALLOC_SIZE, _VG_PHS_VOLS, _VG_UDID,
                _VG_VDISKS)

# LogicalUnit Constants
_LU_THIN = 'ThinDevice'
_LU_UDID = UDID
_LU_CAPACITY = 'UnitCapacity'
_LU_TYPE = 'LogicalUnitType'
_LU_CLONED_FROM = 'ClonedFrom'
_LU_IN_USE = 'InUse'
_LU_NAME = 'UnitName'
_LU_MIG = 'LogicalUnitMigration'
_LU_EL_ORDER = _STOR_EL_ORDER + (
    _LU_THIN, _LU_UDID, _LU_CAPACITY, _LU_TYPE, _LU_CLONED_FROM, _LU_IN_USE,
    _LU_NAME, _LU_MIG)


class LUType(object):
    DISK = "VirtualIO_Disk"
    HIBERNATION = "VirtualIO_Hibernation"
    IMAGE = "VirtualIO_Image"
    AMS = "VirtualIO_Active_Memory_Sharing"


_CAPACITY = 'Capacity'

# Tier Constants
_TIER_NAME = 'Name'
_TIER_UDID = UDID
_TIER_IS_DEFAULT = 'IsDefault'
_TIER_CAPACITY = _CAPACITY
_TIER_ASSOC_SSP = 'AssociatedSharedStoragePool'

# Shared Storage Pool Constants
_SSP_NAME = 'StoragePoolName'
_SSP_UDID = UDID
_SSP_CAPACITY = _CAPACITY
_SSP_FREE_SPACE = 'FreeSpace'
_SSP_TOTAL_LU_SIZE = 'TotalLogicalUnitSize'
_SSP_LUS = 'LogicalUnits'
_SSP_LU = 'LogicalUnit'
_SSP_OCS = 'OverCommitSpace'
_SSP_PVS = PVS
_SSP_PV = PHYS_VOL

# Virtual Adapter Constants
CLIENT_ADPT = 'ClientAdapter'
SERVER_ADPT = 'ServerAdapter'

# Common to all Virtual Adapters
_VADPT_TYPE = 'AdapterType'
_VADPT_DRC_NAME = 'DynamicReconfigurationConnectorName'
_VADPT_LOC_CODE = 'LocationCode'
_VADPT_LOCAL_ID = 'LocalPartitionID'
_VADPT_REQD = 'RequiredAdapter'
_VADPT_VARIED_ON = 'VariedOn'
_VADPT_NEXT_SLOT = 'UseNextAvailableSlotID'
_VADPT_NEXT_HI_SLOT = 'UseNextAvailableHighSlotID'
_VADPT_SLOT_NUM = 'VirtualSlotNumber'
_VADPT_ENABLED = 'Enabled'
_VADPT_NAME = 'AdapterName'
_VADPT_UDID = 'UniqueDeviceID'

# Common to VSCSI Adapters (Client & Server)
_VSCSI_ADPT_BACK_DEV_NAME = 'BackingDeviceName'
_VSCSI_ADPT_REM_BACK_DEV_NAME = 'RemoteBackingDeviceName'
_VSCSI_ADPT_REM_LPAR_ID = 'RemoteLogicalPartitionID'
_VSCSI_ADPT_REM_SLOT_NUM = 'RemoteSlotNumber'
_VSCSI_ADPT_SVR_LOC_CODE = 'ServerLocationCode'

# Common to Client Adapters
_VCLNT_ADPT_SVR_ADPT = SERVER_ADPT

# Common to VFC Adapters (Client & Server)
_VFC_ADPT_CONN_PARTITION = 'ConnectingPartition'
_VFC_ADPT_CONN_PARTITION_ID = 'ConnectingPartitionID'
_VFC_ADPT_CONN_SLOT_NUM = 'ConnectingVirtualSlotNumber'

# VFC Server Adapter-specific
_VFC_SVR_ADPT_MAP_PORT = 'MapPort'
_VFC_SVR_ADPT_PHYS_PORT = 'PhysicalPort'

# VFC Client Adapter-specific
_VFC_CLNT_ADPT_WWPNS = 'WWPNs'
_VFC_CLNT_ADPT_LOGGED_IN = 'NportLoggedInStatus'
_VFC_CLNT_ADPT_OS_DISKS = 'OperatingSystemDisks'

# Element Ordering:
#
# A <ServerAdapter/> might be a VSCSI server adapter or a VFC server adapter.
# Likewise <ClientAdapter/>.  The schema inheritance hierarchy informs the
# way we build up the element order constants:
#
#                            VirtualIOAdapter
#                   VFCAdapter             VSCSIAdapter == VSCSIServerAdapter
#      VFCClientAdapter  VFCServerAdapter        VSCSIClientAdapter
#
# However, this doesn't match up with the hierarchy of our wrapper classes:
#
#               VClientStorageAdapterElement
# VSCSIClientAdapterElement    VFCClientAdapterElement
#
#               VServerStorageAdapterElement
# VSCSIServerAdapterElement    VFCServerAdapterElement
#
# So we have to get creative with element ordering for the base classes, since
# they hold the @pvm_type decorator.  We interleave the VSCSI and VFC
# properties to create an element order that can be used commonly for both
# types.  This only works because all overlapping properties happen to be in
# the same order.
#
# Yes, this is funky.

# Converged ordering base for VFC and VSCSI adapters
_VADPT_BASE_EL_ORDER = (
    _VADPT_TYPE, _VADPT_DRC_NAME, _VADPT_LOC_CODE, _VADPT_LOCAL_ID,
    _VADPT_REQD, _VADPT_VARIED_ON, _VADPT_NEXT_SLOT, _VADPT_NEXT_HI_SLOT,
    _VADPT_SLOT_NUM, _VADPT_ENABLED, _VADPT_NAME, _VSCSI_ADPT_BACK_DEV_NAME,
    _VSCSI_ADPT_REM_BACK_DEV_NAME, _VSCSI_ADPT_REM_LPAR_ID,
    _VFC_ADPT_CONN_PARTITION, _VFC_ADPT_CONN_PARTITION_ID,
    _VSCSI_ADPT_REM_SLOT_NUM, _VFC_ADPT_CONN_SLOT_NUM,
    _VSCSI_ADPT_SVR_LOC_CODE, _VADPT_UDID)

# Converged (VSCSI & VFC) Server Adapter element order
_V_SVR_ADPT_EL_ORDER = _VADPT_BASE_EL_ORDER + (
    _VFC_SVR_ADPT_MAP_PORT, _VFC_SVR_ADPT_PHYS_PORT)

# Converged (VSCSI & VFC) Client Adapter element order
_V_CLNT_ADPT_EL_ORDER = _VADPT_BASE_EL_ORDER + (
    _VCLNT_ADPT_SVR_ADPT, _VFC_CLNT_ADPT_WWPNS, _VFC_CLNT_ADPT_LOGGED_IN,
    _VFC_CLNT_ADPT_OS_DISKS)

VFC_CLIENT_ADPT = 'VirtualFibreChannelClientAdapter'

# TargetDevice Constants
_TD_LU_TD = 'SharedStoragePoolLogicalUnitVirtualTargetDevice'
_TD_PV_TD = 'PhysicalVolumeVirtualTargetDevice'
_TD_VOPT_TD = 'VirtualOpticalTargetDevice'
_TD_VDISK_TD = 'LogicalVolumeVirtualTargetDevice'
_TD_LUA = 'LogicalUnitAddress'
_TD_NAME = 'TargetName'


@ewrap.EntryWrapper.pvm_type('VolumeGroup', child_order=_VG_EL_ORDER)
class VG(ewrap.EntryWrapper):
    """Represents a Volume Group that resides on the Virtual I/O Server."""

    @classmethod
    def bld(cls, adapter, name, pv_list):
        vg = super(VG, cls)._bld(adapter)
        vg.name = name
        vg.phys_vols = pv_list
        return vg

    @property
    def name(self):
        return self._get_val_str(_VG_NAME)

    @name.setter
    def name(self, val):
        self.set_parm_value(_VG_NAME, val)

    @property
    def capacity(self):
        """Overall capacity in GB (float)."""
        return self._get_val_float(_VG_CAPACITY)

    @property
    def available_size(self):
        """Available size for new volumes in GB (float)."""
        return self._get_val_float(_VG_AVAILABLE_SIZE)

    @property
    def free_space(self):
        """Current free space in GB (float)."""
        return self._get_val_float(_VG_FREE_SPACE)

    @property
    def serial_id(self):
        return self._get_val_str(_VG_SERIAL_ID)

    @property
    def vmedia_repos(self):
        """Returns a list of  wrappers."""
        es = ewrap.WrapperElemList(self._find_or_seed(_VG_MEDIA_REPOS),
                                   VMediaRepos)
        return es

    @vmedia_repos.setter
    def vmedia_repos(self, repos):
        """Replaces the VirtualMediaRepositories with the new value.

        :param repos: A list of VMediaRepos objects that will
                      replace the existing repositories.
        """
        self.replace_list(_VG_MEDIA_REPOS, repos)

    @property
    def phys_vols(self):
        """Returns a list of the Physical Volumes that back this repo."""
        # TODO(efried): parent_entry=self not needed once VIOS supports pg83
        # descriptor in Events
        es = ewrap.WrapperElemList(self._find_or_seed(_VG_PHS_VOLS), PV,
                                   parent_entry=self)
        return es

    @phys_vols.setter
    def phys_vols(self, phys_vols):
        """Replaces the physical volumes with the new value.

        :param phys_vols: A list of PV objects that will replace
                          the existing Physcial Volumes.
        """
        self.replace_list(_VG_PHS_VOLS, phys_vols)

    @property
    def virtual_disks(self):
        """Returns a list of the Virtual Disks that are in the repo."""
        es = ewrap.WrapperElemList(self._find_or_seed(_VG_VDISKS), VDisk)
        return es

    @virtual_disks.setter
    def virtual_disks(self, virt_disks):
        """Replaces the virtual disks with the new value.

        :param virt_disks: A list of VDisk objects that will replace
                           the existing Virtual Disks.
        """
        self.replace_list(_VG_VDISKS, virt_disks)


@ewrap.ElementWrapper.pvm_type(_VREPO_ROOT, has_metadata=True,
                               child_order=_VREPO_EL_ORDER)
class VMediaRepos(ewrap.ElementWrapper):
    """A Virtual Media Repository for a VIOS.

    Typically used to store an ISO file for image building.
    """

    @classmethod
    def bld(cls, adapter, name, size):
        """Creates a fresh VMediaRepos wrapper.

        This should be used when adding a new Virtual Media Repository to a
        Volume Group.  The name and size for the media repository is required.
        The other attributes are generated from the system.

        Additionally, once created, specific VirtualOpticalMedia can be added
        onto the object.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: The name of the Virtual Media Repository.
        :param size: The size of the repository in GB (float).
        :returns: A VMediaRepos wrapper that can be used for create.
        """
        vmr = super(VMediaRepos, cls)._bld(adapter)
        vmr._name(name)
        vmr._size(size)
        return vmr

    @property
    def optical_media(self):
        """Returns a list of the VirtualOpticalMedia devices in the repo."""
        seed = self._find_or_seed(_VREPO_OPTICAL_MEDIA_ROOT)
        return ewrap.WrapperElemList(seed, VOptMedia)

    @optical_media.setter
    def optical_media(self, new_media):
        """Sets the list of VirtualOpticalMedia devices in the repo.

        :param new_media: The list of new VOptMedia.
        """
        self.replace_list(_VREPO_OPTICAL_MEDIA_ROOT, new_media)

    @property
    def name(self):
        return self._get_val_str(_VREPO_NAME)

    def _name(self, new_name):
        self.set_parm_value(_VREPO_NAME, new_name)

    @property
    def size(self):
        """Returns the size in GB (float)."""
        return self._get_val_float(_VREPO_SIZE)

    def _size(self, new_size):
        self.set_float_gb_value(_VREPO_SIZE, new_size)


@six.add_metaclass(abc.ABCMeta)
@ewrap.Wrapper.base_pvm_type
class _VTargetDevMethods(ewrap.Wrapper):
    """Base class for {storage_type}TargetDevice of an active VSCSIMapping."""

    @classmethod
    def bld(cls, adapter, lua=None, name=None):
        """Build a new Virtual Target Device.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param lua: (Optional, Default None) Logical Unit Address string to
                    assign to the new VTD.
        :param name: (Optional, Default None) Name of the TargetDev. If None
                     name will be assigned by the server
        :return: A new {storage_type}TargetDev, where {storage_type} is
                 appropriate to the subclass.
        """
        vtd = super(_VTargetDevMethods, cls)._bld(adapter)
        if lua is not None:
            vtd._lua(lua)
        if name is not None:
            vtd._name(name)
        return vtd

    @property
    def lua(self):
        """Logical Unit Address of the target device."""
        return self._get_val_str(_TD_LUA)

    def _lua(self, val):
        """Set the Logical Unit Address of this target device."""
        self.set_parm_value(_TD_LUA, val)

    @property
    def name(self):
        """Target Name of the device"""
        return self._get_val_str(_TD_NAME)

    def _name(self, val):
        """Set the Target Name of the device"""
        self.set_parm_value(_TD_NAME, val)


@ewrap.ElementWrapper.pvm_type(_TD_LU_TD, has_metadata=True)
class LUTargetDev(_VTargetDevMethods, ewrap.ElementWrapper):
    """SSP Logical Unit Virtual Target Device for a VSCSIMapping."""
    pass


@ewrap.ElementWrapper.pvm_type(_TD_PV_TD, has_metadata=True)
class PVTargetDev(_VTargetDevMethods, ewrap.ElementWrapper):
    """Physical Volume Virtual Target Device for a VSCSIMapping."""
    pass


@ewrap.ElementWrapper.pvm_type(_TD_VDISK_TD, has_metadata=True)
class VDiskTargetDev(_VTargetDevMethods, ewrap.ElementWrapper):
    """Virtual Disk (Logical Volume) Target Device for a VSCSIMapping."""
    pass


@ewrap.ElementWrapper.pvm_type(_TD_VOPT_TD, has_metadata=True)
class VOptTargetDev(_VTargetDevMethods, ewrap.ElementWrapper):
    """Virtual Optical Media Target Device for a VSCSIMapping."""
    pass


@ewrap.ElementWrapper.pvm_type(VOPT_ROOT, has_metadata=True,
                               child_order=_VOPT_EL_ORDER)
class VOptMedia(ewrap.ElementWrapper):
    """A virtual optical piece of media."""
    target_dev_type = VOptTargetDev

    @classmethod
    def bld(cls, adapter, name, size=None, mount_type='rw'):
        """Creates a fresh VOptMedia wrapper.

        This should be used when adding a new VirtualOpticalMedia device to a
        VirtualMediaRepository.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: The device name.
        :param size: The device size in GB, decimal precision.
        :param mount_type: The type of mount.  Defaults to RW.  Can be set to R
        :returns: A VOptMedia wrapper that can be used for create.
        """
        vom = super(VOptMedia, cls)._bld(adapter)
        vom._media_name(name)
        if size is not None:
            vom._size(size)
        vom._mount_type(mount_type)
        return vom

    @classmethod
    def bld_ref(cls, adapter, name):
        """Creates a VOptMedia wrapper for referencing an existing VOpt."""
        vom = super(VOptMedia, cls)._bld(adapter)
        vom._media_name(name)
        return vom

    @property
    def media_name(self):
        return self._get_val_str(VOPT_NAME)

    @property
    def name(self):
        """Same as media_name - for consistency with other storage types."""
        return self.media_name

    def _media_name(self, new_name):
        self.set_parm_value(VOPT_NAME, new_name)

    @property
    def size(self):
        """Size is a float represented in GB."""
        return self._get_val_float(_VOPT_SIZE)

    def _size(self, new_size):
        self.set_float_gb_value(_VOPT_SIZE, new_size)

    @property
    def udid(self):
        return self._get_val_str(_VOPT_UDID)

    @property
    def mount_type(self):
        return self._get_val_str(_VOPT_MOUNT_TYPE)

    def _mount_type(self, new_mount_type):
        self.set_parm_value(_VOPT_MOUNT_TYPE, new_mount_type)


@ewrap.Wrapper.base_pvm_type
class _StorageQoS(ewrap.Wrapper):
    """StorageQoS mixin fields/methods common to PV and VDisk."""

    @property
    def read_iops_limit(self):
        """The device's I/O Read limit"""
        return self._get_val_int(_STOR_READ_IOPS)

    @read_iops_limit.setter
    def read_iops_limit(self, new_read_iops_limit):
        self.set_parm_value(
            _STOR_READ_IOPS, new_read_iops_limit, attrib=c.ATTR_KSV170)

    @property
    def write_iops_limit(self):
        """The device's I/O Write limit"""
        return self._get_val_int(_STOR_WRITE_IOPS)

    @write_iops_limit.setter
    def write_iops_limit(self, new_write_iops_limit):
        self.set_parm_value(
            _STOR_WRITE_IOPS, new_write_iops_limit, attrib=c.ATTR_KSV170)


@ewrap.ElementWrapper.pvm_type(_LUKS_ENCRYPTOR, has_metadata=True,
                               child_order=_LUKS_EL_ORDER)
class _LUKSEncryptor(ewrap.ElementWrapper):
    """An encryption agent that uses Linux Unified Key Setup (LUKS).

    This class is part of an experimental API change and may be subject to
    breaking changes until it is publicized.
    """

    @classmethod
    def bld(cls, adapter, cipher=None, key_size=None, hash_spec=None):
        """Creates a new LUKSEncryptor wrapper.

        This can be attached to a disk wrapper during disk create and update
        operations to specify encryption parameters for the device.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param cipher: A string containing the encryption algorithm, mode, and
                       initialization vector (e.g. aes-xts-plain64). Optional.
        :param key_size: The key size of the data encryption key. Optional.
        :param hash_spec: The hash algorithm used for data encryption key
                          derivation. Optional.
        """
        encryptor = super(_LUKSEncryptor, cls)._bld(adapter)
        if cipher is not None:
            encryptor.cipher = cipher
        if key_size is not None:
            encryptor.key_size = key_size
        if hash_spec is not None:
            encryptor.hash_spec = hash_spec
        return encryptor

    @property
    def cipher(self):
        """Cipher mode for translating between ciphertext and cleartext."""
        return self._get_val_str(_LUKS_CIPHER)

    @cipher.setter
    def cipher(self, new_cipher):
        self.set_parm_value(_LUKS_CIPHER, new_cipher, attrib=c.ATTR_KSV170)

    @property
    def key_size(self):
        """Size of the master encryption key used for data encryption."""
        return self._get_val_int(_LUKS_KEY_SIZE)

    @key_size.setter
    def key_size(self, new_key_size):
        self.set_parm_value(_LUKS_KEY_SIZE, new_key_size, attrib=c.ATTR_KSV170)

    @property
    def hash_spec(self):
        """Hash algorithm used for key derivation."""
        return self._get_val_str(_LUKS_HASH_SPEC)

    @hash_spec.setter
    def hash_spec(self, new_hash_spec):
        self.set_parm_value(_LUKS_HASH_SPEC, new_hash_spec,
                            attrib=c.ATTR_KSV170)


@ewrap.Wrapper.base_pvm_type
class _StorageEncryption(ewrap.Wrapper):
    """Encryption properties/methods common to PV and VDisk.

    The members of this class are part of an experimental API change and may be
    subject to breaking changes until they are publicized.
    """

    @property
    def _encryption_state(self):
        """The device's encryption state

        This property is part of an experimental API change and may be subject
        to breaking changes until it is publicized.
        """
        return self._get_val_str(_STOR_ENCRYPTION_STATE)

    @_encryption_state.setter
    def _encryption_state(self, new_encryption_state):
        self.set_parm_value(
            _STOR_ENCRYPTION_STATE, new_encryption_state, attrib=c.ATTR_KSV170)

    @property
    def _encryption_agent(self):
        """The encryption agent used to encrypt the device.

        This property is part of an experimental API change and may be subject
        to breaking changes until it is publicized.
        """
        elem = self._find(_STOR_ENCRYPTION_AGENT)
        if elem is None:
            return None
        agent_elems = list(elem)
        if len(agent_elems) != 1:
            return None
        return ewrap.ElementWrapper.wrap(agent_elems[0])

    @_encryption_agent.setter
    def _encryption_agent(self, new_encryption_agent):
        agent_elem = ent.Element(_STOR_ENCRYPTION_AGENT, self.adapter,
                                 attrib=c.ATTR_KSV170)
        if new_encryption_agent is not None:
            agent_elem.inject(new_encryption_agent.element)
        self.inject(agent_elem)

    @property
    def _encryption_key(self):
        """The encryption key used to format and unlock an encrypted device

        This property is part of an experimental API change and may be subject
        to breaking changes until it is publicized.
        """
        return self._get_val_str(_STOR_ENCRYPTION_KEY)

    @_encryption_key.setter
    def _encryption_key(self, new_encryption_key):
        self.set_parm_value(
            _STOR_ENCRYPTION_KEY, new_encryption_key, attrib=c.ATTR_KSV170)


@ewrap.ElementWrapper.pvm_type(PHYS_VOL, has_metadata=True,
                               child_order=_PV_EL_ORDER)
class PV(ewrap.ElementWrapper, _StorageQoS, _StorageEncryption):
    """A physical volume that backs a Volume Group."""
    target_dev_type = PVTargetDev

    @classmethod
    def bld(cls, adapter, name, udid=None, tag=None, emulate_model=None):
        """Creates the a fresh PV wrapper.

        This should be used when wishing to add physical volumes to a Volume
        Group.  Only the name is required.  The other attributes are generated
        from the system.

        The name matches the device name on the system.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: The name of the physical volume on the Virtual I/O Server
                     to add to the Volume Group.  Ex. 'hdisk1'.
        :param udid: Universal Disk Identifier.
        :param tag: String with which to tag the physical device upon mapping.
        :param emulate_model: Boolean emulate model alias flag to set on the
                              physical device upon mapping.
        :returns: An Element that can be used for a PhysicalVolume create or
                  mapping.
        """
        pv = super(PV, cls)._bld(adapter)
        # Assignment order is significant
        if udid:
            pv.udid = udid
        pv.name = name
        if tag:
            pv.tag = tag
        if emulate_model is not None:
            pv.emulate_model = emulate_model
        return pv

    @property
    def udid(self):
        """The unique device id."""
        return self._get_val_str(_PV_UDID)

    @udid.setter
    def udid(self, new_udid):
        self.set_parm_value(_PV_UDID, new_udid)

    @property
    def capacity(self):
        """Returns the capacity as an int in MB."""
        return self._get_val_int(_PV_VOL_SIZE)

    @property
    def name(self):
        return self._get_val_str(_PV_VOL_NAME)

    @name.setter
    def name(self, newname):
        self.set_parm_value(_PV_VOL_NAME, newname)

    @property
    def state(self):
        return self._get_val_str(_PV_VOL_STATE)

    @property
    def is_fc_backed(self):
        return self._get_val_bool(_PV_FC_BACKED)

    @property
    def description(self):
        return self._get_val_str(_PV_VOL_DESC)

    @property
    def loc_code(self):
        return self._get_val_str(_PV_LOC_CODE)

    @property
    def avail_for_use(self):
        return self._get_val_bool(_PV_AVAIL_FOR_USE)

    @property
    def pg83(self):
        encoded = self._get_val_str(_PV_PG83)
        # TODO(efried): Temporary workaround until VIOS supports pg83 in Events
        # >>>CUT HERE>>>
        if not encoded:
            # The PhysicalVolume XML doesn't contain the DescriptorPage83
            # property.  (This could be because the disk really doesn't have
            # this attribute; but if the caller is asking for pg83, they likely
            # expect that it should.)  More likely, it is because their VIOS is
            # running at a level which supplies this datum in a fresh inventory
            # query, but not in a PV ADD Event.  In that case, use the
            # LUARecovery Job to perform the fresh inventory query to retrieve
            # this value.  Since this is expensive, we cache the value.
            if not hasattr(self, '_pg83_encoded'):
                # Get the VIOS UUID from the parent_entry of this PV.  Raise if
                # it doesn't exist.
                if not hasattr(self, 'parent_entry') or not self.parent_entry:
                    raise ex.UnableToBuildPG83EncodingMissingParent(
                        dev_name=self.name)
                # The parent_entry is either a VG or a VIOS.  If a VG, it is a
                # child of the owning VIOS, so pull out the ROOT UUID of its
                # href. If a VIOS, we can't count on the href being a root URI,
                # so pull the target UUID regardless.
                use_root_uuid = isinstance(self.parent_entry, VG)
                vio_uuid = u.get_req_path_uuid(
                    self.parent_entry.href, preserve_case=True,
                    root=use_root_uuid)

                # Local import to prevent circular dependency
                from pypowervm.tasks import hdisk
                # Cache the encoded value for performance
                self._pg83_encoded = hdisk.get_pg83_via_job(
                    self.adapter, vio_uuid, self.udid)
            encoded = self._pg83_encoded
        # <<<CUT HERE<<<
        try:
            return base64.b64decode(encoded).decode(
                'utf-8') if encoded else None
        except (TypeError, binascii.Error) as te:
            LOG.warning(_('PV had encoded pg83 descriptor "%(pg83_raw)s", but '
                          'it failed to decode (%(type_error)s).'),
                        {'pg83_raw': encoded, 'type_error': te.args[0]})
        return None

    @property
    def tag(self):
        return self._get_val_str(_STOR_TAG)

    @tag.setter
    def tag(self, tag):
        """Set the tag on the storage element.

        NOTE: This is only to be used when adding the storage element to a
        VSCSI mapping.  It is ignored by .update().
        """
        self.set_parm_value(_STOR_TAG, tag, attrib=c.ATTR_KSV190)

    @property
    def emulate_model(self):
        return self._get_val_bool(_STOR_EMULATE_MODEL, default=True)

    @emulate_model.setter
    def emulate_model(self, em):
        """Set the emulate model alias flag on the storage element.

        NOTE: This is only to be used when adding the storage element to a
        VSCSI mapping.  It is ignored by .update().
        """
        self.set_parm_value(_STOR_EMULATE_MODEL, u.sanitize_bool_for_api(em),
                            attrib=c.ATTR_KSV190)


@ewrap.Wrapper.base_pvm_type
class _VDisk(ewrap.ElementWrapper):
    """Methods common to VDisk, FileIO, and RBD."""

    @property
    def name(self):
        return self._get_val_str(DISK_NAME)

    @name.setter
    def name(self, name):
        self.set_parm_value(DISK_NAME, name)

    @property
    def label(self):
        return self._get_val_str(_DISK_LABEL)

    def _label(self, new_label):
        self.set_parm_value(_DISK_LABEL, new_label)

    @property
    def capacity(self):
        """Returns the capacity in GB (float)."""
        return self._get_val_float(_DISK_CAPACITY)

    @capacity.setter
    def capacity(self, capacity):
        self.set_float_gb_value(_DISK_CAPACITY, capacity)

    @property
    def udid(self):
        return self._get_val_str(_DISK_UDID)

    @property
    def vdtype(self):
        return self._get_val_str(_DISK_TYPE)

    def _vdtype(self, val):
        self.set_parm_value(_DISK_TYPE, val, attrib=c.ATTR_KSV150)

    def _base_image(self, base_image):
        self.set_parm_value(_DISK_BASE, base_image)

    @property
    def backstore_type(self):
        """The backing store type, one of the BackStoreType enum values."""
        return self._get_val_str(_DISK_BACKSTORE_TYPE)

    def _backstore_type(self, val):
        """Set the backing store type.

        :param val: One of the BackStoreType enum values.
        """
        self.set_parm_value(_DISK_BACKSTORE_TYPE, val, attrib=c.ATTR_KSV150)

    @property
    def file_format(self):
        """File format to be used, one of the FileFormatType enum values."""
        return self._get_val_str(_DISK_FILEFORMAT)

    def _file_format(self, val):
        """Set the file format.

        :param val: One of the FileFormatType enum values.
        """
        self.set_parm_value(_DISK_FILEFORMAT, val, attrib=c.ATTR_KSV150)

    @property
    def tag(self):
        return self._get_val_str(_STOR_TAG)

    @tag.setter
    def tag(self, tag):
        """Set the tag on the storage element.

        NOTE: This is only to be used when adding the storage element to a
        VSCSI mapping.  It is ignored by .update().
        """
        self.set_parm_value(_STOR_TAG, tag, attrib=c.ATTR_KSV190)

    @property
    def emulate_model(self):
        return self._get_val_bool(_STOR_EMULATE_MODEL, default=True)

    @emulate_model.setter
    def emulate_model(self, em):
        """Set the emulate model alias flag on the storage element.

        NOTE: This is only to be used when adding the storage element to a
        VSCSI mapping.  It is ignored by .update().
        """
        self.set_parm_value(_STOR_EMULATE_MODEL, u.sanitize_bool_for_api(em),
                            attrib=c.ATTR_KSV190)


@ewrap.ElementWrapper.pvm_type(DISK_ROOT, has_metadata=True,
                               child_order=_VDISK_EL_ORDER)
class FileIO(_VDisk):
    """A special case of VirtualDisk representing a File I/O object.

    Do not PUT (.create) this wrapper directly.  Attach it to a VSCSIMapping
    and PUT that instead.
    """
    target_dev_type = VDiskTargetDev

    @classmethod
    def bld_ref(cls, adapter, path, backstore_type=None, tag=None,
                emulate_model=None):
        """Creates a FileIO reference for inclusion in a VSCSIMapping.

        :param adapter: A pypowervm.adapter.Adapter for the REST API.
        :param path: The file system path of the File I/O object.
        :param backstore_type: The type of backing storage, one of the
                               BackStoreType enum values.
        :param tag: String with which to tag the device upon mapping.
        :param emulate_model: Boolean emulate model alias flag to set on the
                              physical device upon mapping.
        :return: An Element that can be attached to a VSCSIMapping to create a
                 File I/O mapping on the server.
        """
        fio = super(FileIO, cls)._bld(adapter)
        fio._label(path)
        fio.name = path
        fio._vdtype(VDiskType.FILE)
        if backstore_type is not None:
            fio._backstore_type(backstore_type)
        if tag:
            fio.tag = tag
        if emulate_model is not None:
            fio.emulate_model = emulate_model
        return fio

    # Maintained for backward compatibility.  FileIOs aren't created by REST.
    bld = bld_ref

    @property
    def path(self):
        """Alias for 'label'."""
        return self.label


@ewrap.ElementWrapper.pvm_type(DISK_ROOT, has_metadata=True,
                               child_order=_VDISK_EL_ORDER)
class RBD(_VDisk):
    """A special case of VirtualDisk representing an RBD object.

    Do not PUT (.create) this wrapper directly.  Attach it to a VSCSIMapping
    and PUT that instead.
    """
    target_dev_type = VDiskTargetDev

    @classmethod
    def bld_ref(cls, adapter, name, tag=None, emulate_model=None, user=None):
        """Creates a RBD reference for inclusion in a VSCSIMapping.

        :param adapter: A pypowervm.adapter.Adapter for the REST API.
        :param name: The name of the RBD object.  Also used as the label.
        :param tag: String with which to tag the device upon mapping.
        :param emulate_model: Boolean emulate model alias flag to set on the
                              physical device upon mapping.
        :param user: The user id used to access the rbd cluster.
        :return: An Element that can be attached to a VSCSIMapping to create a
                 RBD mapping on the server.
        """
        rbd = super(RBD, cls)._bld(adapter)
        rbd.name = name
        rbd._label(name)
        rbd._vdtype(VDiskType.RBD)
        rbd._backstore_type(BackStoreType.USER_RBD)
        if tag:
            rbd.tag = tag
        if emulate_model is not None:
            rbd.emulate_model = emulate_model
        if user is not None:
            rbd._user(user)
        return rbd

    def _user(self, user):
        self.set_parm_value(_DISK_RBD_USER, user, attrib=c.ATTR_KSV190)


@ewrap.ElementWrapper.pvm_type(DISK_ROOT, has_metadata=True,
                               child_order=_VDISK_EL_ORDER)
class VDisk(_VDisk, _StorageQoS, _StorageEncryption):
    """A Logical Volume virtual disk that can be attached to a VM."""
    target_dev_type = VDiskTargetDev

    @classmethod
    def bld(cls, adapter, name, capacity, label=None, base_image=None,
            file_format=None, tag=None, emulate_model=None):
        """Creates a VDisk Wrapper for creating a new VDisk.

        This should be used when the user wishes to add a new Virtual Disk to
        the Volume Group.  The flow is to use this method to lay out the
        attributes of the new Virtual Disk.  Then add it to the Volume Group's
        virtual disks. Then perform an update of the Volume Group.  The disk
        should be created by the update operation.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: The name of the virtual disk
        :param capacity: A float number that defines the GB of the disk.
        :param label: The generic label for the disk.  Not required.
        :param base_image: UDID of virtual disk that contains source data
                           Not required.
        :param file_format: (Optional) File format of VDisk.  See
                            FileFormatType enumeration for valid formats.
        :param tag: String with which to tag the device upon mapping.
        :param emulate_model: Boolean emulate model alias flag to set on the
                              physical device upon mapping.
        :returns: An Element that can be used for a VirtualDisk create.
        """
        vd = super(VDisk, cls)._bld(adapter)
        vd.capacity = capacity
        # Label must be specified; str will make None 'None'.
        vd._label(str(label))
        vd.name = name
        if base_image:
            vd._base_image(base_image)
        if file_format:
            vd._file_format(file_format)
        vd._vdtype(VDiskType.LV)
        if tag:
            vd.tag = tag
        if emulate_model is not None:
            vd.emulate_model = emulate_model
        return vd

    @classmethod
    def bld_ref(cls, adapter, name, tag=None, emulate_model=None):
        """Creates a VDisk Wrapper for referring to an existing VDisk."""
        vd = super(VDisk, cls)._bld(adapter)
        vd.name = name
        vd._vdtype(VDiskType.LV)
        if tag:
            vd.tag = tag
        if emulate_model is not None:
            vd.emulate_model = emulate_model
        return vd

    @property
    def vg_uri(self):
        return self.get_href(_DISK_VG, one_result=True)


# Alias for VDisk making it explicit that it's a Logical Volume type
LV = VDisk


@six.add_metaclass(abc.ABCMeta)
@ewrap.Wrapper.base_pvm_type
class _LUBase(ewrap.Wrapper):
    """Mixin for a Logical Unit EntryWrapper or ElementWrapper.

    A Logical Unit is either a DETAIL object (within a SharedStoragePool or
    SCSI mapping); or it is a first-class REST CHILD of Tier.  In either case,
    its properties/methods are the same, provided here.
    """
    target_dev_type = LUTargetDev

    @classmethod
    def bld(cls, adapter, name, capacity, thin=None, typ=None, clone=None,
            tag=None, emulate_model=None):
        """Build a fresh wrapper for LU creation within an SSP.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: The name to assign to the new LogicalUnit
        :param capacity: Capacity in GB for the new LogicalUnit
        :param thin: Provision the new LU as thin (True) or thick (False).
        :param typ: Logical Unit type, one of the LUType values.
        :param clone: If the new LU is to be a linked clone, this param is a
                      LU(Ent) wrapper representing the backing image LU.
        :param tag: String with which to tag the device upon mapping.
        :param emulate_model: Boolean emulate model alias flag to set on the
                              physical device upon mapping.
        :return: A new LU wrapper suitable for adding to SSP.logical_units
                 prior to update.
        """
        lu = super(_LUBase, cls)._bld(adapter)
        lu._name(name)
        lu._capacity(capacity)
        if thin is not None:
            lu._is_thin(thin)
        if typ is not None:
            lu._lu_type(typ)
        if clone is not None:
            lu._cloned_from_udid(clone.udid)
            # New LU must be at least as big as the backing LU.
            lu._capacity(max(capacity, clone.capacity))
        if tag:
            lu.tag = tag
        if emulate_model is not None:
            lu.emulate_model = emulate_model
        return lu

    @classmethod
    def bld_ref(cls, adapter, name, udid, tag=None, emulate_model=None):
        """Creates the a fresh LU wrapper.

        The name matches the device name on the system.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: The name of the logical unit on the Virtual I/O Server.
        :param udid: Universal Disk Identifier.
        :param tag: String with which to tag the device upon mapping.
        :param emulate_model: Boolean emulate model alias flag to set on the
                              physical device upon mapping.
        :returns: An Element that can be used for a PhysicalVolume create.
        """
        lu = super(_LUBase, cls)._bld(adapter)
        lu._name(name)
        lu._udid(udid)
        if tag:
            lu.tag = tag
        if emulate_model is not None:
            lu.emulate_model = emulate_model
        return lu

    def __eq__(self, other):
        """Name and UDID are sufficient for equality.

        For example, if we change an LU's capacity, it's still the same LU.
        We're counting on UDIDs not being repeated in any reasonable scenario.
        """
        return self.name == other.name and self.udid == other.udid

    def __hash__(self):
        """For comparing sets of LUs."""
        # The contract of hash is that two equal thingies must have the same
        # hash, but two thingies with the same hash are not necessarily equal.
        # The hash is used for assigning keys to hash buckets in a dictionary:
        # if two keys hash the same, their items go into the same bucket, but
        # they're still different items.
        if six.PY3:
            conv = int
        else:
            import __builtin__
            conv = __builtin__.long
        return conv(self.udid[2:], base=16)

    @property
    def name(self):
        return self._get_val_str(_LU_NAME)

    def _name(self, value):
        return self.set_parm_value(_LU_NAME, value)

    @property
    def udid(self):
        return self._get_val_str(_LU_UDID)

    def _udid(self, value):
        self.set_parm_value(_LU_UDID, value)

    @property
    def capacity(self):
        """Float capacity in GB."""
        return self._get_val_float(_LU_CAPACITY)

    def _capacity(self, val):
        """val is float."""
        self.set_float_gb_value(_LU_CAPACITY, val)

    @property
    def lu_type(self):
        """String enum value e.g. "VirtualIO_Disk."""
        return self._get_val_str(_LU_TYPE)

    def _lu_type(self, val):
        self.set_parm_value(_LU_TYPE, val)

    @property
    def is_thin(self):
        return self._get_val_bool(_LU_THIN, default=None)

    def _is_thin(self, val):
        """val is boolean."""
        self.set_parm_value(_LU_THIN, u.sanitize_bool_for_api(val))

    @property
    def cloned_from_udid(self):
        return self._get_val_str(_LU_CLONED_FROM)

    def _cloned_from_udid(self, val):
        self.set_parm_value(_LU_CLONED_FROM, val)

    @property
    def in_use(self):
        return self._get_val_bool(_LU_IN_USE, default=None)

    @property
    def tag(self):
        return self._get_val_str(_STOR_TAG)

    @tag.setter
    def tag(self, tag):
        """Set the tag on the storage element.

        NOTE: This is only to be used when adding the storage element to a
        VSCSI mapping.  It is ignored by .update().
        """
        self.set_parm_value(_STOR_TAG, tag, attrib=c.ATTR_KSV190)

    @property
    def emulate_model(self):
        return self._get_val_bool(_STOR_EMULATE_MODEL, default=True)

    @emulate_model.setter
    def emulate_model(self, em):
        """Set the emulate model alias flag on the storage element.

        NOTE: This is only to be used when adding the storage element to a
        VSCSI mapping.  It is ignored by .update().
        """
        self.set_parm_value(_STOR_EMULATE_MODEL, u.sanitize_bool_for_api(em),
                            attrib=c.ATTR_KSV190)


@ewrap.ElementWrapper.pvm_type('LogicalUnit', has_metadata=True,
                               child_order=_LU_EL_ORDER)
class LU(_LUBase, ewrap.ElementWrapper):
    """ElementWrapper representing a LogicalUnit DETAIL object.

    LogicalUnit exists as a DETAIL object e.g. within a SharedStoragePool
    (accessed via SSP.logical_units[n]) or a SCSI mapping (accessed via
    VIOS.scsi_mappings[n].backing_storage).
    """
    pass


@ewrap.EntryWrapper.pvm_type('LogicalUnit', child_order=_LU_EL_ORDER)
class LUEnt(_LUBase, ewrap.EntryWrapper):
    """EntryWrapper representing a LogicalUnit as a first-class REST object.

    LogicalUnit exists as a CHILD REST object under Tier.  This class provides
    the ability to perform e.g.

        LUEnt.get(adapter, parent=tier)
    """
    pass


@ewrap.EntryWrapper.pvm_type('Tier')
class Tier(ewrap.EntryWrapper):
    """A storage grouping within a SharedStoragePool."""

    @property
    def name(self):
        return self._get_val_str(_TIER_NAME)

    @property
    def udid(self):
        return self._get_val_str(_TIER_UDID)

    @property
    def is_default(self):
        return self._get_val_bool(_TIER_IS_DEFAULT)

    @property
    def capacity(self):
        return self._get_val_float(_TIER_CAPACITY)

    @property
    def ssp_uuid(self):
        """The UUID of this Tier's parent SharedStoragePool."""
        return u.get_req_path_uuid(self.get_href(_TIER_ASSOC_SSP,
                                                 one_result=True))


@ewrap.EntryWrapper.pvm_type('SharedStoragePool')
class SSP(ewrap.EntryWrapper):
    """A Shared Storage Pool containing PVs and LUs."""

    search_keys = dict(name='StoragePoolName')

    @classmethod
    def bld(cls, adapter, name, data_pv_list):
        """Create a fresh SSP EntryWrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: String name for the SharedStoragePool.
        :param data_pv_list: Iterable of storage.PV instances
                             representing the data volumes for the
                             SharedStoragePool.
        """
        ssp = super(SSP, cls)._bld(adapter)
        # Assignment order matters.
        ssp.physical_volumes = data_pv_list
        ssp.name = name
        return ssp

    @property
    def name(self):
        return self._get_val_str(_SSP_NAME)

    @name.setter
    def name(self, newname):
        self.set_parm_value(_SSP_NAME, newname)

    @property
    def udid(self):
        return self._get_val_str(_SSP_UDID)

    @property
    def capacity(self):
        """Capacity in GB as a float."""
        return self._get_val_float(_SSP_CAPACITY)

    @property
    def free_space(self):
        """Free space in GB as a float."""
        return self._get_val_float(_SSP_FREE_SPACE)

    @property
    def over_commit_space(self):
        """Over commit space in GB as a float."""
        return self._get_val_float(_SSP_OCS)

    @property
    def total_lu_size(self):
        """Total LU size in GB as a float."""
        return self._get_val_float(_SSP_TOTAL_LU_SIZE)

    @property
    def logical_units(self):
        """WrapperElemList of LU wrappers."""
        return ewrap.WrapperElemList(self._find_or_seed(_SSP_LUS), LU)

    @logical_units.setter
    def logical_units(self, lus):
        self.replace_list(_SSP_LUS, lus)

    @property
    def physical_volumes(self):
        """WrapperElemList of PV wrappers."""
        return ewrap.WrapperElemList(self._find_or_seed(_SSP_PVS), PV)

    @physical_volumes.setter
    def physical_volumes(self, pvs):
        self.replace_list(_SSP_PVS, pvs)


@ewrap.Wrapper.base_pvm_type
class _VStorageAdapterMethods(ewrap.Wrapper):
    """Mixin to be used with _VStorageAdapter{Element|Entry}."""

    @property
    def side(self):
        """Will return either Server or Client.

        A Server indicates that this is a virtual adapter that resides on the
        Virtual I/O Server.

        A Client indicates that this is an adapter residing on a Client LPAR.
        """
        return self._get_val_str(_VADPT_TYPE)

    def _side(self, t):
        self.set_parm_value(_VADPT_TYPE, t)

    @property
    def is_varied_on(self):
        """True if the adapter is varied on."""
        return self._get_val_str(_VADPT_VARIED_ON)

    def _use_next_slot(self, use):
        """Use next available (not high) slot."""
        self.set_parm_value(_VADPT_NEXT_SLOT, u.sanitize_bool_for_api(use))

    @property
    def loc_code(self):
        """The device's location code."""
        return self._get_val_str(_VADPT_LOC_CODE)


# base_pvm_type by _VStorageAdapterMethods
@six.add_metaclass(abc.ABCMeta)
class _VStorageAdapterElement(ewrap.ElementWrapper, _VStorageAdapterMethods):
    """Parent class for the virtual storage adapters (FC or SCSI)."""
    has_metadata = True

    @classmethod
    def _bld_new(cls, adapter, side):
        """Build a {Client|Server}Adapter requesting a new virtual adapter.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param side: Either 'Client' or 'Server'.
        :returns: A fresh ClientAdapter or ServerAdapter wrapper with
                  UseNextAvailableSlotID=true
        """
        adp = super(_VStorageAdapterElement, cls)._bld(adapter)
        adp._use_next_slot(True)
        adp._side(side)
        return adp


# base_pvm_type by _VStorageAdapterMethods
@six.add_metaclass(abc.ABCMeta)
class _VStorageAdapterEntry(ewrap.EntryWrapper, _VStorageAdapterMethods):
    """Parent class for the virtual storage adapters (FC or SCSI)."""
    has_metadata = True

    @classmethod
    def _bld_new(cls, adapter, side):
        """Build a {Client|Server}Adapter requesting a new virtual adapter.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param side: Either 'Client' or 'Server'.
        :returns: A fresh ClientAdapter or ServerAdapter wrapper with
                  UseNextAvailableSlotID=true
        """
        adp = super(_VStorageAdapterEntry, cls)._bld(adapter)
        adp._side(side)
        adp._use_next_slot(True)
        return adp


@ewrap.Wrapper.base_pvm_type
class _VClientAdapterMethods(ewrap.Wrapper):
    """Mixin to be used with _VClientStorageAdapter{Element|Entry}."""
    @classmethod
    def bld(cls, adapter, slot_num=None):
        """Builds a new Client Adapter.

        If the slot number is None then we'll specify the
        'UseNextAvailableSlot' tag to REST and the REST layer will assign the
        slot. The slot number that it chose will be in the response.

        :param adapter: A pypowervm.adapter.Adapter
        :param slot_num: (Optional, Default: None) The client slot number to
                         be used.
        :returns: A new Client Adapter.
        """
        clad = super(_VClientAdapterMethods, cls)._bld_new(adapter, 'Client')
        if slot_num is not None:
            clad._lpar_slot_num(slot_num)
            clad._use_next_slot(False)
        return clad

    @property
    def lpar_id(self):
        """The short ID (not UUID) of the LPAR side of this adapter.

        Note that the LPAR ID is LocalPartitionID on the client side, and
        RemoteLogicalPartitionID on the server side.
        """
        return self._get_val_int(_VADPT_LOCAL_ID)

    @property
    def lpar_slot_num(self):
        """The (int) slot number that the adapter is in."""
        return self._get_val_int(_VADPT_SLOT_NUM)

    def _lpar_slot_num(self, slot_num):
        """Set the slot number that the adapter is in."""
        self.set_parm_value(_VADPT_SLOT_NUM, slot_num)


@six.add_metaclass(abc.ABCMeta)
@ewrap.ElementWrapper.pvm_type(CLIENT_ADPT, has_metadata=True,
                               child_order=_V_CLNT_ADPT_EL_ORDER)
class VClientStorageAdapterElement(_VClientAdapterMethods,
                                   _VStorageAdapterElement):
    """Parent class for Client Virtual Storage Adapter Elements."""
    pass


@six.add_metaclass(abc.ABCMeta)
@ewrap.ElementWrapper.pvm_type(SERVER_ADPT, has_metadata=True,
                               child_order=_V_SVR_ADPT_EL_ORDER)
class VServerStorageAdapterElement(_VStorageAdapterElement):
    """Parent class for Server Virtual Storage Adapters."""

    @classmethod
    def bld(cls, adapter):
        return super(VServerStorageAdapterElement, cls)._bld_new(adapter,
                                                                 'Server')

    @property
    def name(self):
        """The adapter's name on the Virtual I/O Server."""
        return self._get_val_str(_VADPT_NAME)

    @property
    def udid(self):
        """The device's Unique Device Identifier."""
        return self._get_val_str(_VADPT_UDID)


# pvm_type decorator by superclass (it is not unique)
class VSCSIClientAdapterElement(VClientStorageAdapterElement):
    """The Virtual SCSI Client Adapter within a VSCSI mapping.

    Paired with a VSCSIServerAdapterElement.
    """
    @property
    def vios_id(self):
        """The short ID (not UUID) of the VIOS side of this adapter.

        Note that the VIOS ID is RemoteLogicalPartitionID on the client side,
        and LocalPartitionID on the server side.
        """
        return self._get_val_int(_VSCSI_ADPT_REM_LPAR_ID)

    @property
    def vios_slot_num(self):
        """The (int) remote slot number of the paired adapter."""
        return self._get_val_int(_VSCSI_ADPT_REM_SLOT_NUM)


# pvm_type decorator by superclass (it is not unique)
class VSCSIServerAdapterElement(VServerStorageAdapterElement):
    """The Virtual SCSI Server Adapter within a VSCSI mapping.

    Paired with a VSCSIClientAdapterElement.
    """

    @property
    def backing_dev_name(self):
        """The backing device name that this virtual adapter is hooked into."""
        return self._get_val_str(_VSCSI_ADPT_BACK_DEV_NAME)

    @property
    def lpar_id(self):
        """The short ID (not UUID) of the LPAR side of this adapter.

        Note that the LPAR ID is LocalPartitionID on the client side, and
        RemoteLogicalPartitionID on the server side.
        """
        return self._get_val_int(_VSCSI_ADPT_REM_LPAR_ID)

    @property
    def vios_id(self):
        """The short ID (not UUID) of the VIOS side of this adapter.

        Note that the VIOS ID is RemoteLogicalPartitionID on the client side,
        and LocalPartitionID on the server side.
        """
        return self._get_val_int(_VADPT_LOCAL_ID)

    @property
    def lpar_slot_num(self):
        """The (int) slot number that the LPAR side of the adapter."""
        return self._get_val_int(_VSCSI_ADPT_REM_SLOT_NUM)

    @property
    def vios_slot_num(self):
        """The (int) slot number of the VIOS side of the adapter."""
        return self._get_val_int(_VADPT_SLOT_NUM)


@ewrap.Wrapper.base_pvm_type
class _VFCClientAdapterMethods(ewrap.Wrapper):
    """Mixin to be used with VFCClientAdapter(Element)."""
    def _wwpns(self, value):
        """Sets the WWPN string.

        :param value: The list of WWPNs.  Should only contain two.
        """
        if value is not None:
            self.set_parm_value(_VFC_CLNT_ADPT_WWPNS, " ".join(value).lower())

    @property
    def wwpns(self):
        """Returns a list that contains the WWPNs.  If no WWPNs, empty list."""
        val = self._get_val_str(_VFC_CLNT_ADPT_WWPNS)
        if val is None:
            return []
        else:
            return val.upper().split(' ')

    @property
    def vios_id(self):
        """The short ID (not UUID) of the VIOS side of this adapter."""
        return self._get_val_int(_VFC_ADPT_CONN_PARTITION_ID)

    @property
    def vios_slot_num(self):
        """The (int) remote slot number of the paired adapter."""
        return self._get_val_int(_VFC_ADPT_CONN_SLOT_NUM)


# pvm_type decorator by superclass (it is not unique)
class VFCClientAdapterElement(VClientStorageAdapterElement,
                              _VFCClientAdapterMethods):
    """The Virtual Fibre Channel Client Adapter within a VFC mapping.

    Paired with a VFCServerAdapterElement.
    """

    @classmethod
    def bld(cls, adapter, wwpns=None, slot_num=None):
        """Create a fresh Virtual Fibre Channel Client Adapter.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param wwpns: An optional set of two client WWPNs to set on the
                      adapter.
        :param slot_num: An optional integer to be set as the Virtual
                         slot number.
        """
        adpt = super(VFCClientAdapterElement, cls).bld(adapter,
                                                       slot_num=slot_num)

        if wwpns is not None:
            adpt._wwpns(wwpns)

        return adpt


@six.add_metaclass(abc.ABCMeta)
@ewrap.EntryWrapper.pvm_type(VFC_CLIENT_ADPT, has_metadata=True)
class VFCClientAdapter(_VStorageAdapterEntry, _VClientAdapterMethods,
                       _VFCClientAdapterMethods):
    """EntryWrapper for VirtualFibreChannelClientAdapter CHILD.

    Use this to wrap LogicalPartition/{uuid}/VirtualFibreChannelClientAdapter.
    """
    pass


# pvm_type decorator by superclass (it is not unique)
class VFCServerAdapterElement(VServerStorageAdapterElement):
    """The Virtual Fibre Channel Server Adapter within a VFC mapping.

    Paired with a VFCClientAdapterElement.
    """

    @property
    def map_port(self):
        """The physical FC port name that this virtual port is connect to."""
        return self._get_val_str(_VFC_SVR_ADPT_MAP_PORT)

    @property
    def lpar_id(self):
        """The short ID (not UUID) of the LPAR side of this adapter."""
        return self._get_val_int(_VFC_ADPT_CONN_PARTITION_ID)

    @property
    def vios_id(self):
        """The short ID (not UUID) of the VIOS side of this adapter."""
        return self._get_val_int(_VADPT_LOCAL_ID)

    @property
    def lpar_slot_num(self):
        """The (int) slot number that the LPAR side of the adapter."""
        return self._get_val_int(_VFC_ADPT_CONN_SLOT_NUM)

    @property
    def vios_slot_num(self):
        """The (int) slot number of the VIOS side of the adapter."""
        return self._get_val_int(_VADPT_SLOT_NUM)