AzStackHci.EnvironmentChecker

1.2100.2784.504

AzStackHciHardware/AzStackHci.Hardware.Helpers.psm1

Import-LocalizedData -BindingVariable lhwTxt -FileName AzStackHci.Hardware.Strings.psd1

function Test-Processor
{
    <#
    .SYNOPSIS
        Test CPU
    .DESCRIPTION
        Test CPU
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_Processor'
                Property  = '*'
            }
            $cimData = @(Get-CimInstance @cimParams)
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }
        $cimTest = Test-CimData -Data $remoteOutput -ClassName Processor -Severity WARNING
        $cimData = $remoteOutput.cimData

        $PropertyResult = @()
        $PropertySyncResult = @()
        $matchProperty = @(
            'Caption'
            'Family'
            'Manufacturer'
            'MaxClockSpeed'
            'NumberOfCores'
            'NumberOfEnabledCore'
            'NumberOfLogicalProcessors'
            'ThreadCount'
        )

        $warningDesiredPropertyValue = @{
            AddressWidth                            = @{ value = 64; hint = '64-bit' }
            Architecture                            = @{ value = 9; hint = '64-bit' } # x64
            Availability                            = @{ value = 3; hint = 'Running/Full Power' } # Running/Full Power
            CpuStatus                               = @{ value = 1; hint = 'CPU Enabled' } # CPU Enabled
            DataWidth                               = @{ value = 64; hint = '64-bit' } # x64
            ProcessorType                           = @{ value = 3; hint = 'Central Processor' } # Central Processor
            Status                                  = @{ value = 'OK'; hint = 'OK' }
        }

        $criticalDesiredPropertyValue = @{
            SecondLevelAddressTranslationExtensions = @{ value = $true; hint = 'Virtualization Support' }
            VirtualizationFirmwareEnabled           = @{ value = $true; hint = 'Virtualization Support' }
            VMMonitorModeExtensions                 = @{ value = $true; hint = 'Virtualization Support' }
        }

        # if Hypervisorpresent is all true, SecondLevelAddressTranslationExtensions, VirtualizationFirmwareEnabled, VMMonitorModeExtensions should not be tested
        $CheckHyperVisor = IsHypervisorPresent -PsSession $PsSession
        $hypervisorDtl = ($lhwTxt.HypervisorPresent -f (($CheckHyperVisor  | ForEach-Object {"{0}:{1}" -f $_.Name, $_.HypervisorPresent }) -join ','))
        if (($CheckHyperVisor | Select-Object -ExpandProperty HypervisorPresent) -notcontains $false)
        {
            Log-Info $hypervisorDtl
            Remove-Variable -Name criticalDesiredPropertyValue
        }
        else
        {
            Log-Info $hypervisorDtl -Type CRITICAL
        }
        Log-CimData -cimData $cimData -Properties $matchProperty,$warningDesiredPropertyValue,$criticalDesiredPropertyValue
        $instanceIdStr = 'Write-Output "Machine: $($instance.SystemName), Class: $ClassName, Instance: $($instance.DeviceId)"'
        # Check property sync for nodes individually
        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            Log-Info -Message ($lhwTxt.ProcessorCount -f $systemName, $sData.Count)
            $PropertyResult += Test-DesiredProperty -CimData $sData -desiredPropertyValue $warningDesiredPropertyValue -InstanceIdStr $InstanceIdStr -ValidatorName Hardware -Severity Warning
            if ($criticalDesiredPropertyValue)
            {
                $PropertyResult += Test-DesiredProperty -CimData $sData -desiredPropertyValue $criticalDesiredPropertyValue -InstanceIdStr $InstanceIdStr -ValidatorName Hardware -Severity CRITICAL
            }
            $PropertySyncResult += Test-PropertySync -CimData $sData -MatchProperty $matchProperty -ValidatorName Hardware -Severity Warning
        }
        # Check property sync for all nodes as well
        $PropertySyncResult += Test-PropertySync -CimData $cimData -MatchProperty $matchProperty -ValidatorName Hardware -Severity Warning
        return @($PropertyResult + $PropertySyncResult + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function IsHypervisorPresent
{
    <#
    .SYNOPSIS
        Retrieves HypervisorPresent property from Win32_ComputerSystem
    #>
    [cmdletbinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_ComputerSystem'
                Property  = 'HypervisorPresent'
            }
            $cimData = @(Get-CimInstance @cimParams)
            return $cimData
        }
        $cimData = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }
        Log-CimData -cimData $cimData -Properties HypervisorPresent
        return $cimData
    }
    catch
    {
        throw $_
    }
}

function Test-NetAdapter
{
    <#
    .SYNOPSIS
        Test Network Adapter
    .DESCRIPTION
        Test Network Adapter
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimData = @(Get-NetAdapter -Physical | Where-Object { $_.NdisMedium -eq 0 -and $_.Status -eq 'Up' -and $_.NdisPhysicalMedium -eq 14 -and $_.PnPDeviceID -notlike 'USB\*'})
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $cimTest = Test-CimData -Data $remoteOutput -ClassName NetAdapter -Severity CRITICAL
        $cimData = $remoteOutput.cimData

        $PropertyResult = @()
        $PropertySyncResult = @()
        $GroupResult = @()
        $CountResult = @()

        # Blocking properties
        $criticalMatchProperty = @(
            'DriverDate'
            'DriverDescription'
            'DriverMajorNdisVersion'
            'DriverMinorNdisVersion'
            'DriverProvider'
            'DriverVersionString'
            'MajorDriverVersion'
            'MinorDriverVersion'
        )

        # non-block warning properties
        $warningMatchProperty = @(
            'ActiveMaximumTransmissionUnit'
            'ReceiveLinkSpeed'
            'Speed'
            'TransmitLinkSpeed'
            'VlanID'
            'MtuSize'
        )

        $desiredPropertyValue = @{
            AdminLocked                                      = $false
            ConnectorPresent                                 = $true
            EndpointInterface                                = $false
            ErrorDescription                                 = $null
            FullDuplex                                       = $true
            HardwareInterface                                = $true
            Hidden                                           = $false
            IMFilter                                         = $false
            InterfaceAdminStatus                             = @{ value = 1; hint = 'Up' } # Up
            InterfaceOperationalStatus                       = @{ value = 1; hint = 'Up' } # Up
            iSCSIInterface                                   = $false
            LastErrorCode                                    = $null
            MediaConnectState                                = @{ value = 1; hint = 'Connected' } # Connected
            MediaDuplexState                                 = 2
            NdisMedium                                       = @{ value = 0; hint = '802.3' } # 802.3
            NdisPhysicalMedium                               = @{ value = 14; hint = '802.3' } # 802.3
            OperationalStatusDownDefaultPortNotAuthenticated = $false
            OperationalStatusDownInterfacePaused             = $false
            OperationalStatusDownLowPowerState               = $false
            OperationalStatusDownMediaDisconnected           = $false
            #PromiscuousMode = $false
            State                                            = @{ value = 2; hint = 'Started' } # 802.3 # Started
            #Status = 'Up'
            Virtual                                          = $false
        }

        $groupProperty = @(
            'DriverDescription'
        )

        Log-CimData -cimData $cimData -Properties $desiredPropertyValue,$warningMatchProperty,$criticalMatchProperty

        $minimum = 1
        $instanceIdStr = 'Write-Output "Machine: $($instance.SystemName), ClassName: $ClassName, Instance: $($instance.Name), Description: $($instance.InterfaceDescription), Address: $($instance.PermanentAddress)"'
        # Check property sync for nodes individually
        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            Log-Info -Message ($lhwTxt.NicCount -f $systemName, $sData.Count)
            # Make sure each system has the requisite number of Network Adapters
            $PropertyResult += Test-DesiredProperty -CimData $sData -desiredPropertyValue $desiredPropertyValue -InstanceIdStr $InstanceIdStr -ValidatorName Hardware -Severity Critical
            $CountResult += Test-Count -CimData $sData -minimum $minimum -ValidatorName 'Hardware' -Severity Critical
        }

        # Check property sync for all nodes as well
        $GroupResult += Test-GroupProperty -CimData $cimData -GroupProperty $groupProperty -MatchProperty $warningMatchProperty -ValidatorName Hardware -Severity Warning
        $GroupResult += Test-GroupProperty -CimData $cimData -GroupProperty $groupProperty -MatchProperty $criticalMatchProperty -ValidatorName Hardware -Severity Critical
        $InstanceCount += Test-InstanceCount -CimData $cimData -Severity Critical -ValidatorName 'Hardware'
        $InstanceCountByGroup += Test-InstanceCountByGroup -CimData $cimData -ValidatorName 'Hardware' -GroupProperty $groupProperty -Severity Critical
        # Finally, the all properties from the $matchProperty array have to be compared for all instances across all nodes.
        return @($PropertyResult + $GroupResult + $CountResult + $InstanceCountByGroup + $InstanceCount + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function Test-MemoryCapacity
{
    <#
    .SYNOPSIS
        Test Memory
    .DESCRIPTION
        Test Memory
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        if ((Get-WmiObject -Class Win32_ComputerSystem).Model -eq "Virtual Machine")
        {
            $environmentType = "Virtual"
            $minimumMemory = 24GB
        } else {
            $environmentType = "Physical"
            $minimumMemory = 32GB
        }
        Log-Info -Message ($lhwTxt.MemoryCapacityRequirement -f $minimumMemory, $environmentType)
        $instanceResults = @()
        $AdditionalData = @()
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_PhysicalMemory'
                Property  = '*'
            }
            $cimData = @(Get-CimInstance @cimParams)
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $cimTest = Test-CimData -Data $remoteOutput -ClassName PhysicalMemory -Severity WARNING
        $cimData = $remoteOutput.cimData
        Log-CimData -cimData $cimData -Properties Capacity

        # Check property sync for nodes individually
        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        $totalMemoryLocalNode = $cimData | Where-Object { $_.CimSystemProperties.ServerName -like "$($ENV:COMPUTERNAME)*"} | Measure-Object -Property Capacity -Sum | Select-Object -ExpandProperty Sum
        $instanceResults += foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            $instanceId = "Machine: $($Instance.CimSystemProperties.ServerName), Class: $ClassName, Instance: All"
            $totalMemory = $sData | Measure-Object -Property Capacity -Sum
            $dtl = $lhwTxt.MemoryCapacity -f $systemName, $totalMemory.Sum, $minimumMemory, $totalMemoryLocalNode
            if ($totalMemory.Sum -lt $minimumMemory -or $totalMemory.Sum -lt $totalMemoryLocalNode)
            {
                $Status = 'FAILURE'
                Log-Info $dtl -Type Warning
            }
            else
            {
                $Status = 'SUCCESS'
                Log-Info $dtl
            }

            $params = @{
                Name               = 'AzStackHci_Hardware_Test_MemoryCapacity'
                Title              = 'Test Memory Capacity'
                DisplayName        = "Test Memory Capacity $systemName"
                Severity           = 'WARNING'
                Description        = 'Checking Memory Capacity'
                Tags               = @{}
                Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'Memory'
                Timestamp          = [datetime]::UtcNow
                Status             =  $status
                AdditionalData     = @{
                    Source    = 'Memory Capacity'
                    Resource  = $totalMemory.Sum
                    Detail    = $dtl
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            New-AzStackHciResultObject @params
        }
        return ($instanceResults + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function Test-MemoryProperties
{
    <#
    .SYNOPSIS
        Test Memory
    .DESCRIPTION
        Test Memory
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_PhysicalMemory'
                Property  = '*'
            }
            $cimData = @(Get-CimInstance @cimParams)
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $cimTest = Test-CimData -Data $remoteOutput -ClassName PhysicalMemory -Severity WARNING
        $cimData = $remoteOutput.cimData

        $PropertyResult = @()
        $PropertySyncResult = @()
        $matchProperty = @(
            'ConfiguredClockSpeed'
            'ConfiguredVoltage'
            'MaxVoltage'
            'MemoryType'
            'SMBIOSMemoryType'
            'Speed'
            'TotalWidth'
            'TypeDetail'
        )

        $desiredPropertyValue = @{
            DataWidth  = @{ value = 64; hint = '64-bit' } # x64
            FormFactor = @{ value = 8; hint = 'DIMM' } # DIMM
        }
        Log-CimData -cimData $cimData -Properties $desiredPropertyValue,$matchProperty
        # Check property sync for nodes individually
        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            $instanceIdStr = 'Write-Output "Machine: $($Instance.CimSystemProperties.ServerName), Class: $ClassName, Instance: $($instance.DeviceLocator), Tag: $($instance.Tag)"'
            $PropertyResult += Test-DesiredProperty -CimData $sData -desiredPropertyValue $desiredPropertyValue -InstanceIdStr $InstanceIdStr -ValidatorName Hardware -Severity Warning
            $PropertySyncResult += Test-PropertySync -CimData $sData -MatchProperty $matchProperty -ValidatorName Hardware -Severity Warning
        }
        # Check property sync for all nodes as well
        $PropertySyncResult += Test-PropertySync -CimData $cimData -MatchProperty $matchProperty -ValidatorName Hardware -Severity Warning
        return @($PropertyResult + $PropertySyncResult + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function Test-Gpu
{
    <#
    .SYNOPSIS
        Test Gpu
    .DESCRIPTION
        Test Gpu
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_VideoController'
                Property  = '*'
            }
            $cimData = @(Get-CimInstance @cimParams)
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $cimTest = Test-CimData -Data $remoteOutput -ClassName VideoController -Severity WARNING
        $cimData = $remoteOutput.cimData

        $PropertyResult = @()
        $GroupResult = @()
        $InstanceCount = @()
        $InstanceCountByGroup = @()

        $matchProperty = @(
            'AdapterRam'
            'Name'
            'DriverDate'
            'DriverVersion'
            'VideoMemoryType'
            'VideoProcessor'
        )

        $desiredPropertyValue = @{
            ConfigManagerErrorCode = @{ value = 0; hint = 'The device is working properly' } # The device is working properly
            Status                 = 'OK'
        }

        $groupProperty = @(
            'Name'
        )

        Log-CimData -cimData $cimData -Properties $desiredPropertyValue,$matchProperty
        # Check property sync for nodes individually
        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            $totalGpuRam = $sData | Measure-Object -Property AdapterRam -Sum
            Log-Info -Message ($lhwTxt.TotalGPUMem -f $systemName, $sData.Count, ($totalGpuRam.Sum / 1GB))
            $instanceIdStr = 'Write-Output "Machine: $($instance.SystemName), Class: $ClassName, Instance: $($instance.DeviceID), Name: $($instance.Name)"'
            $PropertyResult += Test-DesiredProperty -CimData $sData -desiredPropertyValue $desiredPropertyValue -InstanceIdStr $InstanceIdStr -ValidatorName Hardware -Severity Warning
        }
        # Check property sync for all nodes as well
        $GroupResult += Test-GroupProperty -CimData $cimData -GroupProperty $groupProperty -MatchProperty $MatchProperty -ValidatorName Hardware -Severity Warning
        $InstanceCount += Test-InstanceCount -CimData $cimData -Severity Warning -ValidatorName 'Hardware'
        $InstanceCountByGroup += Test-InstanceCountByGroup -CimData $cimData -ValidatorName 'Hardware' -GroupProperty $groupProperty -Severity Warning
        return @($GroupResult + $InstanceCount + $InstanceCountByGroup + $PropertyResult + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function Test-Baseboard
{
    <#
    .SYNOPSIS
        Test Baseboard
    .DESCRIPTION
        Test Baseboard
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_Bios'
                Property  = '*'
            }
            $cimData = @(Get-CimInstance @cimParams)
             return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $cimTest = Test-CimData -Data $remoteOutput -ClassName Bios -Severity WARNING
        $cimData = $remoteOutput.cimData

        $PropertyResult = @()
        $PropertySyncResult = @()
        $matchProperty = @(
            #'BiosVersion' # this property is a string array and non-trivial to compare
            'Caption'
            'Description'
            'EmbeddedControllerMajorVersion'
            'EmbeddedControllerMinorVersion'
            'Manufacturer'
            'Name'
            'ReleaseDate'
            'SMBIOSBIOSVersion'
            'SMBIOSMajorVersion'
            'SMBIOSMinorVersion'
            'SoftwareElementId'
            'SystemBiosMajorVersion'
            'SystemBiosMinorVersion'
            'Version'
        )

        $desiredPropertyValue = @{
            SMBIOSPresent        = $true
            SoftwareElementState = @{ value = 3; hint = 'Running' } # Running
            Status               = 'OK'
        }

        Log-CimData -cimData $cimData -Properties $desiredPropertyValue,$matchProperty

        # Check property sync for nodes individually
        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            Log-Info -Message ($lhwTxt.TestBaseboard -f $systemName, $sData.Name, $sData.SerialNumber)
            $instanceIdStr = 'Write-Output "Machine: $($instance.CimSystemProperties.ServerName), Class: $ClassName, Serial: $($instance.SerialNumber)"'
            $PropertyResult += Test-DesiredProperty -CimData $sData -desiredPropertyValue $desiredPropertyValue -InstanceIdStr $InstanceIdStr -ValidatorName Hardware -Severity Warning
            $PropertySyncResult += Test-PropertySync -CimData $sData -MatchProperty $matchProperty -ValidatorName Hardware -Severity Warning
        }
        # Check property sync for all nodes as well
        $PropertySyncResult += Test-PropertySync -CimData $cimData -MatchProperty $matchProperty -ValidatorName Hardware  -Severity Warning
        return @($PropertyResult + $PropertySyncResult + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function Test-Model
{
    <#
    .SYNOPSIS
        Test Hardware Model is the same
    .DESCRIPTION
        Test Hardware Model is the same
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_ComputerSystem'
                Property  = '*'
            }
            $cimData = @(Get-CimInstance @cimParams)
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $cimTest = Test-CimData -Data $remoteOutput -ClassName ComputerSystem -Severity CRITICAL
        $cimData = $remoteOutput.cimData

        $PropertySyncResult = @()
        $matchProperty = @(
            'Manufacturer'
            'Model'
        )
        Log-CimData -cimData $cimData -Properties $matchProperty

        # Check property sync for nodes individually
        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            Log-Info -Message ($lhwTxt.TestModel -f $systemName, $sData.Manufacturer, $sData.Model)
            $PropertySyncResult += Test-PropertySync -CimData $sData -MatchProperty $matchProperty -ValidatorName Hardware -Severity Critical
        }
        # Check property sync for all nodes as well
        $PropertySyncResult += Test-PropertySync -CimData $cimData -MatchProperty $matchProperty -ValidatorName Hardware  -Severity Critical
        return @($PropertyResult + $PropertySyncResult + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function Test-PhysicalDisk
{
    <#
    .SYNOPSIS
        Test Physical Disk
    .DESCRIPTION
        Test Physical Disk
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $fabricOp = $args[0]
            $eceNodeName = $args[1]
            $allowedBusTypes = @('SATA', 'SAS', 'NVMe', 'SCM')
            $allowedMediaTypes = @('HDD', 'SSD', 'SCM')
            $bootPhysicalDisk = Get-Disk | Where-Object {$_.IsBoot -or $_.IsSystem} | Get-PhysicalDisk
            if ($fabricOp -match 'AddNode|Repair')
            {
                if ($eceNodeName -eq $env:COMPUTERNAME)
                {
                    # In AddNode we need a seperate check command to return disks that are spaces disks
                    # to build a reference list for the new node
                    $cimData = @(Get-StorageNode -Name $env:COMPUTERNAME* | `
                        Get-PhysicalDisk -PhysicallyConnected | `
                        Where-Object { `
                            $_.CanPool -eq $false -and `
                            $_.CannotPoolReason -eq 'In a Pool'
                        }
                    )
                }
                else
                {
                    if($fabricOp -like "*AddNode*")
                    {
                        # For AddNode node we expect CanPool true and to match ECE node above
                        $cimData = @(Get-StorageNode -Name $env:COMPUTERNAME* | `
                        Get-PhysicalDisk -PhysicallyConnected | `
                            Where-Object { `
                                $_.BusType -in $allowedBusTypes -and `
                                $_.MediaType -in $allowedMediaTypes -and `
                                $_.DeviceId -notin $bootPhysicalDisk.DeviceId -and `
                                $_.CanPool -eq $true
                            }
                        )
                    }
                    elseif ($fabricOp -like "*Repair*")
                    {
                        # For Repair we ignore CanPool and to match ECE node above
                        $cimData = @(Get-StorageNode -Name $env:COMPUTERNAME* | `
                        Get-PhysicalDisk -PhysicallyConnected | `
                            Where-Object { `
                                $_.BusType -in $allowedBusTypes -and `
                                $_.MediaType -in $allowedMediaTypes -and `
                                $_.DeviceId -notin $bootPhysicalDisk.DeviceId
                            }
                        )
                    }
                    else
                    {
                        throw "Invalid Fabric Operation: $fabricOp"
                    }
                }
            }
            else
            {
                if ($fabricOp -like '*KeepStorage*')
                {
                    $cimData = @(Get-StorageNode -Name $env:COMPUTERNAME* | `
                        Get-PhysicalDisk -PhysicallyConnected | `
                        Where-Object { `
                            $_.BusType -in $allowedBusTypes -and `
                            $_.MediaType -in $allowedMediaTypes -and `
                            $_.DeviceId -notin $bootPhysicalDisk.DeviceId
                        }
                    )
                }
                else
                {
                    $cimData = @(Get-StorageNode -Name $env:COMPUTERNAME* | `
                                Get-PhysicalDisk -PhysicallyConnected | `
                                Where-Object { `
                                    $_.BusType -in $allowedBusTypes -and `
                                    $_.MediaType -in $allowedMediaTypes -and `
                                    $_.DeviceId -notin $bootPhysicalDisk.DeviceId -and `
                                    $_.CanPool -eq $true
                                }
                            )
                }
            }
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                cimData = $cimData
            })
        }
        $remoteOutput = if ($PsSession)
        {
            # When we are using PsSessions (every ECE fabric operation)
            # Inject our FabricOperation and local computer into the remote session,
            # so canPool expectation can be set for deployment and ScaleOut.
            Invoke-Command -Session $PsSession -ScriptBlock $sb -ArgumentList $ENV:EnvChkrId, $ENV:ComputerName
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $cimTest = Test-CimData -Data $remoteOutput -ClassName PhysicalDisk -Severity CRITICAL
        $cimData = $remoteOutput.cimData

        $PropertyResult = @()
        $GroupResult = @()
        $CountResult = @()
        $InstanceCount = @()
        $InstanceCountByGroup = @()

        $matchProperty = @(
            'FirmwareVersion'
        )

        $groupProperty = @(
            'FriendlyName'
        )

        $warningDesiredPropertyValue = @{
            HealthStatus        = @{ value = @('Healthy', 0); hint = 'Healthy' } # Healthy
            IsIndicationEnabled = @{ value = @($false, $null); hint = 'Indicator Off' }
            OperationalStatus   = @{ value = @('OK', 2); hint = 'OK' }
        }

        Log-CimData -cimData $cimData -Properties $groupProperty,$warningDesiredPropertyValue,$matchProperty, CanPool, CannotPoolReason, Size, PhysicalLocation, UniqueId, SerialNumber

        $instanceIdStr = 'Write-Output "Machine: $($instance.CimSystemProperties.ServerName), Class: $ClassName, Location: $($instance.PhysicalLocation), Unique ID: $($instance.UniqueId), Size: $("{0:N2}" -f ($instance.Size / 1TB)) TB"'
        # Check disk count for nodes individually
        [array]$SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            $totalSize = $sData | Measure-Object -Property Size -Sum
            Log-Info -Message ($lhwTxt.DiskTotal -f $systemName, $($sData.Count), ('{0:N2}' -f ($totalSize.Sum / 1TB)))
            $PropertyResult += Test-DesiredProperty -CimData $sData -desiredPropertyValue $warningDesiredPropertyValue -InstanceIdStr $InstanceIdStr -ValidatorName Hardware -Severity Warning

            # Split disks into type
            $SSD = $sData | Where-Object {$_.MediaType -match 'SSD|4' -and $_.BusType -match 'SAS|10|SATA|11'}
            $NVMe = $sData | Where-Object {$_.MediaType -match 'SSD|4' -and $_.BusType -match 'NVMe|17'}
            $SCM = $sData | Where-Object {$_.MediaType -match 'SCM|5'}
            $HDD = $sData | Where-Object {$_.MediaType -match 'HDD|3'}
            Log-Info ("Drive types detected HDD: {0}, SSD:{1}, NVMe:{2}, SCM:{3}" -f [bool]$HDD, [bool]$SSD, [bool]$NVMe, [bool]$SCM)

            # As per https://docs.microsoft.com/en-us/windows-server/storage/storage-spaces/storage-spaces-direct-hardware-requirements
            $systemCountResult = @()
            $countCommonParams = @{
                ValidatorName = 'Hardware'
                Severity = 'CRITICAL'
            }
            # all flash minimum should be 2
            # Drive type present (capacity only) Minimum drives required (Windows Server) Minimum drives required (Azure Stack HCI)
            # All persistent memory (same model) 4 persistent memory 2 persistent memory
            # All NVMe (same model) 4 NVMe 2 NVMe
            # All SSD (same model) 4 SSD 2 SSD
            if ($SSD -xor $NVMe -xor $SCM)
            {
                $systemCountResult += Test-Count -cimData $sData -Minimum 2 @countCommonParams
            }

            # Drive type present Minimum drives required
            # Persistent memory + NVMe or SSD 2 persistent memory + 4 NVMe or SSD
            # NVMe + SSD 2 NVMe + 4 SSD
            # NVMe + HDD 2 NVMe + 4 HDD
            # SSD + HDD 2 SSD + 4 HDD

            if ($SCM -and ($NVMe -or $SSD)) {
                $systemCountResult += Test-Count -cimData $SCM -Minimum 2 @countCommonParams
                if ($NVMe) {
                    Log-Info ($lhwTxt.MinCountDiskType -f 'NVMe', '4', $systemName )
                    $systemCountResult += Test-Count -cimData $NVMe -Minimum 4 @countCommonParams
                }
                else {
                    Log-Info ($lhwTxt.MinCountDiskType -f 'SSD', '4', $systemName )
                    $systemCountResult += Test-Count -cimData $SSD -Minimum 4 @countCommonParams
                }
            }

            if ($NVMe -and $SSD) {
                Log-Info ($lhwTxt.MinCountDiskType -f 'NVMe', '2', $systemName )
                $systemCountResult += Test-Count -cimData $NVMe -Minimum 2 @countCommonParams
                Log-Info ($lhwTxt.MinCountDiskType -f 'SSD', '4', $systemName )
                $systemCountResult += Test-Count -cimData $SSD -Minimum 4 @countCommonParams
            }

            if ($NVMe -and $HHD) {
                Log-Info ($lhwTxt.MinCountDiskType -f 'NVMe', '2', $systemName )
                $systemCountResult += Test-Count -cimData $NVMe -Minimum 2 @countCommonParams
                Log-Info ($lhwTxt.MinCountDiskType -f 'HDD', '4', $systemName )
                $systemCountResult += Test-Count -cimData $HDD -Minimum 4 @countCommonParams
            }

            if ($SSD -and $HHD) {
                Log-Info ($lhwTxt.MinCountDiskType -f 'SSD', '2', $systemName )
                $systemCountResult += Test-Count -cimData $SSD -Minimum 2 @countCommonParams
                Log-Info ($lhwTxt.MinCountDiskType -f 'HDD', '4', $systemName )
                $systemCountResult += Test-Count -cimData $HDD -Minimum 4 @countCommonParams
            }

            if ($systemCountResult.count -eq 0) {
                Log-Info "We did not determine the disk combination correctly for $systemName. Checking minimum as per deployment guide." -Type Warning
                $systemCountResult += Test-Count -cimData $sData -Minimum 3 @countCommonParams
            }
            $CountResult += $systemCountResult
        }
        # Check property sync for all nodes
        $GroupResult += Test-GroupProperty -CimData $cimData -GroupProperty $groupProperty -MatchProperty $matchProperty -ValidatorName Hardware -Severity Warning

        # Split disks into type and check each server has the same count
        $allSSD = $cimData | Where-Object {$_.MediaType -match 'SSD|4' -and $_.BusType -match 'SAS|10|SATA|11'}
        $allNVMe = $cimData | Where-Object {$_.MediaType -match 'SSD|4' -and $_.BusType -match 'NVMe|17'}
        $allSCM = $cimData | Where-Object {$_.MediaType -match 'SCM|5'}
        $allHDD = $cimData | Where-Object {$_.MediaType -match 'HDD|3'}
        $instParams = @{
            ValidatorName = 'Hardware'
            Severity = 'CRITICAL'
        }
        if ($allSSD) {
            Log-Info ($lhwTxt.DiskInstanceCountByType -f 'SSD')
            $InstanceCount += Test-InstanceCount -CimData $allSSD @instParams -NamePostfix "SSD"
        }
        if ($allNVMe) {
            Log-Info ($lhwTxt.DiskInstanceCountByType -f 'NVMe')
            $InstanceCount += Test-InstanceCount -CimData $allNVMe @instParams -NamePostfix "NVMe"
        }
        if ($allSCM) {
            Log-Info ($lhwTxt.DiskInstanceCountByType -f 'SCM')
            $InstanceCount += Test-InstanceCount -CimData $allSCM @instParams -NamePostfix "SCM"
        }
        if ($allHDD) {
            Log-Info ($lhwTxt.DiskInstanceCountByType -f 'HDD')
            $InstanceCount += Test-InstanceCount -CimData $allHDD @instParams -NamePostfix "HDD"
        }

        if ($null -eq $PsSession -or $PsSession.Count -eq 1)
        {
            # Single Node deployments should be all flash
            [array]$CheckSingleNodeAllFlash = CheckSingleNodeAllFlash -CimData $cimData
        }

        # Do all servers have the same count regardless of type
        $InstanceCount += Test-InstanceCount -CimData $cimData -Severity Critical -ValidatorName 'Hardware'
        Log-Info ($lhwTxt.DiskInstanceCountByType -f 'ALL')

        # Finally, the all properties from the $matchProperty array (Firmware) have to be compared for all instances
        # across all nodes grouped by property (FriendlyName)
        $InstanceCountByGroup += Test-InstanceCountByGroup -CimData $cimData -ValidatorName 'Hardware' -GroupProperty $groupProperty -Severity Warning
        return @($PropertyResult + $GroupResult + $CountResult + $InstanceCount + $InstanceCountByGroup + $CheckSingleNodeAllFlash + $cimTest)
    }
    catch
    {
        throw $_
    }
}

function Test-TpmVersion
{
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession,

        [Parameter()]
        $version = '2.0'
    )

    $tpms = @()
    $InstanceResults = @()
    $sb = {
            $tpm = Get-CimInstance -Namespace root/cimv2/Security/MicrosoftTpm -ClassName Win32_Tpm -ErrorAction SilentlyContinue
            $result = New-Object -TypeName PSObject -Property @{
                ComputerName = $ENV:COMPUTERNAME
                TpmData = $tpm
            }
        return $result
    }
    $tpms += if ($PsSession)
    {
        Invoke-Command -Session $PsSession -ScriptBlock $sb
    }
    else
    {
        Invoke-Command -ScriptBlock $sb
    }

    Log-CimData -CimData $tpms.TpmData

    foreach ($tpm in $tpms)
    {
        $computerName = $tpm.ComputerName
        # Test properties
        $InstanceResults += foreach ($instance in $tpm.TpmData)
        {
            $instanceId = "Machine: $computerName, Class: Tpm, Manufacturer ID: $($instance.ManufacturerId)"
            $instanceVersion = $instance.SpecVersion -split ',' | Select-Object -First 1
            $status = if ($instanceVersion -eq $version) { 'SUCCESS' } else { 'FAILURE' }
            $params = @{
                Name               = 'AzStackHci_Hardware_Test_Tpm_Version'
                Title              = 'Test TPM Version'
                DisplayName        = "Test TPM Version $computerName"
                Severity           = 'CRITICAL'
                Description        = "Checking TPM for desired version ($version)"
                Tags               = @{}
                Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'Tpm'
                Timestamp          = [datetime]::UtcNow
                Status             =  $status
                AdditionalData     = @{
                    Source    = 'Version'
                    Resource  = $instanceVersion
                    Detail    = "$instanceId Tpm version is $instanceVersion. Expected $version"
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            $instanceResult = New-AzStackHciResultObject @params

            if ($InstanceResult.AdditionalData.Status -eq 'SUCCESS')
            {
                Log-Info -Message $InstanceResult.AdditionalData.Detail
            }
            else
            {
                Log-Info -Message $InstanceResult.AdditionalData.Detail -Type Warning
            }
            $instanceResult
        }
    }
    return $InstanceResults
}

function Test-TpmProperties
{
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $tpms = @()
        $InstanceResults = @()
        $sb = {
            $tpm = Get-Tpm
            New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                tpm = $tpm
            }
        }
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $tpms += Invoke-Command -ScriptBlock $sb
        }
        else
        {
            $tpms += Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        foreach ($tpm in $tpms)
        {
            $passed = $false
            $computerName = $tpm.ComputerName
            $desiredPropertyValue = @{
                TpmPresent         = $true #(Get-CimInstance -Namespace root/cimv2/Security/MicrosoftTpm -ClassName Win32_Tpm) is null
                TpmReady           = $true #IsActivated()
                TpmEnabled         = $true #IsEnabled()
                TpmActivated       = $true #IsActivated()
                #TpmOwned = $true #IsOwned()
                #RestartPending = $false #GetPhysicalPresenceRequest()?
                ManagedAuthLevel   = 'Full' #GetOwnerAuth()??
                OwnerClearDisabled = $false #IsOwnerClearDisabled()
                AutoProvisioning   = 'Enabled' #IsAutoProvisioningEnabled()
                LockedOut          = $false #IsLockedOut()
                LockoutCount       = 0 #GetCapLockoutInfo()
            }
            Log-CimData -cimData $tpm -Properties $desiredPropertyValue
            Log-Info -Message ($lhwTxt.TestTpm -f $computerName, $tpm.tpm.ManufacturerIdTxt, $tpm.tpm.ManufacturerVersion)

            # Test properties
            $InstanceResults += foreach ($instance in $tpm.tpm)
            {
                $instanceId = "Machine: $computerName, Class: Tpm, Manufacturer ID: $($tpm.tpm.ManufacturerId)"
                foreach ($propertyName in $desiredPropertyValue.Keys)
                {
                    $detail = $null
                    $passed = $false
                    if ($instance.$propertyName -ne $desiredPropertyValue.$propertyName)
                    {
                        $passed = $false
                        $detail = $lhwTxt.UnexProp -f $propertyName, $instance.$propertyName, $desiredPropertyValue.$propertyName
                        Log-Info -Message $detail -Type Warning
                    }
                    else
                    {
                        $detail = $lhwTxt.Prop -f $propertyName, $instance.$propertyName, $desiredPropertyValue.$propertyName
                        $passed = $true
                    }
                    $status = if ($passed) { 'SUCCESS' } else { 'FAILURE' }
                    $params = @{
                        Name               = 'AzStackHci_Hardware_Test_Tpm_Instance_Properties'
                        Title              = "Test TPM Property $propertyName is $($desiredPropertyValue.$propertyName)"
                        DisplayName        = "Test TPM Property $propertyName is $($desiredPropertyValue.$propertyName) $computerName"
                        Severity           = 'CRITICAL'
                        Description        = "Checking TPM for desired properties"
                        Tags               = @{}
                        Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                        TargetResourceID   = $instanceId
                        TargetResourceName = $instanceId
                        TargetResourceType = 'Tpm'
                        Timestamp          = [datetime]::UtcNow
                        Status             =  $status
                        AdditionalData     = @{
                            Source    = $propertyName
                            Resource  = $instance.$propertyName
                            Detail    = $detail
                            Status    = $status
                            TimeStamp = [datetime]::UtcNow
                        }
                        HealthCheckSource  = $ENV:EnvChkrId
                    }
                    New-AzStackHciResultObject @params
                }
            }
        }
        return $InstanceResults
    }
    catch
    {
        throw $_
    }
}

function Test-TpmCertificates
{
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $allowedKeyUsage = '2.23.133.8.1' # Endorsement Key Certificate
        $allowedAlgorithms = @(
            '1.2.840.113549.1.1.11' # SHA256
            '1.2.840.113549.1.1.12' # SHA384
            '1.2.840.113549.1.1.13' # SHA512
            '1.2.840.10045.4.3.2' # SHA256ECDSA
            '1.2.840.10045.4.3.3' # SHA384ECDSA
            '1.2.840.10045.4.3.4' # SHA512ECDSA
        )
        $tpmKeys = @()
        $InstanceResults = @()
        $sb = {
            try
            {
                $tpmKeys = Get-TpmEndorsementKeyInfo -ErrorAction SilentlyContinue
            }
            catch {}
            return (New-Object PsObject -Property @{
                ComputerName = $ENV:ComputerName
                tpmKeys = $tpmKeys
            })
        }
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $tpmKeys += Invoke-Command -ScriptBlock $sb
        }
        else
        {
            $tpmKeys += Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        Log-CimData -cimData $tpmKeys
        $InstanceResults += foreach ($tpmKey in $tpmKeys)
        {
            $computerName = $tpmKey.ComputerName
            $tpmCert = $tpmKey.tpmKeys.ManufacturerCertificates + $tpmKey.tpmKeys.AdditionalCertificates
            $instanceId = "Machine: $computerName, Class: TpmCertificates, Subject: $($tpmKey.tpmKeys.ManufacturerCertificates.subject), Thumprint: $($tpmKey.tpmKeys.ManufacturerCertificates.Thumbprint)"

            foreach ($cert in $tpmCert)
            {
                $validCert = $false
                $certDetail = $null
                # Test TPM certificate expiration
                $now = [datetime]::UtcNow
                $sinceIssued = New-TimeSpan -Start $cert.NotBefore -End $now
                $untilExpired = New-TimeSpan -Start $now -End $cert.NotAfter
                $currentCert = $sinceIssued.Days -gt 0 -and $untilExpired.Days -gt 0

                # Test TPM signature algorithm
                $validAlgo = $cert.SignatureAlgorithm.Value -in $allowedAlgorithms

                # Test TPM certificate Enhanced Key Usage
                $validUsage = $cert.EnhancedKeyUsageList.ObjectId -contains $allowedKeyUsage

                # Display certificate properties
                $validCert = $currentCert -and $validAlgo -and $validUsage
                [string[]]$certDetail = "TPM certificate $($cert.Thumbprint), valid = $validCert"
                $certDetail += " Issuer: $($cert.Issuer)"
                $certDetail += " Subject: $($cert.Subject)"
                $certDetail += " Key Usage: $($cert.EnhancedKeyUsageList.FriendlyName -join ', '), valid = $validUsage"
                #$cert.Extensions.Oid.FriendlyName | Foreach-Object { $certDetail += " Extension: $_" }
                $certDetail += " Valid from: $($cert.NotBefore) to $($cert.NotAfter), valid = $currentCert"
                $certDetail += " Algorithm: $($cert.SignatureAlgorithm.FriendlyName), valid = $validAlgo"
                $foundValidCert = $foundValidCert -or $validCert

                $status = if ($validCert) { 'SUCCESS' } else { 'FAILURE' }

                $params = @{
                    Name               = 'AzStackHci_Hardware_Test_Tpm_Certificate_Properties'
                    Title              = "Test TPM Certificate Properties"
                    DisplayName        = "Test TPM $computerName"
                    Severity           = 'CRITICAL'
                    Description        = "Checking TPM for desired properties"
                    Tags               = @{}
                    Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                    TargetResourceID   = $instanceId
                    TargetResourceName = $instanceId
                    TargetResourceType = 'TpmEndorsementKeyInfo'
                    Timestamp          = [datetime]::UtcNow
                    Status             = $status
                    AdditionalData     = @{
                        Source    = $cert.Thumbprint
                        Resource  = "Current: $currentCert. Valid Algorithm: $validAlgo. Valid Key Usage: $validUsage."
                        Detail    = ($certDetail -join "`r")
                        Status    = $status
                        TimeStamp = [datetime]::UtcNow
                    }
                    HealthCheckSource  = $ENV:EnvChkrId
                }
                New-AzStackHciResultObject @params
            }
        }
        return $InstanceResults
    }
    catch
    {
        throw $_
    }
}

function Test-SecureBoot
{
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $secureBoots = @()
        $sb = {

            if ((Get-Command Confirm-SecureBootUEFI -ErrorAction  SilentlyContinue) -ne $null) {
                <#
                    For devices that Standard hardware security is not supported, this means that the device does not meet
                    at least one of the requirements of standard hardware security.
                    This causes the Confirm-SecureBootUEFI command to fail with the error:
                    Cmdlet not supported on this platform: 0xC0000002
                #>
                try {
                    $secureBoot = Confirm-SecureBootUEFI
                }
                catch {
                    $secureBoot = $false
                }
            }
            else {
                $secureBoot = $false
            }

            New-Object PsObject -Property @{
                SecureBoot = $secureBoot
                ComputerName = $env:COMPUTERNAME
            }
        }
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $secureBoots += Invoke-Command -ScriptBlock $sb
        }
        else
        {
            $secureBoots += Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        Log-CimData -cimData $secureboots
        $InstanceResults = @()
        $InstanceResults += foreach ($SecureBootUEFI in $secureBoots)
        {
            $dtl = $lhwTxt.SecureBoot -f $SecureBootUEFI.SecureBoot, 'True'
            if ($SecureBootUEFI.SecureBoot)
            {
                $status = 'SUCCESS'
            }
            else
            {
                $status = 'FAILURE'
                $dtl = "{0}. {1}" -f $dtl, $lhwTxt.SecureBootNotSupported
            }
            $params = @{
                Name               = 'AzStackHci_Hardware_Test_Secure_Boot'
                Title              = "Test Secure Boot"
                DisplayName        = "Test Secure Boot $($SecureBootUEFI.computerName)"
                Severity           = 'CRITICAL'
                Description        = "Checking Secure Boot"
                Tags               = @{}
                Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'SecureBoot'
                Timestamp          = [datetime]::UtcNow
                Status             = $status
                AdditionalData     = @{
                    Source    = $SecureBootUEFI.ComputerName
                    Resource  = $SecureBootUEFI.SecureBoot
                    Detail    = $dtl
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            New-AzStackHciResultObject @params
        }
        return $InstanceResults
    }
    catch
    {
        throw $_
    }
}

function Test-StoragePool
{
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $StoragePoolsExist = @()
        $sb = {
            New-Object PsObject -Property @{
                StoragePoolExists = [bool](Get-StoragePool -IsPrimordial:$false -ErrorAction SilentlyContinue)
                ComputerName = $ENV:ComputerName
            }
        }
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $StoragePoolsExist += Invoke-Command -ScriptBlock $sb
        }
        else
        {
            $StoragePoolsExist += Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        Log-CimData -cimData $StoragePoolsExist

        $InstanceResults = @()
        $InstanceResults += foreach ($StoragePool in $StoragePoolsExist)
        {
            $status = if (-not $StoragePool.StoragePoolExists) { 'SUCCESS' } else { 'FAILURE' }
            $params = @{
                Name               = 'AzStackHci_Hardware_Test_No_StoragePools'
                Title              = "Test Storage Pools do not exist for new deployment"
                DisplayName        = "Test Storage Pools do not exist for new deployment $($StoragePool.computerName)"
                Severity           = 'CRITICAL'
                Description        = "Checking no storage pools exist for new deployment"
                Tags               = @{}
                Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'StoragePool'
                Timestamp          = [datetime]::UtcNow
                Status             = $status
                AdditionalData     = @{
                    Source    = 'StoragePool'
                    Resource  = if ([bool]$StoragePool.StoragePoolExists) { "Present" } else { "Not present" }
                    Detail    = $lhwTxt.StoragePoolFail -f [bool]$StoragePool.StoragePoolExists, 'False'
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            New-AzStackHciResultObject @params
        }
        return $InstanceResults
    }
    catch
    {
        throw $_
    }
}

function Test-FreeSpace
{
    <#
    .SYNOPSIS
        Test free space
    #>
    [CmdletBinding()]
    param (
        [Parameter()]
        [string]
        $Drive = $env:LocalRootFolderPath,

        [Parameter()]
        [int64]
        $Threshold = 30GB,

        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $cimData = @()
        $InstanceResults = @()
        if ([string]::IsNullOrEmpty($Drive))
        {
            $Drive = "C:\"
        }
        $Drive = (Split-Path -Path $Drive -Qualifier)
        $sb = {
            $DriveExists = Test-Path -Path $args[0] -IsValid
            if ($DriveExists)
            {
                $cimData = Get-CimInstance -ClassName Win32_LogicalDisk -Property DeviceId, FreeSpace | Where-Object DeviceID -EQ $args[0]
            }
            return New-Object PsObject -Property @{
                DriveExists = $DriveExists
                ComputerName = $ENV:ComputerName
                DeviceID = $cimData.DeviceID
                FreeSpace = $cimData.FreeSpace
            }
        }
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $results += Invoke-Command -ScriptBlock $sb -ArgumentList $Drive
        }
        else
        {
            $results += Invoke-Command -Session $PsSession -ScriptBlock $sb -ArgumentList $Drive
        }
        Log-CimData -cimData $results
        $InstanceResults += foreach ($result in $results)
        {
            $computerName = $result.ComputerName
            if ($result.DriveExists -eq $false)
            {
                $status = 'FAILURE'
                $dtl = $lhwtxt.LocalRootFolderPathFail -f $computerName, $Drive
                Log-Info $dtl -Type Warning
            }
            else
            {
                $freeSpaceStr = [int]($result.FreeSpace / 1GB)
                $thresholdStr = [int]($threshold / 1GB)
                $dtl = $lhwtxt.LocalRootFolderPathFreeSpace -f $computerName, $Drive, $freeSpaceStr, $thresholdStr
                if ($result.FreeSpace -gt $Threshold)
                {
                    $status = 'SUCCESS'
                    Log-Info $dtl
                }
                else
                {
                    $status = 'FAILURE'
                    Log-Info $dtl -Type Warning
                }
            }

            $instanceId = "Machine: $computerName, Class: Disk, DriveLetter: $drive"
            $params = @{
                Name               = 'AzStackHci_Hardware_Test_Disk_Space'
                Title              = "Test Disk Space"
                DisplayName        = "Test Disk Space $computerName"
                Severity           = 'WARNING'
                Description        = "Checking Disk Space"
                Tags               = @{}
                Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'Disk'
                Timestamp          = [datetime]::UtcNow
                Status             = $status
                AdditionalData     = @{
                    Source    = $computerName
                    Resource  = $cim.DeviceID
                    Detail    = $dtl
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            New-AzStackHciResultObject @params
        }
        return $InstanceResults
    }
    catch
    {
        throw $_
    }
}

function Test-Volume
{
    <#
    .SYNOPSIS
        Test free space
    #>
    [CmdletBinding()]
    param (
        [Parameter()]
        [string[]]
        $Drive = @('C'),

        # TO DO: Implement Free Space check
        [Parameter()]
        [int64]
        $Threshold = 30GB,

        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $cimData = @()
        $CountResult = @()
        $InstanceCountByGroup = @()

        $sb = {
            $cimData = Get-Volume | Where-Object DriveLetter -in $args
            return $cimData
        }
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $cimData += Invoke-Command -ScriptBlock $sb -ArgumentList $Drive
        }
        else
        {
            $cimData += Invoke-Command -Session $PsSession -ScriptBlock $sb -ArgumentList $Drive
        }

        $groupProperty = @(
            'DriveLetter'
        )

        Log-CimData -cimData $cimData -Properties $groupProperty

        $SystemNames = $cimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique
        foreach ($systemName in $SystemNames)
        {
            $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
            #Log-Info -Message ($lhwTxt.VolumeCount -f $systemName, ($Drive -join ','), $sData.Count)
            # Make sure each system has the requisite number of Network Adapters
            $CountResult += Test-Count -CimData $sData -minimum $Drive.Count -ValidatorName 'Hardware' -Severity Critical
        }
        # Make sure each node has the same count by group
        $InstanceCountByGroup += Test-InstanceCountByGroup -CimData $cimData -ValidatorName 'Hardware' -GroupProperty $groupProperty -Severity Critical
        # Finally, the all properties from the $matchProperty array have to be compared for all instances across all nodes.
        return @($CountResult + $InstanceCountByGroup)
    }
    catch
    {
        throw $_
    }
}

function CheckSingleNodeAllFlash
{
        param ($cimData)
        # Split disks into type and check each server has the same count
        $allSSD = $cimData | Where-Object {$_.MediaType -match 'SSD|4' -and $_.BusType -match 'SAS|10|SATA|11'}
        $allNVMe = $cimData | Where-Object {$_.MediaType -match 'SSD|4' -and $_.BusType -match 'NVMe|17'}
        $allSCM = $cimData | Where-Object {$_.MediaType -match 'SCM|5'}
        $allHDD = $cimData | Where-Object {$_.MediaType -match 'HDD|3'}
        $className = $CimData.CimSystemProperties.ClassName -split '_' | Select-Object -Last 1
        $instanceId = $CimData.CimSystemProperties.ServerName | Sort-Object | Get-Unique

        Log-Info ($lhwTxt.SingleNodeAllFlash -f $instanceId)

        # check if they are all flash
        if ($allSSD -xor $allNVMe -and !$allSCM -and !$allHDD)
        {
            $Status = 'SUCCESS'
            $type = 'Info'
        }
        else
        {
            $Status = 'FAILURE'
            $type = 'WARNING'
        }

        $detail = $lhwTxt.SingleNodeAllFlashDetail -f $instanceId,("HDD: {0}, SSD:{1}, NVMe:{2}, SCM:{3}" -f [bool]$allHDD, [bool]$allSSD, [bool]$allNVMe, [bool]$allSCM)
        Log-Info $detail -Type $type

        $params = @{
            Name               = 'AzStackHci_Hardware_Test_SingleNode_AllFlash'
            Title              = "Test Single Node All Flash"
            DisplayName        = "Test Single Node All Flash $instanceId"
            Severity           = 'CRITICAL'
            Description        = "Checking single node is all flash"
            Tags               = @{}
            Remediation        = 'https://learn.microsoft.com/en-us/windows-server/storage/storage-spaces/storage-spaces-direct-hardware-requirements#minimum-number-of-drives-excludes-boot-drive'
            TargetResourceID   = $instanceId
            TargetResourceName = $instanceId
            TargetResourceType = $className
            Timestamp          = [datetime]::UtcNow
            Status             = $status
            AdditionalData     = @{
                Source    = "$className Drive Type"
                Resource  = "HDD: {0}, SSD:{1}, NVMe:{2}, SCM:{3}" -f [bool]$allHDD, [bool]$allSSD, [bool]$allNVMe, [bool]$allSCM
                Detail    = $detail
                Status    = $status
                TimeStamp = [datetime]::UtcNow
            }
            HealthCheckSource  = $ENV:EnvChkrId
        }
        New-AzStackHciResultObject @params
}

function Test-MinCoreCount
{
    <#
    .SYNOPSIS
        Get minimum core count
    .DESCRIPTION
        Get core count from local machine to use as minimum core count
        Expecting data from PsSessions to include local machine indicating ECE.
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_Processor'
                Property  = 'NumberOfCores'
            }
            $cimData = @(Get-CimInstance @cimParams)
            return $cimData
        }
        $cimData = if ($PsSession)
        {
            Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        else
        {
            Invoke-Command -ScriptBlock $sb
        }

        $instanceResults = @()
        Log-CimData -cimData $cimData -Properties NumberOfCores

        if ((Get-WmiObject -Class Win32_ComputerSystem).Model -eq "Virtual Machine")
        {
            $environmentType = "Virtual"
            $RequiredTotalNumberOfCores = 4
        } else {
            $environmentType = "Physical"
            # Set min cores to local machine
            # This should only apply the scenario where there is a PsSession to all nodes,
            # and one of the nodes is also the local machine i.e. ECE invocation
            $RequiredTotalNumberOfCores = GetTotalNumberOfCores -cimData ($cimData | Where-Object { $_.CimSystemProperties.ServerName -like "$($ENV:COMPUTERNAME)*"})
        }
        Log-Info -Message ($lhwTxt.CoreCountRequirement -f $RequiredTotalNumberOfCores, $environmentType)

        if ($RequiredTotalNumberOfCores)
        {
            [array]$SystemNames = $cimData.CimSystemProperties.ServerName | Where-Object {$PSITEM -notlike "$($ENV:COMPUTERNAME)*"} | Sort-Object | Get-Unique
            $instanceResults += foreach ($systemName in $SystemNames)
            {
                $sData = $CimData | Where-Object { $_.CimSystemProperties.ServerName -eq $systemName }
                $TotalNumberOfCores = GetTotalNumberOfCores -cimData $sData
                if ($TotalNumberOfCores)
                {
                    $detail = $lhwTxt.CheckMinCoreCount -f $SystemName, $TotalNumberOfCores, $RequiredTotalNumberOfCores
                    if ($TotalNumberOfCores -ge $RequiredTotalNumberOfCores)
                    {
                        $status = 'SUCCESS'
                        Log-Info -message $detail
                    }
                    else
                    {
                        $status = 'FAILURE'
                        Log-Info -message $detail -Type Warning
                    }
                }
                else
                {
                    $detail = $lhwTxt.UnexpectedCoreCount -f 'Unavailable','1'
                    $status = 'FAILURE'
                    Log-Info -message $detail -Type Warning
                }

                $params = @{
                    Name               = 'AzStackHci_Hardware_Test_Minimum_CPU_Cores'
                    Title              = 'Test Minimum CPU Cores'
                    DisplayName        = "Test Minimum CPU Cores $systemName"
                    Severity           = 'WARNING'
                    Description        = 'Checking minimum CPU cores'
                    Tags               = @{}
                    Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                    TargetResourceID   = $systemName
                    TargetResourceName = $systemName
                    TargetResourceType = $cimParams.className
                    Timestamp          = [datetime]::UtcNow
                    Status             = $status
                    AdditionalData     = @{
                        Source    = $cimParams.ClassName
                        Resource  = 'Core Count'
                        Detail    = $detail
                        Status    = $status
                        TimeStamp = [datetime]::UtcNow
                    }
                    HealthCheckSource  = $ENV:EnvChkrId
                }
                New-AzStackHciResultObject @params
            }
        }
        else
        {
            Log-info $lhwTxt.SkippedCoreCount -type Warning
        }
        return $instanceResults
    }
    catch
    {
        throw $_
    }
}

function Test-VirtualDisk
{
        <#
    .SYNOPSIS
        Test Virtual Disk
    .DESCRIPTION
        During repair test virtual disk
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            New-Object -Type PsObject -Property @{
                VirtualDiskExists = [bool](Get-StoragePool -IsPrimordial:$false -ErrorAction SilentlyContinue | Get-VirtualDisk)
                ComputerName = $ENV:COMPUTERNAME
            }
        }

        $VirtualDiskExists = @()
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $VirtualDiskExists += Invoke-Command -ScriptBlock $sb
        }
        else
        {
            $VirtualDiskExists += Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        Log-CimData -cimData $VirtualDiskExists
        $instanceResults = @()
        $instanceResults += foreach ($virtualDisk in $VirtualDiskExists)
        {
            if ($virtualDisk.VirtualDiskExists)
            {
                $status = 'SUCCESS'
                $detail = $lhwTxt.VirtualDiskExists -f $virtualDisk.ComputerName
                Log-Info $detail
            }
            else
            {
                $status = 'FAILURE'
                $detail = $lhwTxt.VirtualDiskNotExists -f $virtualDisk.ComputerName
                Log-Info $detail -Type Warning
            }

            $instanceId = "Machine: $($virtualDisk.ComputerName), Class: VirtualDisk"
            $params = @{
                Name               = 'AzStackHci_Hardware_Test_VirtualDisk_Exists'
                Title              = 'Test Virtual Disk exists'
                DisplayName        = "Test Virtual Disk exists $($virtualDisk.ComputerName)"
                Severity           = 'CRITICAL'
                Description        = 'Checking virtual disk(s) exist for repair'
                Tags               = @{}
                Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'VirtualDisk'
                Timestamp          = [datetime]::UtcNow
                Status             = $status
                AdditionalData     = @{
                    Source    = $virtualDisk.ComputerName
                    Resource  = if ($virtualDisk.VirtualDiskExists) { "Present" } else { "Not present" }
                    Detail    = $detail
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            New-AzStackHciResultObject @params
        }
    }
    catch
    {
        throw $_
    }
}

function Test-VirtualizationBasedSecurity
{
    <#
    .SYNOPSIS
        Test Virtualization-based Security (VBS)
    .DESCRIPTION
        Test if hardware supports VBS, which is required on HCI
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $vbsMethodDefinition = @'
public enum Values
{
    SecureKernelRunning,
    HvciEnabled,
    HvciStrictMode,
    DebugEnabled,
    FirmwarePageProtection,
    EncryptionKyAvailable,
    SpareFlags,
    TrustletRunning,
    HvciDisableAllowed,
    SpareFlags2,
    Sparce1,
    Sparce2,
    Sparce3,
    Sparce4,
    Sparce5,
    Sparce6
}
 
public enum SYSTEM_INFORMATION_CLASS_EX : uint
{
    SystemBootEnvironmentInformation = 90,
    SystemIsolatedUserModeInformation = 165,
    SystemDmaGuardPolicyInformation = 202
}
 
public struct SYSTEM_ISOLATED_USER_MODE_INFORMATION
{
    public Values Bits;
    public ulong Spare7;
}
 
public static bool GetVBSCapable()
{
    bool capable = false;
    bool enabled = false;
 
    GetVBSInfo(ref capable, ref enabled);
    return capable;
}
 
[DllImport("ntdll", CharSet = CharSet.Auto, SetLastError = true)]
public static extern uint NtQuerySystemInformation(
  [In] SYSTEM_INFORMATION_CLASS_EX SystemInformationClass,
  [In][Out] IntPtr SystemInformation,
  [In] uint SystemInformationLength,
  [Out] uint ReturnLength);
 
public static void GetVBSInfo(ref bool capable, ref bool enabled)
{
    var outSize = (uint)0;
    var outBuffer = IntPtr.Zero;
 
    try
    {
        outSize = (uint)Marshal.SizeOf(typeof(SYSTEM_ISOLATED_USER_MODE_INFORMATION));
        outBuffer = Marshal.AllocHGlobal((int)outSize);
 
        for (long offset = 0; offset < outSize; offset++)
        {
            Marshal.WriteByte(outBuffer, (int)offset, 0);
        }
 
        uint retValue = NtQuerySystemInformation(SYSTEM_INFORMATION_CLASS_EX.SystemIsolatedUserModeInformation, outBuffer, outSize, 0);
        if (retValue != 0)
        {
            throw new Exception(Marshal.GetLastWin32Error().ToString());
        }
 
        SYSTEM_ISOLATED_USER_MODE_INFORMATION iumInfo = new SYSTEM_ISOLATED_USER_MODE_INFORMATION();
        iumInfo = (SYSTEM_ISOLATED_USER_MODE_INFORMATION)Marshal.PtrToStructure(outBuffer, typeof(SYSTEM_ISOLATED_USER_MODE_INFORMATION));
 
        capable = ((int)iumInfo.Bits | 0x01) != 0;
        enabled = ((int)iumInfo.Bits | 0x02) != 0;
    }
    finally
    {
        Marshal.FreeHGlobal(outBuffer);
    }
}
'@
            $null = Add-Type -MemberDefinition $vbsMethodDefinition -Name "VirtualizationBasedSecurity" -Namespace "Microsoft.PowerShell.AzStackHci.EnvironmentChecker.Hardware" -PassThru
            $vbsCapable = [Microsoft.PowerShell.AzStackHci.EnvironmentChecker.Hardware.VirtualizationBasedSecurity]::GetVBSCapable()

            New-Object -Type PsObject -Property @{
                VbsCapable = $vbsCapable
                ComputerName = $ENV:COMPUTERNAME
            }
        }

        $vbsCapabilities = @()
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $vbsCapabilities += Invoke-Command -ScriptBlock $sb
        }
        else
        {
            $vbsCapabilities += Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        Log-CimData -cimData $vbsCapabilities
        $instanceResults = @()
        $instanceResults += foreach ($vbsCapability in $vbsCapabilities)
        {
            if ($vbsCapability.VbsCapable)
            {
                $status = 'SUCCESS'
                $detail = $lhwTxt.VbsCapable -f $vbsCapability.ComputerName
                Log-Info $detail
            }
            else
            {
                $status = 'FAILURE'
                $detail = $lhwTxt.VbsIncapable -f $vbsCapability.ComputerName
                Log-Info $detail -Type Warning
            }

            $instanceId = "Machine: $($vbsCapability.ComputerName), Class: Virtualization-based Security"
            $params = @{
                Name               = 'AzStackHci_Hardware_Test_VirtualizationBasedSecurity'
                Title              = 'Test Virtualization-based Security'
                DisplayName        = "Test Virtualization-based Security $($virtualDisk.ComputerName)"
                Severity           = 'CRITICAL'
                Description        = 'Checking Virtualization-based Security capability'
                Tags               = @{}
                Remediation        = 'https://learn.microsoft.com/en-us/azure-stack/hci/deploy/deployment-tool-prerequisites'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'Virtualization-based Security'
                Timestamp          = [datetime]::UtcNow
                Status             = $status
                AdditionalData     = @{
                    Source    = $vbsCapability.ComputerName
                    Resource  = if ($vbsCapability.VbsCapable) { "Present" } else { "Not present" }
                    Detail    = $detail
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            New-AzStackHciResultObject @params
        }
        return $InstanceResults
    }
    catch
    {
        throw $_
    }
}

function GetTotalNumberOfCores
{
    <#
    .SYNOPSIS
        Multiply number of cores by number of processors
    .DESCRIPTION
        Multiply number of cores by number of processors
    #>

    param ($cimData)

    try {
        if ($cimData)
        {
            $numberOfCores = $cimData | Select-Object -ExpandProperty NumberOfCores | Sort-Object | Get-Unique
            if ($numberOfCores.count -ne 1)
            {
                throw ($lhwTxt.UnexpectedCoreCount -f $numberOfCores.count, '1')
            }
            else
            {
                return ($numberOfCores * @($cimData).count)
            }
        }
        else
        {
            throw $lhwTxt.NoCoreReference
        }
    }
    catch
    {
        Log-Info ($lhwTxt.UnableCoreCount -f $_) -Type Warning
    }
}

function Test-MountedMedia
{
    <#
    .SYNOPSIS
        Test Mounted Media
    .DESCRIPTION
        Test is any media is mounted on the system such as CD, DVD, etc.
    #>
    [CmdletBinding()]
    param (
        [System.Management.Automation.Runspaces.PSSession[]]
        $PsSession
    )
    try
    {
        $sb = {
            $cimParams = @{
                ClassName = 'Win32_CDROMDrive'
                Property  = '*'
            }
            $cimData = @(Get-CimInstance @cimParams)
            New-Object -Type PsObject -Property @{
                MediaExists = [bool]$cimData.MediaLoaded
                cimData = $cimData
                ComputerName = $ENV:COMPUTERNAME
            }
        }

        $remoteOutput = @()
        if ([string]::IsNullOrEmpty($PsSession))
        {
            $remoteOutput += Invoke-Command -ScriptBlock $sb
        }
        else
        {
            $remoteOutput += Invoke-Command -Session $PsSession -ScriptBlock $sb
        }
        Log-CimData -cimData $remoteOutput.CimData
        $instanceResults = @()
        $instanceResults += foreach ($media in $remoteOutput)
        {
            if ($media.MediaExists)
            {
                $status = 'FAILURE'
                $detail = $lhwTxt.MediaExists -f $media.ComputerName, ($media.CimData | % { "Name: $($_.Name), Media: $($_.Caption), Drive: $($_.Drive)" }) -join '. '
                Log-Info $detail -Type CRITICAL
            }
            else
            {
                $status = 'SUCCESS'
                $detail = $lhwTxt.MediaNotExists -f $media.ComputerName
                Log-Info $detail
            }

            $instanceId = "Machine: $($media.ComputerName), Class: CDROMDrive"
            $params = @{
                Name               = 'AzStackHci_Hardware_Test_MountedMedia_Exists'
                Title              = 'Test No Mounted Media exists'
                DisplayName        = "Test No Mounted Media exists $($virtualDisk.ComputerName)"
                Severity           = 'CRITICAL'
                Description        = 'Checking mounted media does not exist'
                Tags               = @{}
                Remediation        = 'https://aka.ms/nomountedmedia'
                TargetResourceID   = $instanceId
                TargetResourceName = $instanceId
                TargetResourceType = 'CDROMDrive'
                Timestamp          = [datetime]::UtcNow
                Status             = $status
                AdditionalData     = @{
                    Source    = $media.ComputerName
                    Resource  = if ($virtualDisk.MediaExists) { "Present" } else { "Not present" }
                    Detail    = $detail
                    Status    = $status
                    TimeStamp = [datetime]::UtcNow
                }
                HealthCheckSource  = $ENV:EnvChkrId
            }
            New-AzStackHciResultObject @params
        }
        return $instanceResults
    }
    catch
    {
        throw $_
    }

}

Export-ModuleMember -Function Test-*
# SIG # Begin signature block
# MIIoKQYJKoZIhvcNAQcCoIIoGjCCKBYCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCDElFk6qdi8y7Ma
# ndET101Gto7lNkkJnr8MMeFWP1ym16CCDXYwggX0MIID3KADAgECAhMzAAADrzBA
# DkyjTQVBAAAAAAOvMA0GCSqGSIb3DQEBCwUAMH4xCzAJBgNVBAYTAlVTMRMwEQYD
# VQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNpZ25p
# bmcgUENBIDIwMTEwHhcNMjMxMTE2MTkwOTAwWhcNMjQxMTE0MTkwOTAwWjB0MQsw
# CQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9u
# ZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMR4wHAYDVQQDExVNaWNy
# b3NvZnQgQ29ycG9yYXRpb24wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
# AQDOS8s1ra6f0YGtg0OhEaQa/t3Q+q1MEHhWJhqQVuO5amYXQpy8MDPNoJYk+FWA
# hePP5LxwcSge5aen+f5Q6WNPd6EDxGzotvVpNi5ve0H97S3F7C/axDfKxyNh21MG
# 0W8Sb0vxi/vorcLHOL9i+t2D6yvvDzLlEefUCbQV/zGCBjXGlYJcUj6RAzXyeNAN
# xSpKXAGd7Fh+ocGHPPphcD9LQTOJgG7Y7aYztHqBLJiQQ4eAgZNU4ac6+8LnEGAL
# go1ydC5BJEuJQjYKbNTy959HrKSu7LO3Ws0w8jw6pYdC1IMpdTkk2puTgY2PDNzB
# tLM4evG7FYer3WX+8t1UMYNTAgMBAAGjggFzMIIBbzAfBgNVHSUEGDAWBgorBgEE
# AYI3TAgBBggrBgEFBQcDAzAdBgNVHQ4EFgQURxxxNPIEPGSO8kqz+bgCAQWGXsEw
# RQYDVR0RBD4wPKQ6MDgxHjAcBgNVBAsTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEW
# MBQGA1UEBRMNMjMwMDEyKzUwMTgyNjAfBgNVHSMEGDAWgBRIbmTlUAXTgqoXNzci
# tW2oynUClTBUBgNVHR8ETTBLMEmgR6BFhkNodHRwOi8vd3d3Lm1pY3Jvc29mdC5j
# b20vcGtpb3BzL2NybC9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3JsMGEG
# CCsGAQUFBwEBBFUwUzBRBggrBgEFBQcwAoZFaHR0cDovL3d3dy5taWNyb3NvZnQu
# Y29tL3BraW9wcy9jZXJ0cy9NaWNDb2RTaWdQQ0EyMDExXzIwMTEtMDctMDguY3J0
# MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggIBAISxFt/zR2frTFPB45Yd
# mhZpB2nNJoOoi+qlgcTlnO4QwlYN1w/vYwbDy/oFJolD5r6FMJd0RGcgEM8q9TgQ
# 2OC7gQEmhweVJ7yuKJlQBH7P7Pg5RiqgV3cSonJ+OM4kFHbP3gPLiyzssSQdRuPY
# 1mIWoGg9i7Y4ZC8ST7WhpSyc0pns2XsUe1XsIjaUcGu7zd7gg97eCUiLRdVklPmp
# XobH9CEAWakRUGNICYN2AgjhRTC4j3KJfqMkU04R6Toyh4/Toswm1uoDcGr5laYn
# TfcX3u5WnJqJLhuPe8Uj9kGAOcyo0O1mNwDa+LhFEzB6CB32+wfJMumfr6degvLT
# e8x55urQLeTjimBQgS49BSUkhFN7ois3cZyNpnrMca5AZaC7pLI72vuqSsSlLalG
# OcZmPHZGYJqZ0BacN274OZ80Q8B11iNokns9Od348bMb5Z4fihxaBWebl8kWEi2O
# PvQImOAeq3nt7UWJBzJYLAGEpfasaA3ZQgIcEXdD+uwo6ymMzDY6UamFOfYqYWXk
# ntxDGu7ngD2ugKUuccYKJJRiiz+LAUcj90BVcSHRLQop9N8zoALr/1sJuwPrVAtx
# HNEgSW+AKBqIxYWM4Ev32l6agSUAezLMbq5f3d8x9qzT031jMDT+sUAoCw0M5wVt
# CUQcqINPuYjbS1WgJyZIiEkBMIIHejCCBWKgAwIBAgIKYQ6Q0gAAAAAAAzANBgkq
# hkiG9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24x
# EDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlv
# bjEyMDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5
# IDIwMTEwHhcNMTEwNzA4MjA1OTA5WhcNMjYwNzA4MjEwOTA5WjB+MQswCQYDVQQG
# EwJVUzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwG
# A1UEChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSgwJgYDVQQDEx9NaWNyb3NvZnQg
# Q29kZSBTaWduaW5nIFBDQSAyMDExMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC
# CgKCAgEAq/D6chAcLq3YbqqCEE00uvK2WCGfQhsqa+laUKq4BjgaBEm6f8MMHt03
# a8YS2AvwOMKZBrDIOdUBFDFC04kNeWSHfpRgJGyvnkmc6Whe0t+bU7IKLMOv2akr
# rnoJr9eWWcpgGgXpZnboMlImEi/nqwhQz7NEt13YxC4Ddato88tt8zpcoRb0Rrrg
# OGSsbmQ1eKagYw8t00CT+OPeBw3VXHmlSSnnDb6gE3e+lD3v++MrWhAfTVYoonpy
# 4BI6t0le2O3tQ5GD2Xuye4Yb2T6xjF3oiU+EGvKhL1nkkDstrjNYxbc+/jLTswM9
# sbKvkjh+0p2ALPVOVpEhNSXDOW5kf1O6nA+tGSOEy/S6A4aN91/w0FK/jJSHvMAh
# dCVfGCi2zCcoOCWYOUo2z3yxkq4cI6epZuxhH2rhKEmdX4jiJV3TIUs+UsS1Vz8k
# A/DRelsv1SPjcF0PUUZ3s/gA4bysAoJf28AVs70b1FVL5zmhD+kjSbwYuER8ReTB
# w3J64HLnJN+/RpnF78IcV9uDjexNSTCnq47f7Fufr/zdsGbiwZeBe+3W7UvnSSmn
# Eyimp31ngOaKYnhfsi+E11ecXL93KCjx7W3DKI8sj0A3T8HhhUSJxAlMxdSlQy90
# lfdu+HggWCwTXWCVmj5PM4TasIgX3p5O9JawvEagbJjS4NaIjAsCAwEAAaOCAe0w
# ggHpMBAGCSsGAQQBgjcVAQQDAgEAMB0GA1UdDgQWBBRIbmTlUAXTgqoXNzcitW2o
# ynUClTAZBgkrBgEEAYI3FAIEDB4KAFMAdQBiAEMAQTALBgNVHQ8EBAMCAYYwDwYD
# VR0TAQH/BAUwAwEB/zAfBgNVHSMEGDAWgBRyLToCMZBDuRQFTuHqp8cx0SOJNDBa
# BgNVHR8EUzBRME+gTaBLhklodHRwOi8vY3JsLm1pY3Jvc29mdC5jb20vcGtpL2Ny
# bC9wcm9kdWN0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFfMDNfMjIuY3JsMF4GCCsG
# AQUFBwEBBFIwUDBOBggrBgEFBQcwAoZCaHR0cDovL3d3dy5taWNyb3NvZnQuY29t
# L3BraS9jZXJ0cy9NaWNSb29DZXJBdXQyMDExXzIwMTFfMDNfMjIuY3J0MIGfBgNV
# HSAEgZcwgZQwgZEGCSsGAQQBgjcuAzCBgzA/BggrBgEFBQcCARYzaHR0cDovL3d3
# dy5taWNyb3NvZnQuY29tL3BraW9wcy9kb2NzL3ByaW1hcnljcHMuaHRtMEAGCCsG
# AQUFBwICMDQeMiAdAEwAZQBnAGEAbABfAHAAbwBsAGkAYwB5AF8AcwB0AGEAdABl
# AG0AZQBuAHQALiAdMA0GCSqGSIb3DQEBCwUAA4ICAQBn8oalmOBUeRou09h0ZyKb
# C5YR4WOSmUKWfdJ5DJDBZV8uLD74w3LRbYP+vj/oCso7v0epo/Np22O/IjWll11l
# hJB9i0ZQVdgMknzSGksc8zxCi1LQsP1r4z4HLimb5j0bpdS1HXeUOeLpZMlEPXh6
# I/MTfaaQdION9MsmAkYqwooQu6SpBQyb7Wj6aC6VoCo/KmtYSWMfCWluWpiW5IP0
# wI/zRive/DvQvTXvbiWu5a8n7dDd8w6vmSiXmE0OPQvyCInWH8MyGOLwxS3OW560
# STkKxgrCxq2u5bLZ2xWIUUVYODJxJxp/sfQn+N4sOiBpmLJZiWhub6e3dMNABQam
# ASooPoI/E01mC8CzTfXhj38cbxV9Rad25UAqZaPDXVJihsMdYzaXht/a8/jyFqGa
# J+HNpZfQ7l1jQeNbB5yHPgZ3BtEGsXUfFL5hYbXw3MYbBL7fQccOKO7eZS/sl/ah
# XJbYANahRr1Z85elCUtIEJmAH9AAKcWxm6U/RXceNcbSoqKfenoi+kiVH6v7RyOA
# 9Z74v2u3S5fi63V4GuzqN5l5GEv/1rMjaHXmr/r8i+sLgOppO6/8MO0ETI7f33Vt
# Y5E90Z1WTk+/gFcioXgRMiF670EKsT/7qMykXcGhiJtXcVZOSEXAQsmbdlsKgEhr
# /Xmfwb1tbWrJUnMTDXpQzTGCGgkwghoFAgEBMIGVMH4xCzAJBgNVBAYTAlVTMRMw
# EQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVN
# aWNyb3NvZnQgQ29ycG9yYXRpb24xKDAmBgNVBAMTH01pY3Jvc29mdCBDb2RlIFNp
# Z25pbmcgUENBIDIwMTECEzMAAAOvMEAOTKNNBUEAAAAAA68wDQYJYIZIAWUDBAIB
# BQCgga4wGQYJKoZIhvcNAQkDMQwGCisGAQQBgjcCAQQwHAYKKwYBBAGCNwIBCzEO
# MAwGCisGAQQBgjcCARUwLwYJKoZIhvcNAQkEMSIEIKj5Tu3VqJaReFUZVhDUaDdw
# dp9biaJsxm1KTXcsmzndMEIGCisGAQQBgjcCAQwxNDAyoBSAEgBNAGkAYwByAG8A
# cwBvAGYAdKEagBhodHRwOi8vd3d3Lm1pY3Jvc29mdC5jb20wDQYJKoZIhvcNAQEB
# BQAEggEAjoG2oKdOnzbE/qGpD1Gic5ieGYCsvlVH4Q7ANxcbZV3kNBZyPa0Eulo0
# BZlsS3Su+h90s8xSouK4UsJOxI7Cf2yObfboXWq4oro3oCxWswwR8rOL0tt0m5jB
# JZr+FnlULL0r1xYSF2oOiNLsygUVlRxBU+Un60L/+1BXOZM+5FwnBNi2MykdKDlu
# ZD4iWI+q1yCElDaCh8Rr5r24q3yf/+aL0Cre2N1VRqUUNu8VCPqDCN5GVag2zwGN
# 7uholtsQjosTCegDvIpYR3BfJy7cbT/u24gSD7aCDDPVcL5AGO1UFb26YR0eswq+
# kcwjxgtHC9PAL+YDKUEoN0us7yGacKGCF5MwghePBgorBgEEAYI3AwMBMYIXfzCC
# F3sGCSqGSIb3DQEHAqCCF2wwghdoAgEDMQ8wDQYJYIZIAWUDBAIBBQAwggFRBgsq
# hkiG9w0BCRABBKCCAUAEggE8MIIBOAIBAQYKKwYBBAGEWQoDATAxMA0GCWCGSAFl
# AwQCAQUABCBnjzfzA+EiHIUtQ1qpCVnN1QX2o9TzHpJn/U5zU35zUQIGZr4keQWC
# GBIyMDI0MDgxOTE3Mjc1OC45MlowBIACAfSggdGkgc4wgcsxCzAJBgNVBAYTAlVT
# MRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQK
# ExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJTAjBgNVBAsTHE1pY3Jvc29mdCBBbWVy
# aWNhIE9wZXJhdGlvbnMxJzAlBgNVBAsTHm5TaGllbGQgVFNTIEVTTjozNzAzLTA1
# RTAtRDk0NzElMCMGA1UEAxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2VydmljZaCC
# EeowggcgMIIFCKADAgECAhMzAAAB6pokctVZP2FjAAEAAAHqMA0GCSqGSIb3DQEB
# CwUAMHwxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQH
# EwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJjAkBgNV
# BAMTHU1pY3Jvc29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwMB4XDTIzMTIwNjE4NDUz
# MFoXDTI1MDMwNTE4NDUzMFowgcsxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNo
# aW5ndG9uMRAwDgYDVQQHEwdSZWRtb25kMR4wHAYDVQQKExVNaWNyb3NvZnQgQ29y
# cG9yYXRpb24xJTAjBgNVBAsTHE1pY3Jvc29mdCBBbWVyaWNhIE9wZXJhdGlvbnMx
# JzAlBgNVBAsTHm5TaGllbGQgVFNTIEVTTjozNzAzLTA1RTAtRDk0NzElMCMGA1UE
# AxMcTWljcm9zb2Z0IFRpbWUtU3RhbXAgU2VydmljZTCCAiIwDQYJKoZIhvcNAQEB
# BQADggIPADCCAgoCggIBALULX/FIPyAH1fsu52ijatZvaSypoXrlC0mRtCmaxzob
# huDkw6/pY/+4nhc4m8pf9zW3R6PihYGp0YPpVuNdfhPQp/KVO6WvMq2DGfFmHurW
# 4PQPL/DkbQMkM9vqjFCvPq8xXZnfL1nGN9moGcN+oaif/hUMedmF1qzbay9ILkYf
# LCxDYn3Qwzsvh5xjxOcsjzmRddNURJvT23Eva0cxisH4ocLLTx2zfpqfshw4Z9Ga
# EdsWg9rmib1galUpLzF5PsQDBbtZtcv+Wjmn0pFEiMCWwEEcPVN0YG5ysYLdNBdJ
# On2zsOOS+80W5RrQEqzPpSIIvEkZBJmF3aI4lMR8nV/FiTadjpIIqxX5Wa1XlqI/
# Nj+xagVjnjb7POsA+vh6Wu+v24HpyL8pyL/8Q4RFkRRME9cwT+Jr63yOtPbLe6DX
# kxIJW6E6w2ua5kXBpEKtEQPTLPhX3CUxMYcglbnmI0zcc9UknX285K+sI/2WwRwT
# BZkhDUULI86eQzV+zvzzR1qEBrlSY+oyTlYQrHMM9WnTzVflFDocZVTPpl2BDSNx
# Pn0Qb4IoM9EPqbHyi/MilL+v/AQc8q3mQ6FiuPJAddz0ocpNZ9ekBWPVLKq3lfie
# v4yl65u/438+NAQ+vSJgkONLMmuoguEGzmnK1vq/JHwdRUyn6YADiteM7Dja+Qd9
# AgMBAAGjggFJMIIBRTAdBgNVHQ4EFgQUK4FFJaJR5ukXQFTUxMhyiwVuWV4wHwYD
# VR0jBBgwFoAUn6cVXQBeYl2D9OXSZacbUzUZ6XIwXwYDVR0fBFgwVjBUoFKgUIZO
# aHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jcmwvTWljcm9zb2Z0JTIw
# VGltZS1TdGFtcCUyMFBDQSUyMDIwMTAoMSkuY3JsMGwGCCsGAQUFBwEBBGAwXjBc
# BggrBgEFBQcwAoZQaHR0cDovL3d3dy5taWNyb3NvZnQuY29tL3BraW9wcy9jZXJ0
# cy9NaWNyb3NvZnQlMjBUaW1lLVN0YW1wJTIwUENBJTIwMjAxMCgxKS5jcnQwDAYD
# VR0TAQH/BAIwADAWBgNVHSUBAf8EDDAKBggrBgEFBQcDCDAOBgNVHQ8BAf8EBAMC
# B4AwDQYJKoZIhvcNAQELBQADggIBACiDrVZeP37+fFVtfcbfsqC/Kg0Ce67bDceh
# ZmPcfRgJ5Ddv0pJlOFVOFbiIVwesqeEUwFtclfi5AjneQ5ZJpYJpXfELOelG3dzj
# +BKfd287/UY/cwmSkl+CjnoKBL3Ms6I/fWR+alR0+p6RlviK8xHoug9vkc2WrRZs
# GnMVu2xOM2tPJ+qpyoDBzqv30N/ZRBOoNrS/PCkDwLGICDYqVs/IzAE49yv2ElPy
# walf9mEsOHXV1lxtQDNcejVEmitJJ+1Vr2EtafPEbMQZp89TAuagROKE4YuohCUK
# m+v3geJqTQarTBjqV25RCOT+XFngTMDD9wYx6TwndB2I1Ly726NiHUHs0uvq3ciC
# V9JwNXdt1VZ63WK1NSgpVEsiK9EPABPt1EfXcKrfaPYkbkFi79eK1ETxx3NomYNU
# HNiGU+X1Be8L7qpHwjo0g3/33XhtOr9LiDoUXh/V2LFTETiqV9Q8yLEavQW3j9LQ
# /h/CaGz5YdGfrY8HiPfMIeLEokKxGf0hHcTEFApB0yLlq6KoHrFAEANR/4XuFIpl
# 9sDywVIWt4tKqG+P6pRAXzg1zG5rGlslZWmw7XwgvhBu3jkLP9AxrsSYwY2ftrww
# ze5NA6VDLS7pz+OrXXWLUmoyNrJNx5Bk0wEwzkQxzkOvmbdPhsOP1ZM0uA/xIV7c
# SpNpZUw5MIIHcTCCBVmgAwIBAgITMwAAABXF52ueAptJmQAAAAAAFTANBgkqhkiG
# 9w0BAQsFADCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCldhc2hpbmd0b24xEDAO
# BgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jvc29mdCBDb3Jwb3JhdGlvbjEy
# MDAGA1UEAxMpTWljcm9zb2Z0IFJvb3QgQ2VydGlmaWNhdGUgQXV0aG9yaXR5IDIw
# MTAwHhcNMjEwOTMwMTgyMjI1WhcNMzAwOTMwMTgzMjI1WjB8MQswCQYDVQQGEwJV
# UzETMBEGA1UECBMKV2FzaGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UE
# ChMVTWljcm9zb2Z0IENvcnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGlt
# ZS1TdGFtcCBQQ0EgMjAxMDCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB
# AOThpkzntHIhC3miy9ckeb0O1YLT/e6cBwfSqWxOdcjKNVf2AX9sSuDivbk+F2Az
# /1xPx2b3lVNxWuJ+Slr+uDZnhUYjDLWNE893MsAQGOhgfWpSg0S3po5GawcU88V2
# 9YZQ3MFEyHFcUTE3oAo4bo3t1w/YJlN8OWECesSq/XJprx2rrPY2vjUmZNqYO7oa
# ezOtgFt+jBAcnVL+tuhiJdxqD89d9P6OU8/W7IVWTe/dvI2k45GPsjksUZzpcGkN
# yjYtcI4xyDUoveO0hyTD4MmPfrVUj9z6BVWYbWg7mka97aSueik3rMvrg0XnRm7K
# MtXAhjBcTyziYrLNueKNiOSWrAFKu75xqRdbZ2De+JKRHh09/SDPc31BmkZ1zcRf
# NN0Sidb9pSB9fvzZnkXftnIv231fgLrbqn427DZM9ituqBJR6L8FA6PRc6ZNN3SU
# HDSCD/AQ8rdHGO2n6Jl8P0zbr17C89XYcz1DTsEzOUyOArxCaC4Q6oRRRuLRvWoY
# WmEBc8pnol7XKHYC4jMYctenIPDC+hIK12NvDMk2ZItboKaDIV1fMHSRlJTYuVD5
# C4lh8zYGNRiER9vcG9H9stQcxWv2XFJRXRLbJbqvUAV6bMURHXLvjflSxIUXk8A8
# FdsaN8cIFRg/eKtFtvUeh17aj54WcmnGrnu3tz5q4i6tAgMBAAGjggHdMIIB2TAS
# BgkrBgEEAYI3FQEEBQIDAQABMCMGCSsGAQQBgjcVAgQWBBQqp1L+ZMSavoKRPEY1
# Kc8Q/y8E7jAdBgNVHQ4EFgQUn6cVXQBeYl2D9OXSZacbUzUZ6XIwXAYDVR0gBFUw
# UzBRBgwrBgEEAYI3TIN9AQEwQTA/BggrBgEFBQcCARYzaHR0cDovL3d3dy5taWNy
# b3NvZnQuY29tL3BraW9wcy9Eb2NzL1JlcG9zaXRvcnkuaHRtMBMGA1UdJQQMMAoG
# CCsGAQUFBwMIMBkGCSsGAQQBgjcUAgQMHgoAUwB1AGIAQwBBMAsGA1UdDwQEAwIB
# hjAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNX2VsuP6KJcYmjRPZSQW9fO
# mhjEMFYGA1UdHwRPME0wS6BJoEeGRWh0dHA6Ly9jcmwubWljcm9zb2Z0LmNvbS9w
# a2kvY3JsL3Byb2R1Y3RzL01pY1Jvb0NlckF1dF8yMDEwLTA2LTIzLmNybDBaBggr
# BgEFBQcBAQROMEwwSgYIKwYBBQUHMAKGPmh0dHA6Ly93d3cubWljcm9zb2Z0LmNv
# bS9wa2kvY2VydHMvTWljUm9vQ2VyQXV0XzIwMTAtMDYtMjMuY3J0MA0GCSqGSIb3
# DQEBCwUAA4ICAQCdVX38Kq3hLB9nATEkW+Geckv8qW/qXBS2Pk5HZHixBpOXPTEz
# tTnXwnE2P9pkbHzQdTltuw8x5MKP+2zRoZQYIu7pZmc6U03dmLq2HnjYNi6cqYJW
# AAOwBb6J6Gngugnue99qb74py27YP0h1AdkY3m2CDPVtI1TkeFN1JFe53Z/zjj3G
# 82jfZfakVqr3lbYoVSfQJL1AoL8ZthISEV09J+BAljis9/kpicO8F7BUhUKz/Aye
# ixmJ5/ALaoHCgRlCGVJ1ijbCHcNhcy4sa3tuPywJeBTpkbKpW99Jo3QMvOyRgNI9
# 5ko+ZjtPu4b6MhrZlvSP9pEB9s7GdP32THJvEKt1MMU0sHrYUP4KWN1APMdUbZ1j
# dEgssU5HLcEUBHG/ZPkkvnNtyo4JvbMBV0lUZNlz138eW0QBjloZkWsNn6Qo3GcZ
# KCS6OEuabvshVGtqRRFHqfG3rsjoiV5PndLQTHa1V1QJsWkBRH58oWFsc/4Ku+xB
# Zj1p/cvBQUl+fpO+y/g75LcVv7TOPqUxUYS8vwLBgqJ7Fx0ViY1w/ue10CgaiQuP
# Ntq6TPmb/wrpNPgkNWcr4A245oyZ1uEi6vAnQj0llOZ0dFtq0Z4+7X6gMTN9vMvp
# e784cETRkPHIqzqKOghif9lwY1NNje6CbaUFEMFxBmoQtB1VM1izoXBm8qGCA00w
# ggI1AgEBMIH5oYHRpIHOMIHLMQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2FzaGlu
# Z3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENvcnBv
# cmF0aW9uMSUwIwYDVQQLExxNaWNyb3NvZnQgQW1lcmljYSBPcGVyYXRpb25zMScw
# JQYDVQQLEx5uU2hpZWxkIFRTUyBFU046MzcwMy0wNUUwLUQ5NDcxJTAjBgNVBAMT
# HE1pY3Jvc29mdCBUaW1lLVN0YW1wIFNlcnZpY2WiIwoBATAHBgUrDgMCGgMVAInb
# HtxB+OlGyQnxQYhy04KSYSSPoIGDMIGApH4wfDELMAkGA1UEBhMCVVMxEzARBgNV
# BAgTCldhc2hpbmd0b24xEDAOBgNVBAcTB1JlZG1vbmQxHjAcBgNVBAoTFU1pY3Jv
# c29mdCBDb3Jwb3JhdGlvbjEmMCQGA1UEAxMdTWljcm9zb2Z0IFRpbWUtU3RhbXAg
# UENBIDIwMTAwDQYJKoZIhvcNAQELBQACBQDqbeiiMCIYDzIwMjQwODE5MTU1MjAy
# WhgPMjAyNDA4MjAxNTUyMDJaMHQwOgYKKwYBBAGEWQoEATEsMCowCgIFAOpt6KIC
# AQAwBwIBAAICITMwBwIBAAICE6YwCgIFAOpvOiICAQAwNgYKKwYBBAGEWQoEAjEo
# MCYwDAYKKwYBBAGEWQoDAqAKMAgCAQACAwehIKEKMAgCAQACAwGGoDANBgkqhkiG
# 9w0BAQsFAAOCAQEAC6poXQZ3+69kl7rUaDfhNmVVPqHpaWpEsXw1KEvKnsGwRXx2
# kBPfqJUAewY/iX8eCRnLIoZL8jB8/qx3tyEziZza+2KdHFG3pw5fG5cb7vfjhMG8
# 1uJQ2OmsCYvkY0gk0Do+7E3Xvw20iSMjQqZ2AGXPXqB9tXEcnha5+SiUR1ySKcOa
# HmVlPG7/vQMVLHC/LNJLil6kh7xB9TjQWe+ksMYnjqXasoDQ5EngdSREmxyQc4Yh
# m+DVrMwzFlJvBi8hEqp0klFSvrAOQWukKESEQOdLDxWNHZMh1CANDUSSTMNCPZDu
# obgHURQd0QZ7HPNV/WT5suRGbieEPZpclQaW1zGCBA0wggQJAgEBMIGTMHwxCzAJ
# BgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAwDgYDVQQHEwdSZWRtb25k
# MR4wHAYDVQQKExVNaWNyb3NvZnQgQ29ycG9yYXRpb24xJjAkBgNVBAMTHU1pY3Jv
# c29mdCBUaW1lLVN0YW1wIFBDQSAyMDEwAhMzAAAB6pokctVZP2FjAAEAAAHqMA0G
# CWCGSAFlAwQCAQUAoIIBSjAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwLwYJ
# KoZIhvcNAQkEMSIEIKn+od+0ohhi4UjKG0x/h1HS1ZcC2n62e2m6JnWiGqebMIH6
# BgsqhkiG9w0BCRACLzGB6jCB5zCB5DCBvQQgKY+h1eNkNHiLCDSW0sA1cGHkbW4q
# ooi+ryyMp6S4ZngwgZgwgYCkfjB8MQswCQYDVQQGEwJVUzETMBEGA1UECBMKV2Fz
# aGluZ3RvbjEQMA4GA1UEBxMHUmVkbW9uZDEeMBwGA1UEChMVTWljcm9zb2Z0IENv
# cnBvcmF0aW9uMSYwJAYDVQQDEx1NaWNyb3NvZnQgVGltZS1TdGFtcCBQQ0EgMjAx
# MAITMwAAAeqaJHLVWT9hYwABAAAB6jAiBCBe92Igz29PTU9UKxzXeIGeHVClLGWC
# /BmI1Lf4J86nsTANBgkqhkiG9w0BAQsFAASCAgCWOQ6p5m+1qVXxfkbRRXH8Oo9z
# MqkB++defLi3Ji1WmWutNhJMauBGPUZf7XRFQe5oVGMVzY/C+WiUxK5Dlc58VDPj
# 5jNXDf4nKJ7PanJw/uh+SX1mxE0CoergOXQ/gNHldfBmGVDuujUaAemIBFJaM+It
# jqQB2oaWtiW5l1L0Il7TgggH0sD54U7zq3wEU0SoyLw7KycVVyVNZFzCOXYfC+Pf
# +3hPmdePQ9J9JrYIh2hLrYhq8puc9/twaxoGu1fbIQ3J8EkYcEL/1xjNsvSuzi+t
# db2LqNxA1J/ZRSi19rS505LMlwuhiM0bs3Ysu2/i+1VvLYWJVubzv2bASfyCqyeO
# 4CF3jNRJj9pYwIvWisZMHdoO8IZswd2TbkS63Ixt7u3kq7THNgePbj39QzEhGFux
# 2ciW4juIW7TUyPy6k8QxIndao1albC9Q7NpKAW5ho5y1iXr3y0kb3fdokGoEv2w5
# Ih5hmBL/OjxPt82Z6deFrmJgVsUVhh48SXXJVUmaOtGUBW2dckMl4xYfwWJrW/mM
# UV8YIUK78zCTgwsAj5T5QzBktYBo5pCmpNtUnQBmWiLhrTr7/AwoPRHB66QpSeSq
# RlQta11ypAJpbp3hZCb+HKRZzcAaxGty4grKGh0zXUfiCCvmqBthFlHO/CJec7Au
# /Azaxqtbbye2hl+v6Q==
# SIG # End signature block