# Copyright 2015, 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.

"""Base classes, enums, and constants shared by LPAR and VIOS EntryWrappers."""
from pypowervm import const
from pypowervm.i18n import _
import pypowervm.util as u
import pypowervm.wrappers.entry_wrapper as ewrap
import pypowervm.wrappers.iocard as card

# Base Partition (_BP)
_BP_ALLOW_PERF_DATA_COLL = 'AllowPerformanceDataCollection'
_BP_ASSOC_PROF = 'AssociatedPartitionProfile'
_BP_AVAIL_PRIORITY = 'AvailabilityPriority'
_BP_CURR_BSR_ARRAYS = 'CurrentAllocatedBarrierSynchronizationRegisterArrays'
_BP_CURRENT_PROC_MODE = 'CurrentProcessorCompatibilityMode'
_BP_PROFILE_SYNC = 'CurrentProfileSync'
_BP_CURR_SECURE_BOOT = 'CurrentSecureBoot'
_BP_HOSTNAME = 'Hostname'
_BP_BOOTABLE = 'IsBootable'
_BP_CALL_HOME = 'IsCallHomeEnabled'
_BP_CONN_MONITORING = 'IsConnectionMonitoringEnabled'
_BP_OP_IN_PROGRESS = 'IsOperationInProgress'
_BP_REDUNDANT_ERR_PATH_REP = 'IsRedundantErrorPathReportingEnabled'
_BP_TIME_REF = 'IsTimeReferencePartition'
_BP_ATTN_LED = 'IsVirtualServiceAttentionLEDOn'
_BP_TRUSTED_PLATFORM = 'IsVirtualTrustedPlatformModuleEnabled'
_BP_KEYLOCK_POS = 'KeylockPosition'
_BP_LOGICAL_SERIAL_NUM = 'LogicalSerialNumber'
_BP_OS_VER = 'OperatingSystemVersion'
_BP_CAPABILITIES = 'PartitionCapabilities'
_BP_ID = 'PartitionID'
_BP_IO_CFG = 'PartitionIOConfiguration'
_BP_MEM_CFG = 'PartitionMemoryConfiguration'
_BP_NAME = 'PartitionName'
_BP_PROC_CFG = 'PartitionProcessorConfiguration'
_BP_PROFS = 'PartitionProfiles'
_BP_STATE = 'PartitionState'
_BP_TYPE = 'PartitionType'
_BP_UUID = 'PartitionUUID'
_BP_PENDING_PROC_MODE = 'PendingProcessorCompatibilityMode'
_BP_PENDING_SECURE_BOOT = 'PendingSecureBoot'
_BP_PROC_POOL = 'ProcessorPool'
_BP_PROG_DATA_REMAIN = 'ProgressPartitionDataRemaining'
_BP_PROG_DATA_TOTAL = 'ProgressPartitionDataTotal'
_BP_PROG_STATE = 'ProgressState'
_BP_RMC_STATE = 'ResourceMonitoringControlState'
_BP_RMC_IP = 'ResourceMonitoringIPAddress'
_BP_VAL_INT_PERF = 'ValidInteractivePerformance'
_BP_ASSOC_SYSTEM = 'AssociatedManagedSystem'
_BP_SRIOV_ETH = 'SRIOVEthernetLogicalPorts'
_BP_SRIOV_ROCE = 'SRIOVRoCELogicalPorts'
_BP_SRIOV_FC_ETH = 'SRIOVFibreChannelOverEthernetLogicalPorts'
_BP_CNAS = 'ClientNetworkAdapters'
_BP_HOST_ETH = 'HostEthernetAdapterLogicalPorts'
_BP_MAC_PREF = 'MACAddressPrefix'
_BP_SVC_PARTITION = 'IsServicePartition'
_BP_MGMT_CAP = 'PowerVMManagementCapable'
_BP_REF_CODE = 'ReferenceCode'
_BP_REF_CODE_FULL = 'ReferenceCodeFull'
_BP_MGT_PARTITION = 'IsManagementPartition'
_BP_AUTO_START = 'AutoStart'
_BP_BOOT_MODE = 'BootMode'
_BP_NVRAM = 'PartitionNVRAM'
_BP_UPTIME = 'Uptime'
_BP_DISABLE_SECURE_BOOT = 'DisableSecureBoot'
_BP_ASSOC_GROUPS = 'AssociatedGroups'
_BP_POWER_ON_WITH_HYP = 'PowerOnWithHypervisor'
_BP_ASSOC_TASKS = 'AssociatedTasks'
_BP_DESC = 'Description'

BP_EL_ORDER = (
    _BP_ALLOW_PERF_DATA_COLL, _BP_ASSOC_PROF, _BP_AVAIL_PRIORITY,
    _BP_CURR_BSR_ARRAYS, _BP_CURRENT_PROC_MODE, _BP_PROFILE_SYNC, _BP_HOSTNAME,
    _BP_BOOTABLE, _BP_CALL_HOME, _BP_CONN_MONITORING, _BP_OP_IN_PROGRESS,
    _BP_REDUNDANT_ERR_PATH_REP, _BP_TIME_REF, _BP_ATTN_LED,
    _BP_TRUSTED_PLATFORM, _BP_KEYLOCK_POS, _BP_LOGICAL_SERIAL_NUM, _BP_OS_VER,
    _BP_CAPABILITIES, _BP_ID, _BP_IO_CFG, _BP_MEM_CFG, _BP_NAME, _BP_PROC_CFG,
    _BP_PROFS, _BP_STATE, _BP_TYPE, _BP_UUID, _BP_PENDING_PROC_MODE,
    _BP_PROC_POOL, _BP_PROG_DATA_REMAIN, _BP_PROG_DATA_TOTAL, _BP_PROG_STATE,
    _BP_RMC_STATE, _BP_RMC_IP, _BP_VAL_INT_PERF, _BP_ASSOC_SYSTEM,
    _BP_SRIOV_ETH, _BP_SRIOV_ROCE, _BP_SRIOV_FC_ETH, _BP_CNAS, _BP_HOST_ETH,
    _BP_MAC_PREF, _BP_SVC_PARTITION, _BP_MGMT_CAP, _BP_REF_CODE,
    _BP_REF_CODE_FULL, _BP_MGT_PARTITION, _BP_AUTO_START, _BP_BOOT_MODE,
    _BP_NVRAM, _BP_UPTIME, _BP_DISABLE_SECURE_BOOT, _BP_PENDING_SECURE_BOOT,
    _BP_CURR_SECURE_BOOT, _BP_ASSOC_GROUPS, _BP_POWER_ON_WITH_HYP,
    _BP_ASSOC_TASKS, _BP_DESC
)

# Partition Capabilities (_CAP)
_CAP_DLPAR_IO_CAPABLE = 'DynamicLogicalPartitionIOCapable'
_CAP_DLPAR_MEM_CAPABLE = 'DynamicLogicalPartitionMemoryCapable'
_CAP_DLPAR_PROC_CAPABLE = 'DynamicLogicalPartitionProcessorCapable'
_CAP_INTRUSION_DETECT_CAPABLE = 'InternalAndExternalIntrusionDetectionCapable'
_CAP_RMC_OS_SHUTDOWN_CAPABLE = ('ResourceMonitoringControlOperatingSystem'
                                'ShutdownCapable')
_CAP_EL_ORDER = (_CAP_DLPAR_IO_CAPABLE, _CAP_DLPAR_MEM_CAPABLE,
                 _CAP_DLPAR_PROC_CAPABLE, _CAP_INTRUSION_DETECT_CAPABLE,
                 _CAP_RMC_OS_SHUTDOWN_CAPABLE,)

# Processor Configuration (_PC)
_PC_DED_PROC_CFG = 'DedicatedProcessorConfiguration'
_PC_HAS_DED_PROCS = 'HasDedicatedProcessors'
_PC_SHR_PROC_CFG = 'SharedProcessorConfiguration'
_PC_SHARING_MODE = 'SharingMode'
_PC_CURR_HAS_DED_PROCS = 'CurrentHasDedicatedProcessors'
_PC_CURR_SHARING_MODE = 'CurrentSharingMode'
_PC_CURR_DED_PROC_CFG = 'CurrentDedicatedProcessorConfiguration'
_PC_RUN_HAS_DED_PROCS = 'RuntimeHasDedicatedProcessors'
_PC_RUN_SHARING_MODE = 'RuntimeSharingMode'
_PC_CURR_SHR_PROC_CFG = 'CurrentSharedProcessorConfiguration'
_PC_EL_ORDER = (_PC_DED_PROC_CFG, _PC_HAS_DED_PROCS, _PC_SHR_PROC_CFG,
                _PC_SHARING_MODE, _PC_CURR_HAS_DED_PROCS,
                _PC_CURR_SHARING_MODE, _PC_CURR_DED_PROC_CFG,
                _PC_RUN_HAS_DED_PROCS, _PC_RUN_SHARING_MODE,
                _PC_CURR_SHR_PROC_CFG)

# Shared Processor Configuration (_SPC)
_SPC_DES_PROC_UNIT = 'DesiredProcessingUnits'
_SPC_DES_VIRT_PROC = 'DesiredVirtualProcessors'
_SPC_MAX_PROC_UNIT = 'MaximumProcessingUnits'
_SPC_MAX_VIRT_PROC = 'MaximumVirtualProcessors'
_SPC_MIN_PROC_UNIT = 'MinimumProcessingUnits'
_SPC_MIN_VIRT_PROC = 'MinimumVirtualProcessors'
_SPC_SHARED_PROC_POOL_ID = 'SharedProcessorPoolID'
_SPC_UNCAPPED_WEIGHT = 'UncappedWeight'
_SPC_ALLOC_VIRT_PROC = 'AllocatedVirtualProcessors'
_SPC_CURR_MAX_PROC_UNIT = 'CurrentMaximumProcessingUnits'
_SPC_CURR_MIN_PROC_UNIT = 'CurrentMinimumProcessingUnits'
_SPC_CURR_PROC_UNIT = 'CurrentProcessingUnits'
_SPC_CURR_SHARED_PROC_POOL_ID = 'CurrentSharedProcessorPoolID'
_SPC_CURR_UNCAPPED_WEIGHT = 'CurrentUncappedWeight'
_SPC_CURR_MIN_VIRT_PROC = 'CurrentMinimumVirtualProcessors'
_SPC_CURR_MAX_VIRT_PROC = 'CurrentMaximumVirtualProcessors'
_SPC_RUN_PROC_UNIT = 'RuntimeProcessingUnits'
_SPC_RUN_UNCAPPED_WEIGHT = 'RuntimeUncappedWeight'
_SPC_EL_ORDER = (_SPC_DES_PROC_UNIT, _SPC_DES_VIRT_PROC, _SPC_MAX_PROC_UNIT,
                 _SPC_MAX_VIRT_PROC, _SPC_MIN_PROC_UNIT, _SPC_MIN_VIRT_PROC,
                 _SPC_SHARED_PROC_POOL_ID, _SPC_UNCAPPED_WEIGHT,
                 _SPC_ALLOC_VIRT_PROC, _SPC_CURR_MAX_PROC_UNIT,
                 _SPC_CURR_MIN_PROC_UNIT, _SPC_CURR_PROC_UNIT,
                 _SPC_CURR_SHARED_PROC_POOL_ID, _SPC_CURR_UNCAPPED_WEIGHT,
                 _SPC_CURR_MIN_VIRT_PROC, _SPC_CURR_MAX_VIRT_PROC,
                 _SPC_RUN_PROC_UNIT, _SPC_RUN_UNCAPPED_WEIGHT)

# Dedicated Processor Configuration (_DPC)
_DPC_DES_PROCS = 'DesiredProcessors'
_DPC_MAX_PROCS = 'MaximumProcessors'
_DPC_MIN_PROCS = 'MinimumProcessors'

# Partition Memory Configuration (_MEM)
_MEM_PROF_AME_ENABLED = 'ActiveMemoryExpansionEnabled'
_MEM_AMS_ENABLED = 'ActiveMemorySharingEnabled'
_MEM_BSR_ARRAY_CT = 'BarrierSynchronizationRegisterArrayCount'
_MEM_DES_ENT = 'DesiredEntitledMemory'
_MEM_DES_HUGE_PAGE_CT = 'DesiredHugePageCount'
_MEM_DES = 'DesiredMemory'
_MEM_EXP_FACTOR = 'ExpansionFactor'
_MEM_PPT_RATIO = 'PhysicalPageTableRatio'
_MEM_HW_PG_TBL_RATIO = 'HardwarePageTableRatio'
_MEM_MAN_ENT_MODE_ENABLED = 'ManualEntitledModeEnabled'
_MEM_MAX_HUGE_PG_CT = 'MaximumHugePageCount'
_MEM_MAX = 'MaximumMemory'
_MEM_WT = 'MemoryWeight'
_MEM_MIN_HUGE_PG_CT = 'MinimumHugePageCount'
_MEM_MIN = 'MinimumMemory'
_MEM_PRI_PGING_SVC_PART = 'PrimaryPagingServicePartition'
_MEM_SEC_PGING_SVC_PART = 'SecondaryPagingServicePartition'
_MEM_AUTO_ENT_MEM_ENABLED = 'AutoEntitledMemoryEnabled'
_MEM_CURR_BSR_ARRAYS = 'CurrentBarrierSynchronizationRegisterArrays'
_MEM_CURR_ENT = 'CurrentEntitledMemory'
_MEM_CURR_EXP_FACT = 'CurrentExpansionFactor'
_MEM_CURR_PPT_RATIO = 'CurrentPhysicalPageTableRatio'
_MEM_CURR_HW_PG_TBL_RATIO = 'CurrentHardwarePageTableRatio'
_MEM_CURR_HUGE_PG_CT = 'CurrentHugePageCount'
_MEM_CURR_MAX_HUGE_PG_CT = 'CurrentMaximumHugePageCount'
_MEM_CURR_MAX = 'CurrentMaximumMemory'
_MEM_CUR = 'CurrentMemory'
_MEM_CURR_MEM_WT = 'CurrentMemoryWeight'
_MEM_CURR_MIN_HUGE_PG_CT = 'CurrentMinimumHugePageCount'
_MEM_CURR_MIN = 'CurrentMinimumMemory'
_MEM_CURR_PGING_SVC_PART = 'CurrentPagingServicePartition'
_MEM_EXP_HW_ACC_ENABLED = 'MemoryExpansionHardwareAccessEnabled'
_MEM_ENC_HW_ACC_ENABLED = 'MemoryEncryptionHardwareAccessEnabled'
_MEM_AME_ENABLED = 'MemoryExpansionEnabled'
_MEM_RELEASABLE = 'MemoryReleaseable'
_MEM_TO_RELEASE = 'MemoryToRelease'
_MEM_RED_ERR_PATH_REP_ENABLED = 'RedundantErrorPathReportingEnabled'
_MEM_REQ_MIN_FOR_MAX = 'RequiredMinimumForMaximum'
_MEM_RUNT_ENT = 'RuntimeEntitledMemory'
_MEM_RUNT_EXP_FACT = 'RuntimeExpansionFactor'
_MEM_RUNT_HUGE_PG_CT = 'RuntimeHugePageCount'
_MEM_RUNT = 'RuntimeMemory'
_MEM_RUNT_WT = 'RuntimeMemoryWeight'
_MEM_RUNT_MIN = 'RuntimeMinimumMemory'
_MEM_SHARED_MEM_ENABLED = 'SharedMemoryEnabled'

_MEM_EL_ORDER = (
    _MEM_PROF_AME_ENABLED, _MEM_AMS_ENABLED, _MEM_BSR_ARRAY_CT, _MEM_DES_ENT,
    _MEM_DES_HUGE_PAGE_CT, _MEM_DES, _MEM_EXP_FACTOR, _MEM_PPT_RATIO,
    _MEM_HW_PG_TBL_RATIO, _MEM_MAN_ENT_MODE_ENABLED, _MEM_MAX_HUGE_PG_CT,
    _MEM_MAX, _MEM_WT, _MEM_MIN_HUGE_PG_CT, _MEM_MIN, _MEM_PRI_PGING_SVC_PART,
    _MEM_SEC_PGING_SVC_PART, _MEM_AUTO_ENT_MEM_ENABLED, _MEM_CURR_BSR_ARRAYS,
    _MEM_CURR_ENT, _MEM_CURR_EXP_FACT, _MEM_CURR_PPT_RATIO,
    _MEM_CURR_HW_PG_TBL_RATIO, _MEM_CURR_HUGE_PG_CT, _MEM_CURR_MAX_HUGE_PG_CT,
    _MEM_CURR_MAX, _MEM_CUR, _MEM_CURR_MEM_WT, _MEM_CURR_MIN_HUGE_PG_CT,
    _MEM_CURR_MIN, _MEM_CURR_PGING_SVC_PART, _MEM_EXP_HW_ACC_ENABLED,
    _MEM_ENC_HW_ACC_ENABLED, _MEM_AME_ENABLED, _MEM_RELEASABLE,
    _MEM_TO_RELEASE, _MEM_RED_ERR_PATH_REP_ENABLED, _MEM_REQ_MIN_FOR_MAX,
    _MEM_RUNT_ENT, _MEM_RUNT_EXP_FACT, _MEM_RUNT_HUGE_PG_CT, _MEM_RUNT,
    _MEM_RUNT_WT, _MEM_RUNT_MIN, _MEM_SHARED_MEM_ENABLED)

# Partition I/O Configuration (_IO)
IO_CFG_ROOT = _BP_IO_CFG
_IO_MAX_SLOTS = 'MaximumVirtualIOSlots'
_IO_TIO = 'TaggedIO'

# Tagged I/O (_TIO)
_TIO_ALT_CONSOLE = 'AlternateConsole'
_TIO_ALT_LOAD_SRC = 'AlternateLoadSource'
_TIO_CONSOLE = 'Console'
_TIO_LOAD_SRC = 'LoadSource'
_TIO_OP_CONSOLE = 'OperationsConsole'
_TIO_EL_ORDER = (_TIO_ALT_CONSOLE, _TIO_ALT_LOAD_SRC, _TIO_CONSOLE,
                 _TIO_LOAD_SRC, _TIO_OP_CONSOLE)

# Constants for the I/O Slot Configuration
IO_SLOTS_ROOT = 'ProfileIOSlots'
IO_SLOT_ROOT = 'ProfileIOSlot'
_IO_SLOT_REQ = 'IsRequired'

# Constants for the Associated I/O Slot
ASSOC_IO_SLOT_ROOT = 'AssociatedIOSlot'
_ASSOC_IO_SLOT_BUS_GRP = 'BusGroupingRequired'
_ASSOC_IO_SLOT_DESC = 'Description'
_ASSOC_IO_SLOT_FEAT_CODES = 'FeatureCodes'
_ASSOC_IO_SLOT_PHYS_LOC = 'IOUnitPhysicalLocation'
_ASSOC_IO_SLOT_ADPT_ID = 'PCAdapterID'
_ASSOC_IO_SLOT_PCI_CLASS = 'PCIClass'
_ASSOC_IO_SLOT_PCI_DEV_ID = 'PCIDeviceID'
_ASSOC_IO_SLOT_PCI_SUBSYS_DEV_ID = 'PCISubsystemDeviceID'
_ASSOC_IO_SLOT_PCI_MFG_ID = 'PCIManufacturerID'
_ASSOC_IO_SLOT_PCI_REV_ID = 'PCIRevisionID'
_ASSOC_IO_SLOT_PCI_VENDOR_ID = 'PCIVendorID'
_ASSOC_IO_SLOT_SUBSYS_VENDOR_ID = 'PCISubsystemVendorID'
_ASSOC_IO_SLOT_DRC_INDEX = 'SlotDynamicReconfigurationConnectorIndex'
_ASSOC_IO_SLOT_DRC_NAME = 'SlotDynamicReconfigurationConnectorName'

# Constants for generic I/O Adapter
IO_ADPT_ROOT = 'IOAdapter'
RELATED_IO_ADPT_ROOT = 'RelatedIOAdapter'

_IO_SLOT_ORDER = (ASSOC_IO_SLOT_ROOT, _IO_SLOT_REQ)

_AIO_ORDER = (_ASSOC_IO_SLOT_BUS_GRP, _ASSOC_IO_SLOT_DESC,
              _ASSOC_IO_SLOT_FEAT_CODES, _ASSOC_IO_SLOT_PHYS_LOC,
              _ASSOC_IO_SLOT_ADPT_ID, _ASSOC_IO_SLOT_PCI_CLASS,
              _ASSOC_IO_SLOT_PCI_DEV_ID, _ASSOC_IO_SLOT_PCI_SUBSYS_DEV_ID,
              _ASSOC_IO_SLOT_PCI_MFG_ID, _ASSOC_IO_SLOT_PCI_REV_ID,
              _ASSOC_IO_SLOT_PCI_VENDOR_ID, _ASSOC_IO_SLOT_SUBSYS_VENDOR_ID,
              RELATED_IO_ADPT_ROOT, _ASSOC_IO_SLOT_DRC_INDEX,
              _ASSOC_IO_SLOT_DRC_NAME)

IO_PFC_ADPT_ROOT = 'PhysicalFibreChannelAdapter'
_IO_ADPT_ID = 'AdapterID'
_IO_ADPT_DESC = 'Description'
_IO_ADPT_DEV_NAME = 'DeviceName'
_IO_ADPT_DEV_TYPE = 'DeviceType'
_IO_ADPT_DYN_NAME = 'DynamicReconfigurationConnectorName'
_IO_ADPT_PHYS_LOC = 'PhysicalLocation'
_IO_ADPT_UDID = 'UniqueDeviceID'

PFC_PORT_WWPN = card.PFC_PORT_WWPN
PFC_PORTS_ROOT = card.PFC_PORTS_ROOT
PFC_PORT_ROOT = card.PFC_PORT_ROOT

IOAdapter = card.IOAdapter
PhysFCAdapter = card.PhysFCAdapter
PhysFCPort = card.PhysFCPort


class SharingMode(object):
    """Shared Processor sharing modes.

    Subset of LogicalPartitionProcessorSharingModeEnum.
    """
    CAPPED = 'capped'
    UNCAPPED = 'uncapped'
    ALL_VALUES = (CAPPED, UNCAPPED)


class DedicatedSharingMode(object):
    """Dedicated Processor sharing modes.

    Subset of LogicalPartitionProcessorSharingModeEnum.
    """
    SHARE_IDLE_PROCS = 'sre idle proces'
    SHARE_IDLE_PROCS_ACTIVE = 'sre idle procs active'
    SHARE_IDLE_PROCS_ALWAYS = 'sre idle procs always'
    KEEP_IDLE_PROCS = 'keep idle procs'
    ALL_VALUES = (SHARE_IDLE_PROCS, SHARE_IDLE_PROCS_ACTIVE,
                  SHARE_IDLE_PROCS_ALWAYS, KEEP_IDLE_PROCS)


class LPARState(object):
    """State of a given LPAR.

    From LogicalPartitionStateEnum.
    """
    ERROR = 'error'
    NOT_ACTIVATED = 'not activated'
    NOT_AVAILBLE = 'not available'
    OPEN_FIRMWARE = 'open firmware'
    RUNNING = 'running'
    SHUTTING_DOWN = 'shutting down'
    STARTING = 'starting'
    MIGRATING_NOT_ACTIVE = 'migrating not active'
    MIGRATING_RUNNING = 'migrating running'
    HARDWARE_DISCOVERY = 'hardware discovery'
    SUSPENDED = 'suspended'
    SUSPENDING = 'suspending'
    RESUMING = 'resuming'
    UNKNOWN = 'Unknown'


class LPARType(object):
    """Subset of LogicalPartitionEnvironmentEnum."""
    OS400 = 'OS400'
    AIXLINUX = 'AIX/Linux'
    VIOS = 'Virtual IO Server'


class LPARCompat(object):
    """LPAR compatibility modes.

    From LogicalPartitionProcessorCompatibilityModeEnum.
    """
    DEFAULT = 'default'
    POWER6 = 'POWER6'
    POWER6_PLUS = 'POWER6_Plus'
    POWER6_PLUS_ENHANCED = 'POWER6_Plus_Enhanced'
    POWER7 = 'POWER7'
    POWER8 = 'POWER8'
    POWER8_ENHANCED = 'POWER8_Enhanced'
    POWER9_BASE = 'POWER9_Base'
    POWER9 = 'POWER9'
    POWER9_ENHANCED = 'POWER9_Enhanced'
    ALL_VALUES = (DEFAULT, POWER6, POWER6_PLUS, POWER6_PLUS_ENHANCED, POWER7,
                  POWER8, POWER8_ENHANCED, POWER9_BASE, POWER9,
                  POWER9_ENHANCED)


class RMCState(object):
    """Various RMC States.

    From ResourceMonitoringControlStateEnum.
    """
    ACTIVE = 'active'
    INACTIVE = 'inactive'
    NONE = 'none'
    UNKNOWN = 'unknown'
    BUSY = 'busy'


class BootMode(object):
    """Mirror of PartitionBootMode.Enum.

    Valid values for LPAR.bootmode/VIOS.bootmode.

    Not to be confused with pypowervm.tasks.power.BootMode.

    Example usage:
        lwrap.bootmode = BootMode.NORM
        lwrap.update()
    """
    NORM = 'Normal'
    SMS = 'System_Management_Services'
    DD = 'Diagnostic_With_Default_Boot_List'
    DS = 'Diagnostic_With_Stored_Boot_List'
    OF = 'Open_Firmware'
    PBL = 'Petitboot'
    UNAVAILABLE = 'Unavailable'
    DEFAULT = 'Default'
    UNKNOWN = 'Unknown'
    ALL_VALUES = (NORM, SMS, DD, DS, OF, PBL, UNAVAILABLE, DEFAULT, UNKNOWN)


class KeylockPos(object):
    """Mirror of KeylockPosition.Enum.

    Valid values for LPAR.keylock_pos/VIOS.keylock_pos.

    Not to be confused with pypowervm.tasks.power.KeylockPos.

    Example usage:
        lwrap.keylock_pos = KeylockPos.MANUAL
        lwrap.update()
    """
    MANUAL = 'manual'
    NORMAL = 'normal'
    UNKNOWN = 'unknown'
    ALL_VALUES = (MANUAL, NORMAL, UNKNOWN)


class _DlparCapable(object):
    def _can_modify(self, dlpar_cap, cap_desc):
        """Checks to determine if the partition can be modified.

        :param dlpar_cap: The appropriate DLPAR attribute to validate.  Only
                          used if system is active.
        :param cap_desc: A translated string indicating the DLPAR capability.
        :return capable: True if HW can be added/removed.  False otherwise.
        :return reason: A translated message that will indicate why it was not
                        capable of modification.  If capable is True, the
                        reason will be None.
        """
        # First check is the not activated state
        if self.state == LPARState.NOT_ACTIVATED:
            return True, None
        if self.rmc_state != RMCState.ACTIVE and not self.is_mgmt_partition:
            return False, _('Partition does not have an active RMC '
                            'connection.')
        if not dlpar_cap:
            return False, _('Partition does not have an active DLPAR '
                            'capability for %s.') % cap_desc
        return True, None

    def can_modify_io(self):
        """Determines if a partition is capable of adding/removing I/O HW.

        :return capable: True if HW can be added/removed.  False otherwise.
        :return reason: A translated message that will indicate why it was not
                        capable of modification.  If capable is True, the
                        reason will be None.
        """
        return self._can_modify(self.capabilities.io_dlpar, _('I/O'))

    def can_modify_mem(self):
        """Determines if a partition is capable of adding/removing Memory.

        :return capable: True if memory can be added/removed.  False otherwise.
        :return reason: A translated message that will indicate why it was not
                        capable of modification.  If capable is True, the
                        reason will be None.
        """
        return self._can_modify(self.capabilities.mem_dlpar, _('Memory'))

    def can_modify_proc(self):
        """Determines if a partition is capable of adding/removing processors.

        :return capable: True if procs can be added/removed.  False otherwise.
        :return reason: A translated message that will indicate why it was not
                        capable of modification.  If capable is True, the
                        reason will be None.
        """
        return self._can_modify(self.capabilities.proc_dlpar, _('Processors'))


@ewrap.Wrapper.base_pvm_type
class BasePartition(ewrap.EntryWrapper, _DlparCapable):
    """Base class for Logical Partition (LPAR) & Virtual I/O Server (VIOS).

    This corresponds to the abstract BasePartition object in the PowerVM
    schema.
    """

    search_keys = dict(name=_BP_NAME, id=_BP_ID)

    @classmethod
    def _bld_base(cls, adapter, name, mem_cfg, proc_cfg, env, io_cfg=None):
        """Creates a BasePartition wrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param name: The name of the partition
        :param mem_cfg: The memory configuration wrapper
        :param proc_cfg: The processor configuration wrapper
        :param env: The type of partition, taken from LPARType
        :param io_cfg: The I/O configuration wrapper

        :returns: New BasePartition wrapper
        """

        partition = super(BasePartition, cls)._bld(adapter)
        if io_cfg:
            partition.io_config = io_cfg
        partition.mem_config = mem_cfg
        partition.name = name
        partition.proc_config = proc_cfg
        partition._env(env)

        return partition

    @property
    def state(self):
        """See LPARState.

        e.g. 'not activated', 'running', 'migrating running', etc.
        """
        return self._get_val_str(_BP_STATE)

    @property
    def name(self):
        """Short name (not ID, MTMS, or hostname)."""
        return self._get_val_str(_BP_NAME)

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

    @property
    def id(self):
        """Short ID (not UUID)."""
        return self._get_val_int(_BP_ID)

    def _id(self, value):
        """Set ID (not UUID). Only settable on creation of the partition."""
        self.set_parm_value(_BP_ID, int(value))

    @property
    def env(self):
        """See the LPARType Enumeration.

        Should usually be 'AIX/Linux' for LPAR.  'Virtual IO Server' should
        only happen for VIOS.
        """
        return self._get_val_str(_BP_TYPE)

    def _env(self, val):
        self.set_parm_value(_BP_TYPE, val)

    @property
    def partition_uuid(self):
        return self._get_val_str(_BP_UUID)

    @property
    def assoc_sys_uuid(self):
        """UUID of the associated ManagedSystem."""
        href = self.get_href(_BP_ASSOC_SYSTEM, one_result=True)
        return u.get_req_path_uuid(href, preserve_case=True) if href else None

    @property
    def rmc_state(self):
        """See RMCState.

        e.g. 'active', 'inactive', 'busy', etc.
        """
        return self._get_val_str(_BP_RMC_STATE)

    @property
    def rmc_ip(self):
        """IP address used for RMC communication, as a string."""
        return self._get_val_str(_BP_RMC_IP)

    @property
    def operating_system(self):
        """String representing the OS and version, or 'Unknown'."""
        return self._get_val_str(_BP_OS_VER, 'Unknown')

    @property
    def ref_code(self):
        return self._get_val_str(_BP_REF_CODE)

    @property
    def ref_code_full(self):
        return self._get_val_str(_BP_REF_CODE_FULL)

    @property
    def avail_priority(self):
        return self._get_val_int(_BP_AVAIL_PRIORITY, 0)

    @avail_priority.setter
    def avail_priority(self, value):
        self.set_parm_value(_BP_AVAIL_PRIORITY, value)

    @property
    def profile_sync(self):
        return self._get_val_str(_BP_PROFILE_SYNC, default='Off') == 'On'

    @profile_sync.setter
    def profile_sync(self, value):
        if type(value) == bool:
            value = 'On' if value else 'Off'
        self.set_parm_value(_BP_PROFILE_SYNC, value)

    @property
    def proc_compat_mode(self):
        """*Current* processor compatibility mode.

        See LPARCompat.  E.g. 'POWER7',
        'POWER7_Plus', 'POWER8', etc.
        """
        return self._get_val_str(_BP_CURRENT_PROC_MODE)

    @property
    def pending_proc_compat_mode(self):
        """Pending processor compatibility mode.

        See LPARCompat.  E.g. 'POWER7',
        'POWER7_Plus', 'POWER8', etc.
        """
        return self._get_val_str(_BP_PENDING_PROC_MODE)

    @proc_compat_mode.setter
    def proc_compat_mode(self, value):
        """Sets *PENDING* proc compat mode.

        Note that corresponding getter retrieves the *CURRENT* proc compat
        mode.
        """
        self.set_parm_value(_BP_PENDING_PROC_MODE, value)

    @property
    def is_mgmt_partition(self):
        """Is this the management partition?  Default False if field absent."""
        return self._get_val_bool(_BP_MGT_PARTITION)

    @property
    def is_service_partition(self):
        """Is this the service partition?  Default False if field absent."""
        return self._get_val_bool(_BP_SVC_PARTITION)

    @is_service_partition.setter
    def is_service_partition(self, value):
        """Set if this is the service partition."""
        self.set_parm_value(_BP_SVC_PARTITION, u.sanitize_bool_for_api(value))

    @property
    def keylock_pos(self):
        """Keylock position - see KeylockPos enumeration."""
        return self._get_val_str(_BP_KEYLOCK_POS)

    @keylock_pos.setter
    def keylock_pos(self, value):
        """Keylock position - see KeylockPos enumeration."""
        if value not in KeylockPos.ALL_VALUES:
            raise ValueError(_("Invalid KeylockPos '%s'.") % value)
        self.set_parm_value(_BP_KEYLOCK_POS, value)

    @property
    def bootmode(self):
        """Boot mode - one of the BootMode enum values."""
        return self._get_val_str(_BP_BOOT_MODE)

    @bootmode.setter
    def bootmode(self, val):
        if val not in BootMode.ALL_VALUES:
            raise ValueError(_("Invalid BootMode '%s'.") % val)
        self.set_parm_value(_BP_BOOT_MODE, val)

    @property
    def disable_secure_boot(self):
        return self._get_val_bool(_BP_DISABLE_SECURE_BOOT)

    @disable_secure_boot.setter
    def disable_secure_boot(self, value):
        self.set_parm_value(
            _BP_DISABLE_SECURE_BOOT, u.sanitize_bool_for_api(value),
            attrib=const.ATTR_KSV150)

    @property
    def pending_secure_boot(self):
        """The Pending Secure Boot Policy Value

        This parameter can be set while the LPAR is running. It will
        be the policy used when the LPAR is next booted.
        """
        return self._get_val_int(_BP_PENDING_SECURE_BOOT, default=0)

    @pending_secure_boot.setter
    def pending_secure_boot(self, value):
        self.set_parm_value(
            _BP_PENDING_SECURE_BOOT, value, attrib=const.ATTR_KSV180)

    @property
    def current_secure_boot(self):
        """The Secure Boot Policy Value

        The secure boot value will determine what level of enforcement will
        take place when the LPAR is booted. The following are the values
        and their interpretations:
          * 0: Secure boot disabled
          * 1: Secure boot enabled (log only)
          * 2: Secure boot enabled and enforced
          * 3-9: Secure boot enabled and enforced. Firmware or OS may
                 take additional measures.
        """
        return self._get_val_int(_BP_CURR_SECURE_BOOT, default=0)

    @property
    def allow_perf_data_collection(self):
        return self._get_val_bool(_BP_ALLOW_PERF_DATA_COLL)

    @allow_perf_data_collection.setter
    def allow_perf_data_collection(self, value):
        self.set_parm_value(_BP_ALLOW_PERF_DATA_COLL,
                            u.sanitize_bool_for_api(value))

    @property
    def capabilities(self):
        elem = self._find(_BP_CAPABILITIES)
        return PartitionCapabilities.wrap(elem)

    @property
    def io_config(self):
        """The Partition I/O Configuration."""
        elem = self._find(_BP_IO_CFG)
        return PartitionIOConfiguration.wrap(elem)

    @io_config.setter
    def io_config(self, io_cfg):
        """The Partition I/O Configuration for the LPAR."""
        elem = self._find_or_seed(_BP_IO_CFG)
        # TODO(efried): All instances of _find_or_seed + element.replace should
        # probably be inject instead
        self.element.replace(elem, io_cfg.element)

    @property
    def mem_config(self):
        """The Partition Memory Configuration for the LPAR."""
        elem = self._find(_BP_MEM_CFG)
        return PartitionMemoryConfiguration.wrap(elem)

    @mem_config.setter
    def mem_config(self, mem_cfg):
        """The Partition Memory Configuration for the LPAR."""
        elem = self._find_or_seed(_BP_MEM_CFG)
        self.element.replace(elem, mem_cfg.element)

    @property
    def proc_config(self):
        """The Partition Processor Configuration for the LPAR."""
        elem = self._find(_BP_PROC_CFG)
        return PartitionProcessorConfiguration.wrap(elem)

    @proc_config.setter
    def proc_config(self, proc_config):
        """The Partition Processor Configuration for the LPAR."""
        elem = self._find_or_seed(_BP_PROC_CFG)
        self.element.replace(elem, proc_config.element)

    @ewrap.Wrapper.xag_property(const.XAG.NVRAM)
    def nvram(self):
        return self._get_val_str(_BP_NVRAM)

    @nvram.setter
    def nvram(self, nvram):
        self.set_parm_value(_BP_NVRAM, nvram,
                            attrib=u.xag_attrs(const.XAG.NVRAM,
                                               base=const.ATTR_KSV130))

    @property
    def uptime(self):
        """Integer time since partition boot, in seconds."""
        return self._get_val_int(_BP_UPTIME)


@ewrap.ElementWrapper.pvm_type(_BP_CAPABILITIES, has_metadata=True,
                               child_order=_CAP_EL_ORDER)
class PartitionCapabilities(ewrap.ElementWrapper):
    """See LogicalPartitionCapabilities."""
    @property
    def io_dlpar(self):
        return self._get_val_bool(_CAP_DLPAR_IO_CAPABLE)

    @property
    def mem_dlpar(self):
        return self._get_val_bool(_CAP_DLPAR_MEM_CAPABLE)

    @property
    def proc_dlpar(self):
        return self._get_val_bool(_CAP_DLPAR_PROC_CAPABLE)


@ewrap.ElementWrapper.pvm_type(_BP_PROC_CFG, has_metadata=True,
                               child_order=_PC_EL_ORDER)
class PartitionProcessorConfiguration(ewrap.ElementWrapper):
    """Represents the partitions Processor Configuration.

    Comprised of either the shared or dedicated processor config.
    """

    @classmethod
    def bld_shared(cls, adapter, proc_unit, proc,
                   sharing_mode=SharingMode.UNCAPPED, uncapped_weight=128,
                   min_proc_unit=None, max_proc_unit=None, min_proc=None,
                   max_proc=None, proc_pool=0):
        """Builds a Shared Processor configuration wrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param proc_unit: Amount of desired proc units (float)
        :param proc: Number of virtual processors (int)
        :param sharing_mode: Sharing mode of the processors (uncapped)
        :param uncapped_weight: Uncapped weight of the processors (0-255)
        :param min_proc_unit: Minimum proc units, default to proc unit value
        :param max_proc_unit: Maximum proc units, default to proc unit value
        :param min_proc: Minimum processors, default to proc value
        :param max_proc: Maximum processors, default to proc value
        :param proc_pool: The shared processor pool for the lpar, defaults to 0
        :returns: Processor Config with shared processors

        """
        proc_cfg = super(PartitionProcessorConfiguration, cls)._bld(adapter)
        proc_cfg._has_dedicated(False)

        sproc = SharedProcessorConfiguration.bld(
            adapter, proc_unit, proc, uncapped_weight=uncapped_weight,
            min_proc_unit=min_proc_unit, max_proc_unit=max_proc_unit,
            min_proc=min_proc, max_proc=max_proc, proc_pool=proc_pool)

        proc_cfg._shared_proc_cfg(sproc)
        proc_cfg.sharing_mode = sharing_mode
        return proc_cfg

    @classmethod
    def bld_dedicated(cls, adapter, proc, min_proc=None, max_proc=None,
                      sharing_mode=DedicatedSharingMode.SHARE_IDLE_PROCS):

        """Builds a Dedicated Processor configuration wrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param proc: Number of virtual processors (int)
        :param min_proc: Minimum processors, default to proc value
        :param max_proc: Maximum processors, default to proc value
        :param sharing_mode: Sharing mode of the processors, 'sre idle proces'
        :returns: Processor Config with dedicated processors

        """

        proc_cfg = super(PartitionProcessorConfiguration, cls)._bld(adapter)

        dproc = DedicatedProcessorConfiguration.bld(
            adapter, proc, min_proc=min_proc, max_proc=max_proc)

        proc_cfg._dedicated_proc_cfg(dproc)
        proc_cfg._has_dedicated(True)
        proc_cfg.sharing_mode = sharing_mode
        return proc_cfg

    @property
    def has_dedicated(self):
        """Returns boolean True if dedicated, False if shared or not found."""
        return self._get_val_bool(_PC_HAS_DED_PROCS)

    def _has_dedicated(self, val):
        """Expects 'true' (string) for dedicated or 'false' for shared."""
        self.set_parm_value(_PC_HAS_DED_PROCS, u.sanitize_bool_for_api(val))

    @property
    def sharing_mode(self):
        return self._get_val_str(_PC_SHARING_MODE)

    @sharing_mode.setter
    def sharing_mode(self, value):
        self.set_parm_value(_PC_SHARING_MODE, value)

    @property
    def shared_proc_cfg(self):
        """Returns the Shared Processor Configuration."""
        return SharedProcessorConfiguration.wrap(
            self._find(_PC_SHR_PROC_CFG))

    def _shared_proc_cfg(self, spc):
        elem = self._find_or_seed(_PC_SHR_PROC_CFG)
        self.element.replace(elem, spc.element)

    @property
    def dedicated_proc_cfg(self):
        """Returns the Dedicated Processor Configuration."""
        return DedicatedProcessorConfiguration.wrap(
            self._find(_PC_DED_PROC_CFG))

    def _dedicated_proc_cfg(self, dpc):
        elem = self._find_or_seed(_PC_DED_PROC_CFG)
        self.element.replace(elem, dpc.element)


@ewrap.ElementWrapper.pvm_type(_BP_MEM_CFG, has_metadata=True,
                               child_order=_MEM_EL_ORDER)
class PartitionMemoryConfiguration(ewrap.ElementWrapper):
    """Represents the partitions Memory Configuration."""

    @classmethod
    def bld(cls, adapter, mem, min_mem=None, max_mem=None):
        """Creates the ParitionMemoryConfiguration.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param mem: The amount of memory for the partition in MB
        :param min_mem: The minimum amount of memory in MB. Defaults to
            the mem param
        :param max_mem: The maximum amount of memory in MB. Defaults to
            the mem param
        :returns: The memory configuration wrapper.
        """
        if min_mem is None:
            min_mem = mem
        if max_mem is None:
            max_mem = mem

        cfg = super(PartitionMemoryConfiguration, cls)._bld(adapter)
        cfg.desired = mem
        cfg.max = max_mem
        cfg.min = min_mem

        return cfg

    @property
    def current(self):
        return self._get_val_int(_MEM_CUR)

    @property
    def desired(self):
        return self._get_val_int(_MEM_DES)

    @desired.setter
    def desired(self, mem):
        self.set_parm_value(_MEM_DES, str(mem))

    @property
    def max(self):
        return self._get_val_int(_MEM_MAX)

    @max.setter
    def max(self, mem):
        self.set_parm_value(_MEM_MAX, str(mem))

    @property
    def min(self):
        return self._get_val_int(_MEM_MIN)

    @min.setter
    def min(self, mem):
        self.set_parm_value(_MEM_MIN, str(mem))

    @property
    def shared_enabled(self):
        # The default is None instead of False so that the caller
        # can know if the value is not set
        return self._get_val_bool(_MEM_SHARED_MEM_ENABLED, None)

    @property
    def ame_enabled(self):
        return self._get_val_bool(_MEM_AME_ENABLED)

    @property
    def exp_factor(self):
        """The Active Memory Expansion Factor

        The expansion factor represents the target memory multiplier.
        e.g. An LPAR with EF = 2 which has 4 GB of memory will have a target
        expansion memory of 8 GB.
        """
        return self._get_val_float(_MEM_EXP_FACTOR, default=0)

    @exp_factor.setter
    def exp_factor(self, exp_factor):
        """The Active Memory Expansion Factor

        :param exp_factor: The expansion factor value. Setting this to 0 will
                           turn/keep AME off. The valid values are
                           1.0 <= x <= 10.0 up to 2 decimal places.
        """
        self.set_parm_value(_MEM_EXP_FACTOR,
                            u.sanitize_float_for_api(exp_factor))

    @property
    def ppt_ratio(self):
        """The Physical Page Table Ratio

        The physical page table ratio represents the ratio of a VM's maximum
        memory to the size of its physical page table. The PPT is used by the
        platform to maintain the translation of the VM's physical to virtual
        memory addresses during mobility operations (i.e. LPM).

        The ppt_ratio is represented as 1:2^N where accepted values for N range
        from 6 to 12. If the ratio is 1:4096 for a VM with 64 GB of maximum
        memory, it would have a PPT of 16 MB (64 GB / 4096 = 16 MB).
        """
        return self._get_val_int(_MEM_PPT_RATIO)

    @ppt_ratio.setter
    def ppt_ratio(self, ppt_ratio):
        """The Physical Page Table Ratio

        :param ppt_ratio: The ppt ratio value.
        """
        self.set_parm_value(_MEM_PPT_RATIO, ppt_ratio)


@ewrap.ElementWrapper.pvm_type(_PC_SHR_PROC_CFG, has_metadata=True,
                               child_order=_SPC_EL_ORDER)
class SharedProcessorConfiguration(ewrap.ElementWrapper):
    """Represents the partition's Shared Processor Configuration."""

    @classmethod
    def bld(cls, adapter, proc_unit, proc, uncapped_weight=None,
            min_proc_unit=None, max_proc_unit=None,
            min_proc=None, max_proc=None, proc_pool=0):
        """Builds a Shared Processor configuration wrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param proc_unit: Amount of desired proc units (float)
        :param proc: Number of virtual processors (int)
        :param uncapped_weight: Uncapped weight of the processors, 0-255
        :param min_proc_unit: Minimum proc units, default to proc unit value
        :param max_proc_unit: Maximum proc units, default to proc unit value
        :param min_proc: Minimum processors, default to proc value
        :param max_proc: Maximum processors, default to proc value
        :param proc_pool: The shared processor pool for the lpar, defaults to 0
        :returns: Processor Config with shared processors

        """

        # Set defaults if not specified
        if min_proc_unit is None:
            min_proc_unit = proc_unit
        if max_proc_unit is None:
            max_proc_unit = proc_unit
        if min_proc is None:
            min_proc = proc
        if max_proc is None:
            max_proc = proc

        sproc = super(SharedProcessorConfiguration, cls)._bld(adapter)

        sproc.desired_units = proc_unit
        sproc.desired_virtual = proc
        sproc.max_units = max_proc_unit
        sproc.max_virtual = max_proc
        sproc.min_units = min_proc_unit
        sproc.min_virtual = min_proc
        sproc.pool_id = proc_pool
        if uncapped_weight is not None:
            sproc.uncapped_weight = uncapped_weight

        return sproc

    @property
    def desired_units(self):
        return self._get_val_float(_SPC_DES_PROC_UNIT)

    @desired_units.setter
    def desired_units(self, val):
        self.set_parm_value(_SPC_DES_PROC_UNIT, u.sanitize_float_for_api(val))

    @property
    def max_units(self):
        return self._get_val_float(_SPC_MAX_PROC_UNIT)

    @max_units.setter
    def max_units(self, val):
        self.set_parm_value(_SPC_MAX_PROC_UNIT, u.sanitize_float_for_api(val))

    @property
    def min_units(self):
        return self._get_val_float(_SPC_MIN_PROC_UNIT)

    @min_units.setter
    def min_units(self, val):
        self.set_parm_value(_SPC_MIN_PROC_UNIT, u.sanitize_float_for_api(val))

    @property
    def desired_virtual(self):
        return self._get_val_int(_SPC_DES_VIRT_PROC)

    @desired_virtual.setter
    def desired_virtual(self, val):
        self.set_parm_value(_SPC_DES_VIRT_PROC, val)

    @property
    def max_virtual(self):
        return self._get_val_int(_SPC_MAX_VIRT_PROC)

    @max_virtual.setter
    def max_virtual(self, val):
        self.set_parm_value(_SPC_MAX_VIRT_PROC, val)

    @property
    def min_virtual(self):
        return self._get_val_int(_SPC_MIN_VIRT_PROC)

    @min_virtual.setter
    def min_virtual(self, val):
        self.set_parm_value(_SPC_MIN_VIRT_PROC, val)

    @property
    def pool_id(self):
        return self._get_val_int(_SPC_SHARED_PROC_POOL_ID, 0)

    @pool_id.setter
    def pool_id(self, val):
        self.set_parm_value(_SPC_SHARED_PROC_POOL_ID, val)

    @property
    def uncapped_weight(self):
        return self._get_val_int(_SPC_UNCAPPED_WEIGHT, 0)

    @uncapped_weight.setter
    def uncapped_weight(self, val):
        self.set_parm_value(_SPC_UNCAPPED_WEIGHT, val)


@ewrap.ElementWrapper.pvm_type(_PC_DED_PROC_CFG, has_metadata=True)
class DedicatedProcessorConfiguration(ewrap.ElementWrapper):
    """Represents the partition's Dedicated Processor Configuration."""

    @classmethod
    def bld(cls, adapter, proc, min_proc=None, max_proc=None):
        """Builds a Dedicated Processor configuration wrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param proc: Number of virtual processors (int)
        :param min_proc: Minimum processors, default to proc value
        :param max_proc: Maximum processors, default to proc value
        :returns: Processor Config with dedicated processors

        """

        # Set defaults if not specified
        if min_proc is None:
            min_proc = proc
        if max_proc is None:
            max_proc = proc

        dproc = super(DedicatedProcessorConfiguration, cls)._bld(adapter)

        dproc.desired = proc
        dproc.max = max_proc
        dproc.min = min_proc

        return dproc

    @property
    def desired(self):
        return self._get_val_int(_DPC_DES_PROCS, 0)

    @desired.setter
    def desired(self, value):
        self.set_parm_value(_DPC_DES_PROCS, value)

    @property
    def max(self):
        return self._get_val_int(_DPC_MAX_PROCS, 0)

    @max.setter
    def max(self, value):
        self.set_parm_value(_DPC_MAX_PROCS, value)

    @property
    def min(self):
        return self._get_val_int(_DPC_MIN_PROCS, 0)

    @min.setter
    def min(self, value):
        self.set_parm_value(_DPC_MIN_PROCS, value)


@ewrap.ElementWrapper.pvm_type('PartitionIOConfiguration', has_metadata=True)
class PartitionIOConfiguration(ewrap.ElementWrapper):
    """Represents the partitions Dedicated IO Configuration.

    Comprised of I/O Slots.  There are two types of IO slots.  Those dedicated
    to physical hardware (io_slots) and those that get used by virtual
    hardware.
    """

    @classmethod
    def bld(cls, adapter, max_virt_slots, io_slots=None):
        """Builds a Partition IO configuration wrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param max_virt_slots: Number of virtual slots (int)
        :param io_slots: I/O slots to assign to the LPAR (list of IOSlot).
        :returns: Partition IO configuration wrapper

        """
        cfg = super(PartitionIOConfiguration, cls)._bld(adapter)
        cfg.max_virtual_slots = max_virt_slots
        if io_slots is not None:
            cfg.io_slots = io_slots

        return cfg

    @property
    def max_virtual_slots(self):
        """The maximum number of virtual slots.

        Slots are used for every VirtualScsiServerAdapter, TrunkAdapter, etc...
        """
        return self._get_val_int(_IO_MAX_SLOTS)

    @max_virtual_slots.setter
    def max_virtual_slots(self, value):
        self.set_parm_value(_IO_MAX_SLOTS, value)

    @property
    def io_slots(self):
        """The physical I/O Slots.

        Each slot will have hardware associated with it.
        """
        es = ewrap.WrapperElemList(self._find_or_seed(IO_SLOTS_ROOT), IOSlot)
        return es

    @io_slots.setter
    def io_slots(self, val):
        self.replace_list(IO_SLOTS_ROOT, val)

    @property
    def tagged_io(self):
        """IBMi only - tagged I/O attributes of the I/O configuration."""
        tio = self._find(_IO_TIO)
        return TaggedIO.wrap(tio) if tio else None

    @tagged_io.setter
    def tagged_io(self, tio):
        self.inject(tio.element)


@ewrap.ElementWrapper.pvm_type('TaggedIO', has_metadata=True,
                               child_order=_TIO_EL_ORDER)
class TaggedIO(ewrap.ElementWrapper):
    """IBMi only - tagged I/O attributes of the I/O configuration."""

    @classmethod
    def bld(cls, adapter, load_src='0', console='HMC', alt_load_src='NONE'):
        """Builds a Partition TaggedIO wrapper.

        :param adapter: A pypowervm.adapter.Adapter (for traits, etc.)
        :param load_src: Load source to use
        :param console: Console to use for IBMi
        :param alt_load_src: Alternate load source to use
        :returns: Partition TaggedIO wrapper

        """
        cfg = super(TaggedIO, cls)._bld(adapter)
        cfg.load_src = load_src
        cfg.console = console
        cfg.alt_load_src = alt_load_src
        return cfg

    @property
    def alt_load_src(self):
        """Value may or may not be an integer - always returned as string."""
        return self._get_val_str(_TIO_ALT_LOAD_SRC)

    @alt_load_src.setter
    def alt_load_src(self, value):
        self.set_parm_value(_TIO_ALT_LOAD_SRC, value)

    @property
    def console(self):
        """Value may or may not be an integer - always returned as string."""
        return self._get_val_str(_TIO_CONSOLE)

    @console.setter
    def console(self, value):
        self.set_parm_value(_TIO_CONSOLE, value)

    @property
    def load_src(self):
        """Value may or may not be an integer - always returned as string."""
        return self._get_val_str(_TIO_LOAD_SRC)

    @load_src.setter
    def load_src(self, value):
        self.set_parm_value(_TIO_LOAD_SRC, value)


@ewrap.ElementWrapper.pvm_type('ProfileIOSlot', has_metadata=True,
                               child_order=_IO_SLOT_ORDER)
class IOSlot(ewrap.ElementWrapper):
    """An I/O Slot represents a device bus on the system.

    It may contain a piece of hardware within it.
    """
    @classmethod
    def bld(cls, adapter, bus_grp_required, drc_index, required=False):
        """Build a new IOSlot wrapper with all required parameters.

        :returns: A new IOSlot wrapper.
        """
        new_slot = super(IOSlot, cls)._bld(adapter)

        new_slot.required = required

        # Build out the AssociatedIOSlot
        assoc_io_slot = cls.AssociatedIOSlot._bld_new(adapter,
                                                      bus_grp_required,
                                                      drc_index)

        # Inject the AssociatedIOSlot into this wrapper
        new_slot.inject(assoc_io_slot.element)

        return new_slot

    @ewrap.ElementWrapper.pvm_type(ASSOC_IO_SLOT_ROOT, has_metadata=True,
                                   child_order=_AIO_ORDER)
    class AssociatedIOSlot(ewrap.ElementWrapper):
        """Internal class.  Hides the nested AssociatedIOSlot from parent.

        Every ProfileIOSlot contains one AssociatedIOSlot.  If both are
        exposed at the API level, the user would have to go from:
         - lpar -> partition i/o config -> i/o slot -> associated i/o slot ->
           i/o data

        Since every i/o slot has a single Associated I/O Slot (unless said
        I/O slot has no associated I/O), then we can just hide this from
        the user.

        We still keep the structure internally, but makes the API easier to
        consume.
        """
        @classmethod
        def _bld_new(cls, adapter, bus_grp_required, drc_index):
            """Build a new AssociatedIOSlot wrapper.

            This will not typically be called outside of the IOSlot.bld
            class method.

            :returns: A new AssociatedIOSlot wrapper.
            """
            new_slot = super(IOSlot.AssociatedIOSlot, cls)._bld(adapter)
            new_slot._bus_grp_required(bus_grp_required)
            new_slot._drc_index(drc_index)

            return new_slot

        @property
        def bus_grp_required(self):
            return self._get_val_bool(_ASSOC_IO_SLOT_BUS_GRP)

        def _bus_grp_required(self, val):
            self.set_parm_value(_ASSOC_IO_SLOT_BUS_GRP,
                                u.sanitize_bool_for_api(val))

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

        @property
        def phys_loc(self):
            return self._get_val_str(_ASSOC_IO_SLOT_PHYS_LOC)

        @property
        def pc_adpt_id(self):
            return self._get_val_int(_ASSOC_IO_SLOT_ADPT_ID)

        @property
        def pci_class(self):
            return self._get_val_int(_ASSOC_IO_SLOT_PCI_CLASS)

        @property
        def pci_dev_id(self):
            return self._get_val_int(_ASSOC_IO_SLOT_PCI_DEV_ID)

        @property
        def pci_subsys_dev_id(self):
            return self._get_val_int(_ASSOC_IO_SLOT_PCI_SUBSYS_DEV_ID)

        @property
        def pci_mfg_id(self):
            return self._get_val_int(_ASSOC_IO_SLOT_PCI_MFG_ID)

        @property
        def pci_rev_id(self):
            return self._get_val_int(_ASSOC_IO_SLOT_PCI_REV_ID)

        @property
        def pci_vendor_id(self):
            return self._get_val_int(_ASSOC_IO_SLOT_PCI_VENDOR_ID)

        @property
        def pci_subsys_vendor_id(self):
            return self._get_val_int(_ASSOC_IO_SLOT_SUBSYS_VENDOR_ID)

        @property
        def drc_index(self):
            return self._get_val_int(_ASSOC_IO_SLOT_DRC_INDEX)

        def _drc_index(self, val):
            self.set_parm_value(_ASSOC_IO_SLOT_DRC_INDEX, val)

        @property
        def drc_name(self):
            return self._get_val_str(_ASSOC_IO_SLOT_DRC_NAME)

        @property
        def io_adapter(self):
            """Jumps over the 'Related IO Adapter' element direct to the I/O.

            This is another area where the schema has a two step jump that the
            API can avoid.  This method skips over the RelatedIOAdapter
            and jumps right to the IO Adapter.

            Return values are either the generic IOAdapter or the
            PhysFCAdapter.
            """
            # The child can be either an IO Adapter or a PhysFCAdapter.
            # Need to check for both...
            io_adpt_root = self._find(
                u.xpath(RELATED_IO_ADPT_ROOT, IOAdapter.schema_type))
            if io_adpt_root is not None:
                return IOAdapter.wrap(io_adpt_root)

            # Didn't have the generic...check for non-generic.
            io_adpt_root = self._find(
                u.xpath(RELATED_IO_ADPT_ROOT, PhysFCAdapter.schema_type))
            if io_adpt_root is not None:
                return PhysFCAdapter.wrap(io_adpt_root)

            return None

    @property
    def required(self):
        return self._get_val_bool(_IO_SLOT_REQ)

    @required.setter
    def required(self, val):
        self.set_parm_value(_IO_SLOT_REQ, u.sanitize_bool_for_api(val))

    def __get_prop(self, func):
        """Thin wrapper to get the Associated I/O Slot and get a property."""
        elem = self._find(ASSOC_IO_SLOT_ROOT)
        if elem is None:
            return None

        # Build the Associated IO Slot, find the function and execute it.
        assoc_io_slot = self.AssociatedIOSlot.wrap(elem)
        return getattr(assoc_io_slot, func)

    @property
    def bus_grp_required(self):
        return self.__get_prop('bus_grp_required')

    @property
    def description(self):
        return self.__get_prop('description')

    @property
    def phys_loc(self):
        return self.__get_prop('phys_loc')

    @property
    def pc_adpt_id(self):
        return self.__get_prop('pc_adpt_id')

    @property
    def pci_class(self):
        return self.__get_prop('pci_class')

    @property
    def pci_dev_id(self):
        return self.__get_prop('pci_dev_id')

    @property
    def pci_subsys_dev_id(self):
        return self.__get_prop('pci_subsys_dev_id')

    @property
    def pci_mfg_id(self):
        return self.__get_prop('pci_mfg_id')

    @property
    def pci_rev_id(self):
        return self.__get_prop('pci_rev_id')

    @property
    def pci_vendor_id(self):
        return self.__get_prop('pci_vendor_id')

    @property
    def pci_subsys_vendor_id(self):
        return self.__get_prop('pci_subsys_vendor_id')

    @property
    def drc_index(self):
        return self.__get_prop('drc_index')

    @property
    def drc_name(self):
        return self.__get_prop('drc_name')

    @property
    def adapter(self):
        """DEPRECATED - use 'io_adapter' method instead."""
        import warnings
        warnings.warn(
            _("IOSlot.adapter is deprecated!  Use IOSlot.io_adapter instead."),
            DeprecationWarning)
        return self.io_adapter

    @property
    def io_adapter(self):
        """Returns the physical I/O Adapter for this slot.

        This will be one of two types.  Either a generic I/O Adapter or
        a Physical Fibre Channel Adapter (PhysFCAdapter).
        """
        return self.__get_prop('io_adapter')