Skip to content

Instantly share code, notes, and snippets.

@smasterson

smasterson/Get-VMHostInfo.ps1

Created November 11, 2014 21:34
Show Gist options
  • Save smasterson/25862683c8f822917177 to your computer and use it in GitHub Desktop.
Save smasterson/25862683c8f822917177 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
Get-VMHostInfo.ps1
#Requires –Version 3
#Requires -PSSnapin VMware.VimAutomation.Core
<#
.SYNOPSIS
Exports VMware host (ESX/ESXi) information to Excel
.DESCRIPTION
Queries one or more ESX/ESXi servers directly and exports all info to an Excel workbook
A new workbook/file will be created for each host
.PARAMETER Server
The name of one or more ESX/ESXi servers to query
.PARAMETER Path
Path to folder where Excel workbook is saved
.EXAMPLE
.\Get-VMHostInfo.ps1 -server myesxhost -path "E:\Reports"
Gathers info from myesxhost and exports info to an Excel workbook saved in E:\Reports
.EXAMPLE
.\Get-VMHostInfo.ps1 -server "myesxhost","myotheresxhost" -path "E:\Reports"
Gathers info from myesxhost and myotheresxhost, exports info to separate Excel workbooks located in E:\Reports
.EXAMPLE
$servers = Get-Content "E:\myhosts.txt";.\Get-VMHostInfo.ps1 -server $servers -path "E:\Reports"
Gathers a list of ESX/ESXi host names from E:\myhosts.txt and gathers\exports info to separate Excel workbooks located in E:\Reports
.NOTES
Author : Shawn Masterson
Export-Xlsx function from Gilbert van Griensven https://www.itpilgrims.com/2013/01/export-xlsx-extended/
Excel is required to be installed on script host
Tested with ESX 4 and ESXi 4.1 thru 5.5
#>
[CmdletBinding()]
Param (
[parameter(Mandatory=$true)]
[String[]]
$server,
[parameter(Mandatory=$true)]
[String]
$path
)
### Supporting function ###
Function Export-Xlsx {
<#
.SYNOPSIS
Exports objects to an Excel workbook
.DESCRIPTION
Exports objects to an Excel workbook and applies cosmetics. Optionally add a title, autofilter, autofit and a chart.
Allows for export to .xls and .xlsx format. If .xlsx is specified but not available (Excel 2003) the data will be exported to .xls.
.PARAMETER InputObject
The data to be exported to Excel
.PARAMETER Path
The path of the Excel file. Defaults to %HomeDrive%\Export.xlsx.
.PARAMETER WorksheetName
The name of the worksheet. Defaults to filename in $Path without extension.
.PARAMETER ExpandArrayValues
Joins an array value to a newline separated list.
.PARAMETER ChartType
Name of an Excel chart to be added.
.PARAMETER TableStyle
Apply a style to the created table. Does not work in Excel 2003.
For an overview of styles see http://msdn.microsoft.com/fr-fr/library/documentformat.openxml.spreadsheet.tablestyle.aspx
The Pivot styles are not used in this function.
.PARAMETER Title
Adds a title to the worksheet.
.PARAMETER SheetPosition
Adds the worksheet either to the 'begin' or 'end' of the Excel file.
.PARAMETER TransposeColumnProperty
Selects a property of the input object which will be moved to the top row of the transposed table.
.PARAMETER ChartOnNewSheet
Adds a chart to a new worksheet instead of to the worksheet containing data.
The Chart will be placed after the sheet containing data.
.PARAMETER AppendWorksheet
Appends a worksheet to an existing Excel file.
.PARAMETER Borders
Adds borders to all cells. Defaults to True.
.PARAMETER HeaderColor
Applies background color to the header row. Defaults to True.
.PARAMETER AutoFit
Apply autofit to columns. Defaults to True.
.PARAMETER AutoFilter
Apply autofilter. Defaults to True.
.PARAMETER PassThru
Returns file object of the generated file.
.PARAMETER Force
Overwrites existing Excel sheet. When this switch is not used but the Excel file already exists, a new file with datestamp will be generated.
.PARAMETER Transpose
Transposes the data in Excel. This will automatically disable AutoFilter and HeaderColor.
.PARAMETER FreezePanes
Freezes the title row.
.EXAMPLE
Get-Process | Export-Xlsx -Path D:\Data\ProcessList.xlsx
Exports a list of running processes to Excel
.EXAMPLE
Get-ADuser -Filter {enabled -ne $True} | Select-Object Name,Surname,GivenName,DistinguishedName | Export-Xlsx -Path 'D:\Data\Disabled Users.xlsx' -Title 'Disabled users of Contoso.com'
Export all disabled AD users to Excel with optional title
.EXAMPLE
Get-Process | Sort-Object CPU -Descending | Export-Xlsx -Path D:\Data\Processes_by_CPU.xlsx
Export a sorted processlist to Excel
.EXAMPLE
Export-Xlsx (Get-Process) -AutoFilter:$False -PassThru | Invoke-Item
Export a processlist to %HomeDrive%\Export.xlsx with AutoFilter disabled, and open the Excel file
.NOTES
Author : Gilbert van Griensven
Based on http://www.lucd.info/2010/05/29/beyond-export-csv-export-xls/
#>
[CmdletBinding(DefaultParametersetName="Default")]
Param (
[Parameter(Position=0,Mandatory=$True,ValueFromPipeline=$True)]
[ValidateNotNullOrEmpty()]
$InputObject,
[ValidateScript({
$ReqExt = [System.IO.Path]::GetExtension($_)
($ReqExt -eq ".xls") -or
($ReqExt -eq ".xlsx")
})]
$Path=(Join-Path $env:HomeDrive "Export.xlsx"),
$WorksheetName = [System.IO.Path]::GetFileNameWithoutExtension($Path),
[Switch] $AppendWorksheet,
[ValidateSet("begin","end")] $SheetPosition="begin",
$Title,
[Switch] $AutoFit=$True,
[Switch] $AutoFilter=$True,
[Switch] $FreezePanes,
[Switch] $Transpose,
[String] $TransposeColumnProperty,
[Switch] $ExpandArrayValues,
[PSObject] $ChartType,
[Switch] $ChartOnNewSheet,
[Parameter(ParameterSetName="CustomStyle")]
[Switch] $Borders=$True,
[Parameter(ParameterSetName="CustomStyle")]
[Switch] $HeaderColor=$True,
[Parameter(ParameterSetName="TableStyle")]
[String] $TableStyle,
[Switch] $Force,
[Switch] $PassThru
)
DynamicParam {
# Adds custom argument completers for 'ChartType' and 'TableStyle' parameters for this function only
If ([Reflection.Assembly]::LoadWithPartialName("Microsoft.Office.Interop.Excel") -ne $Null) {
$Completion_xlChartType = {
Param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameter)
[Enum]::GetValues([Microsoft.Office.Interop.Excel.XlChartType]) | % {
New-Object System.Management.Automation.CompletionResult $_, $_, 'ParameterValue', "$($_)"
}
}
$Completion_xlTableStyle = {
Param($commandName, $parameterName, $wordToComplete, $commandAst, $fakeBoundParameter)
1..28 | % {
@("TableStyleMedium$($_)")
If ($_ -le 21) { @("TableStyleLight$($_)") }
If ($_ -le 11) { @("TableStyleDark$($_)") }
} |
Sort-Object | % {
New-Object System.Management.Automation.CompletionResult $_, $_, 'ParameterValue', "$($_)"
}
}
If (!($global:options)) { $global:options = @{CustomArgumentCompleters = @{};NativeArgumentCompleters = @{}} }
$global:options['CustomArgumentCompleters']['Export-Xlsx:ChartType'] = $Completion_xlChartType
$global:options['CustomArgumentCompleters']['Export-Xlsx:TableStyle'] = $Completion_xlTableStyle
$function:tabexpansion2 = $function:tabexpansion2 -replace 'End\r\n{','End { If ($Null -ne $options) {$options += $global:options} Else {$options = $global:options}'
}
}
Begin {
Function Convert-NumberToA1 {
Param([parameter(Mandatory=$true)] [int]$number)
$a1Value = $null
While ($number -gt 0) {
$multiplier = [int][system.math]::Floor(($number / 26))
$charNumber = $number - ($multiplier * 26)
If ($charNumber -eq 0) { $multiplier-- ; $charNumber = 26 }
$a1Value = [char]($charNumber + 96) + $a1Value
$number = $multiplier
}
Write-Verbose "Converted '$($number)' to '$($a1Value)'"
Return $a1Value
}
Function Using-Culture ([System.Globalization.CultureInfo]$Culture, [ScriptBlock]$Script) {
$OldCulture = [System.Threading.Thread]::CurrentThread.CurrentCulture
Trap { [System.Threading.Thread]::CurrentThread.CurrentCulture = $OldCulture }
[System.Threading.Thread]::CurrentThread.CurrentCulture = $Culture
$ExecutionContext.InvokeCommand.InvokeScript($Script)
[System.Threading.Thread]::CurrentThread.CurrentCulture = $OldCulture
}
$Path = [System.IO.Path]::GetFullPath($Path)
$Script:WorkingData = @()
}
Process {
$Script:WorkingData += $InputObject
}
End {
If ($Script:WorkingData.Count -eq 0) {
$ExceptionMessage = New-Object System.FormatException "Input object is empty. Nothing to export to Excel."
Throw $ExceptionMessage
}
$Props = $Script:WorkingData[0].PSObject.properties | % { $_.Name }
Write-Verbose "$($Props.Count) object properties detected"
If ($Transpose) {
Write-Verbose "Setting up for transposed data collection"
If (($TransposeColumnProperty) -and ($Props -contains $TransposeColumnProperty)) {
$Props = $Props | ? {$_ -ne $TransposeColumnProperty}
$Rows = 1
} Else {
$TransposeColumnProperty = $Null
$HeaderColor = $False
}
$Rows += $Props.Count
$Cols = $Script:WorkingData.Count+1
$AutoFilter = $False
} Else {
Write-Verbose "Setting up for data collection"
$Rows = $Script:WorkingData.Count+1
$Cols = $Props.Count
}
Write-Verbose "Input object has $($Rows) rows and $($Cols) columns"
$A1Cols = Convert-NumberToA1 $Cols
$Array = New-Object 'object[,]' $Rows,$Cols
$Col = 0
$Row = 0
Write-Verbose "Storing object properties as data headers into array"
If (($Transpose) -and ($TransposeColumnProperty)) {
$Array[$Row,$Col] = $TransposeColumnProperty
$Row++
}
$Props | % {
$Array[$Row,$Col] = $_.ToString()
If ($Transpose) {
$Row++
} Else {
$Col++
}
}
Write-Verbose "Storing object data into array"
$Row = 1
$Script:WorkingData | % {
$Item = $_
$Col = 0
$Props | % {
If (($Transpose) -and ($TransposeColumnProperty) -and ($Col -eq 0)) {
$Array[$Col,$Row] = $Item.($TransposeColumnProperty).ToString()
$Col++
}
If ($Item.($_) -eq $Null) {
If ($Transpose) {
$Array[$Col,$Row] = ""
} Else {
$Array[$Row,$Col] = ""
}
} Else {
If (($Item.($_) -is [System.Array]) -and ($ExpandArrayValues)) {
$ItemData = [String]::Join("`r`n",$Item.($_))
} Else {
$ItemData = $Item.($_).ToString()
}
If ($Transpose) {
$Array[$Col,$Row] = $ItemData
} Else {
$Array[$Row,$Col] = $ItemData
}
}
$Col++
}
$Row++
}
Using-Culture en-US {
Write-Verbose "Attempting to start Excel as COM object"
Try { $ExcelApplication = New-Object -ComObject Excel.Application }
Catch {
$ExceptionMessage = New-Object System.FormatException "Could not create COM object. Please ensure Microsoft Excel is installed."
Throw $ExceptionMessage
}
$ExcelApplication.DisplayAlerts = $False
$ExcelApplicationFixedFormat = [Microsoft.Office.Interop.Excel.XLFileFormat]::xlWorkbookNormal
If ([System.IO.Path]::GetExtension($Path) -eq '.xlsx') {
Write-Verbose "Selected file format: .xlsx"
If ($ExcelApplication.Version -lt 12) {
Write-Verbose "Current Excel version `($($ExcelApplication.Version)`)does not support .xlsx format. Switching to .xls format"
$Path = [System.IO.Path]::ChangeExtension($Path,".xls")
} Else {
$ExcelApplicationFixedFormat = [Microsoft.Office.Interop.Excel.XLFileFormat]::xlWorkbookDefault
}
} Else {
Write-Verbose "Selected file format: .xls"
}
If (Test-Path -Path $Path -PathType "Leaf") {
Write-Verbose "$($Path) exists"
If ($AppendWorkSheet) {
Write-Verbose "AppendWorkSheet parameter received. Attempting to open $($Path)"
$Workbook = $ExcelApplication.Workbooks.Open($Path)
If ($Workbook.ReadOnly) {
$Workbook.Close()
$ExcelApplication.Quit()
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($Workbook)) {}
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($ExcelApplication)) {}
[GC]::Collect()
$ExceptionMessage = New-Object System.FormatException "The file $($Path) is marked read-only. Please check NTFS permissions and ensure the file is not open in other applications"
Throw $ExceptionMessage
}
If ($SheetPosition -eq "end") {
Write-Verbose "Setting sheet position to 'end'"
$Workbook.Worksheets.Add([System.Reflection.Missing]::Value,$Workbook.Sheets.Item($Workbook.Sheets.Count)) | Out-Null
} Else {
Write-Verbose "Setting sheet position to 'begin'"
$Workbook.Worksheets.Add($Workbook.Worksheets.Item(1)) | Out-Null
}
} Else {
If (!($Force)) {
$Path = $Path.Insert($Path.LastIndexOf(".")," - $(Get-Date -Format "ddMMyyyy-HHmm")")
Write-Verbose "No Force parameter specified. Target file is changed to: $($Path)"
} Else {
Write-Verbose "Force parameter specified. Overwriting existing file"
}
Write-Verbose "Adding new workbook"
$Workbook = $ExcelApplication.Workbooks.Add()
While ($Workbook.Worksheets.Count -gt 1) { $Workbook.Worksheets.Item(1).Delete() }
}
} Else {
Write-Verbose "$($Path) does not exist. Adding new workbook"
$Workbook = $ExcelApplication.Workbooks.Add()
While ($Workbook.Worksheets.Count -gt 1) { $Workbook.Worksheets.Item(1).Delete() }
}
$Worksheet = $Workbook.ActiveSheet
Try { $Worksheet.Name = $WorksheetName }
Catch {
Write-Verbose "!!! Unable to set worksheet name to $($WorksheetName)"
}
If ($Title) {
Write-Verbose "Adding title"
$Worksheet.Cells.Item(1,1) = $Title
$TitleRange = $Worksheet.Range("a1","$($A1Cols)2")
$TitleRange.Font.Size = 18
$TitleRange.Font.Bold=$True
$TitleRange.Font.Name = "Cambria"
$TitleRange.Font.ThemeFont = 1
$TitleRange.Font.ThemeColor = 4
$TitleRange.Font.ColorIndex = 55
$TitleRange.Font.Color = 8210719
$TitleRange.Merge()
$TitleRange.VerticalAlignment = -4160
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($TitleRange)) {}
$UsedRange = $Worksheet.Range("a3","$($A1Cols)$($Rows + 2)")
If ($HeaderColor) {
Write-Verbose "Setting header row background color"
$Worksheet.Range("a3","$($A1Cols)3").Interior.ColorIndex = 48
$Worksheet.Range("a3","$($A1Cols)3").Font.Bold = $True
}
If (($FreezePanes) -and ((($Transpose) -and ($TransposeColumnProperty)) -or (!($Transpose)))) {
Write-Verbose "Freezing panes"
$Worksheet.Range("a4:a4").Select() | Out-Null
$ExcelApplication.ActiveWindow.FreezePanes = $True
}
} Else {
$UsedRange = $Worksheet.Range("a1","$($A1Cols)$($Rows)")
If ($HeaderColor) {
Write-Verbose "Setting header row background color"
$Worksheet.Range("a1","$($A1Cols)1").Interior.ColorIndex = 48
$Worksheet.Range("a1","$($A1Cols)1").Font.Bold = $True
}
If (($FreezePanes) -and ((($Transpose) -and ($TransposeColumnProperty)) -or (!($Transpose)))) {
Write-Verbose "Freezing panes"
$Worksheet.Range("a2:a2").Select() | Out-Null
$ExcelApplication.ActiveWindow.FreezePanes = $True
}
}
Write-Verbose "Transferring array data to selected range in Excel"
$UsedRange.Value2 = $Array
$UsedRange.HorizontalAlignment = -4131
$UsedRange.VerticalAlignment = -4160
If ($Borders) {
Write-Verbose "Adding borders"
$UsedRange.Borders.LineStyle = 1
$UsedRange.Borders.Weight = 2
}
If ($AutoFilter) {
Write-Verbose "Applying autofilter"
$UsedRange.AutoFilter() | Out-Null
}
If ($AutoFit) {
Write-Verbose "Applying autofit"
$Worksheet.UsedRange.EntireColumn.AutoFit() | Out-Null
$Worksheet.UsedRange.EntireRow.AutoFit() | Out-Null
}
If (($TableStyle) -and ($ExcelApplication.Version -ge 12)) {
Write-Verbose "Applying table style '$($TableStyle)'"
$ListObject = $Worksheet.ListObjects.Add([Microsoft.Office.Interop.Excel.XlListObjectSourceType]::xlSrcRange, $UsedRange, $Null, [Microsoft.Office.Interop.Excel.XlYesNoGuess]::xlYes, $Null)
$ListObject.TableStyle = $TableStyle
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($ListObject)) {}
}
If ($ChartType) {
Try {
Write-Verbose "Attempting to add chart of type '$($ChartType)'"
[Microsoft.Office.Interop.Excel.XlChartType]$ChartType = $ChartType
If ($ChartOnNewSheet) {
Write-Verbose "Adding chart to new worksheet"
$Workbook.Charts.Add().ChartType = $ChartType
$Workbook.ActiveChart.setSourceData($UsedRange)
Try { $Workbook.ActiveChart.Name = "$($WorksheetName) - Chart" }
Catch { }
$Workbook.ActiveChart.Move([System.Reflection.Missing]::Value,$Workbook.Sheets.Item($Worksheet.Name))
} Else {
Write-Verbose "Adding chart to current sheet"
$Worksheet.Shapes.AddChart($ChartType).Chart.setSourceData($UsedRange) | Out-Null
}
}
Catch {
Write-Verbose "!!! '$($ChartType)' is not a valid Excel chart type. Use tab expansion to choose between valid chart types."
}
}
Write-Verbose "Saving Excel workbook to $($Path)"
$Workbook.Worksheets.Item(1).Select()
Try { $Workbook.SaveAs($Path,$ExcelApplicationFixedFormat) }
Catch { $ExceptionMessage = New-Object System.FormatException "Unable to save to $($Path). Please ensure you have write access." }
Write-Verbose "Closing Excel and cleaning up references"
$Workbook.Close()
$ExcelApplication.Quit()
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($UsedRange)) {}
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($Worksheet)) {}
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($Workbook)) {}
While ([System.Runtime.Interopservices.Marshal]::ReleaseComObject($ExcelApplication)) {}
[GC]::Collect()
If ($ExceptionMessage) { Throw $ExceptionMessage }
}
If ($PassThru) { Return Get-Item $Path }
}
}
### Main script begin ###
# Test path
If (!(Test-Path $path)) {
Write-Host "Path not found - $path" -ForegroundColor Red
Exit
}
# Obtain Credentials
$creds = Get-Credential -Message "Enter ESX/ESXi host credentials used to connect" -UserName root
# Cycle through servers gathering and exporting info
Foreach ($ESX in $Server) {
# Create full path to Excel workbook
$FullPath = $Path.Trimend('\') + "\HostInfo_" + $ESX + "_" + (Get-Date -Format MM-dd-yyyy) + ".xlsx"
# Connect to ESX/ESXi host
$connection = Connect-VIServer $ESX -Credential $creds
# Ensure connection
If ($connection) {
Write-Host "Connected to $ESX"
# Get ESX(i) Host Info
$VMHost = Get-VMHost $ESX
$VMHostProp = [ordered]@{}
$VMHostProp.Name = $VMHost.NetworkInfo.HostName
$VMHostProp."Domain Name" = $VMHost.NetworkInfo.DomainName
$VMHostProp.Hypervisor = $VMHost.Extensiondata.Config.Product.FullName
$VMHostProp.License = $VMHost.LicenseKey
$VMHostProp.Vendor = $VMHost.Manufacturer
$VMHostProp.Model = $VMHost.Model
$VMHostProp."BIOS Version" = $VMHost.Extensiondata.Hardware.BiosInfo.BiosVersion
$VMHostProp."CPU Model" = $VMHost.ProcessorType
$VMHostProp."CPU Count" = $VMHost.ExtensionData.Summary.Hardware.NumCpuPkgs
$VMHostProp."Total Cores" = $VMHost.ExtensionData.Summary.Hardware.numCpuCores
$VMHostProp."Total Threads" = $VMHost.ExtensionData.Summary.Hardware.numCpuThreads
$VMHostProp."Hyperthreading Enabled" = $VMHost.HyperThreadingActive
$VMHostProp."CPU Current Usage (Mhz)" = $VMHost.CpuUsageMhz
$VMHostProp."Memory (GB)" = [Math]::Round($VMHost.MemoryTotalGB,0)
$VMHostProp."Memory Current Usage (GB)" = [Math]::Round($VMHost.MemoryUsageGB,0)
$VMHostProp."FC HBAs" = ($VMHost | Get-VMHostHba | where {$_.Type -eq "FibreChannel"}).Count
$VMHostProp."iSCSI HBAs" = ($VMHost | Get-VMHostHba | where {$_.Type -eq "IScsi"}).Count
$VMHostProp."Physical NICs" = $VMHost.ExtensionData.Config.Network.Pnic.Count
If ($VMHost.NetworkInfo.VMKernelGateway) {
$VMHostProp."VMKernel Gateway" = $VMHost.NetworkInfo.VMKernelGateway
} Else {
$VMHostProp."Console Gateway" = $VMHost.NetworkInfo.ConsoleGateway
}
Try {
$domainStatus = ""
$domainStatus = $VMHost | Get-VMHostAuthentication -ErrorAction Stop
$VMHostProp."Authentication Domain" = If ($domainStatus.Domain){$domainStatus.Domain} Else {"Not Configured"}
$VMHostProp."Authentication Domain Status" = If ($domainStatus.DomainMembershipStatus){$domainStatus.DomainMembershipStatus} Else {"Unknown"}
$VMHostProp."Trusted Domains" = If ($domainStatus.Trusteddomains) {$domainStatus | Select -ExpandProperty TrustedDomains | Out-String} Else {"None"}
} Catch {}
$VMHostProp."DNS Server(s)" = $VMHost.ExtensionData.Config.Network.DnsConfig.Address | Out-String
$VMHostProp."Search Domain(s)" = $VMHost.NetworkInfo.SearchDomain | Out-String
$VMHostProp.TimeZone = $VMHost.TimeZone
$VMHostProp."NTP Server(s)" = $VMHost | Get-VMHostNtpServer | Out-String
Try {
$VMHostProp."Syslog Server(s)" = $VMHost | Get-VMHostSysLogServer -ErrorAction Stop | %{$_.Host + ":" + $_.Port} | Out-String
} Catch {
$VMHostProp."Syslog Server(s)" = "Unavailable"
}
Try {
$VMHostProp."Firewall Default Allow Incoming" = $VMHost | Get-VMHostFirewallDefaultPolicy -ErrorAction Stop | Select -ExpandProperty IncomingEnabled
$VMHostProp."Firewall Default Allow Outgoing" = $VMHost | Get-VMHostFirewallDefaultPolicy -ErrorAction Stop | Select -ExpandProperty OutgoingEnabled
} Catch {}
$VMHostProp."VM Count" = ($VMHost | Get-VM).Count
$VMHostProp."Report Created" = Get-Date
$VMHostInfo = New-Object –TypeName PSObject –Prop $VMHostProp
$VMHostInfo | Export-Xlsx -Path $FullPath -WorksheetName "ESX(i) Info" -Title "VMHost Information" -Transpose -Borders:$false -Force
# Get HBA Info
$HBAInfo = @()
$HBAs = $VMHost | Get-VMHostHba
Foreach ($HBA in $HBAs) {
$HBAProp = [ordered]@{}
$HBAProp.Device = $HBA.Device
$HBAProp."HBA Model" = $HBA.Model
$HBAProp."HBA Type" = $HBA.Type
$HBAProp.Driver = $HBA.Driver
$HBAProp.PCI = $HBA.PCI
$NWWN = $null
$NWWNFormatted = $null
[String] $NWWN = "{0:x}" -f $HBA.NodeWorldWideName
If ($NWWN) {
For ($i=0;$i -lt 8;$i++)
{
$NWWNFormatted += "{0}:" -f $($NWWN.SubString($i * 2, 2))
}
$NWWNFormatted = $NWWNFormatted.SubString(0, $NWWNFormatted.Length - 1)
}
$PWWN = $null
$PWWNFormatted = $null
[String] $PWWN = "{0:x}" -f $HBA.PortWorldWideName
If ($PWWN) {
For ($i=0;$i -lt 8;$i++)
{
$PWWNFormatted += "{0}:" -f $($PWWN.SubString($i * 2, 2))
}
$PWWNFormatted = $PWWNFormatted.SubString(0, $PWWNFormatted.Length - 1)
}
$HBAProp.NWWN = $NWWNFormatted
$HBAProp.PWWN = $PWWNFormatted
$HBAProp."Software Based" = $HBA.IsSoftwareBased
$HBAProp."iSCSI Name" = $HBA.IScsiName
$HBAProp."iSCSI Alias" = $HBA.IScsiAlias
$HBAProp.Status = $HBA.Status
$HBATemp = New-Object –TypeName PSObject –Prop $HBAProp
$HBAInfo += $HBATemp
}
If ($HBAInfo) {
$HBAInfo | Export-Xlsx -Path $FullPath -WorksheetName "HBA Info" -Title "HBA Info" -AppendWorksheet -SheetPosition "end"
}
# Get Host Disks
$diskInfo = @()
$disks = $VMHost | Get-VMHostDisk
ForEach ($disk in $disks) {
$diskProp = [ordered]@{}
$diskProp."Device Name" = $disk.DeviceName
$diskProp."SCSI LUN" = $disk.ScsiLun
$diskProp.Cylinders = $disk.Cylinders
$diskProp.Heads = $disk.Heads
$diskProp.Sectors = $disk.Sectors
$diskProp.TotalSectors = $disk.TotalSectors
$diskTemp = New-Object –TypeName PSObject –Prop $diskProp
$diskInfo += $diskTemp
}
If ($diskInfo) {
$diskInfo | Sort "Device Name" | Export-Xlsx -Path $FullPath -WorksheetName "Disks" -Title "Host Disks" -AppendWorksheet -SheetPosition "end"
}
# Get SCSI LUNs
$lunInfo = @()
$scsiLuns = $VMHost | Get-ScsiLun
ForEach ($scsiLun in $scsiLuns) {
$scsiLunProp = [ordered]@{}
$scsiLunProp."Runtime Name" = $scsiLun.RuntimeName
$scsiLunProp."Canonical Name" = $scsiLun.CanonicalName
$scsiLunProp."Device Path" = $scsiLun.ConsoleDeviceName
$scsiLunProp.Type = $scsiLun.LunType
$scsiLunProp.Vendor = $scsiLun.Vendor
$scsiLunProp.Model = $scsiLun.Model
$scsiLunProp."Serial Number" = $scsiLun.SerialNumber
$scsiLunProp."Capacity (GB)" = [Math]::Round($scsiLun.CapacityGB,2)
$scsiLunProp."Multipath Policy" = $scsiLun.MultipathPolicy
$scsiLunProp.Local = $scsiLun.IsLocal
$scsiLunProp.SSD = $scsiLun.ExtensionData.Ssd
$scsiLunProp.UUID = $scsiLun.ExtensionData.Uuid
$scsiLunTemp = New-Object –TypeName PSObject –Prop $scsiLunProp
$lunInfo += $scsiLunTemp
}
If ($lunInfo) {
$lunInfo | Sort Type | Export-Xlsx -Path $FullPath -WorksheetName "SCSI LUNs" -Title "SCSI LUNs" -AppendWorksheet -SheetPosition "end"
}
# Get Multipathing Info
$pathInfo = @()
$luns = $VMhost.ExtensionData.config.storagedevice.multipathinfo.lun
ForEach ($lun in $luns) {
$lunName = $lun.Id
$lunPolicy = $lun.policy.policy
$lunPaths = $lun.path
Foreach ($lunPath in $lunPaths) {
$pathProp = [ordered]@{}
$pathProp."LUN ID" = $lunName
$pathProp."LUN Policy" = $lunPolicy
$pathProp.State = $lunPath.pathstate
$pathProp."Path Name" = $lunPath.Name
$pathProp."Adapter Name" = ($lunPath.Name).Split("-")[0]
$pathProp."Target Name" = ($lunPath.Name).Split("-")[1]
$pathProp."LUN Name" = ($lunPath.Name).Split("-")[2]
$pathTemp = New-Object –TypeName PSObject –Prop $pathProp
$pathInfo += $pathTemp
}
}
If ($pathInfo) {
$pathInfo | Sort "LUN ID" | Export-Xlsx -Path $FullPath -WorksheetName "Multipath Info" -Title "Multipath Info" -AppendWorksheet -SheetPosition "end"
}
# Get iSCSI HBA Targets
$iscsiTargetInfo = @()
$iscsiTargets = Get-IScsiHbaTarget -Server $ESX
ForEach ($iscsiTarget in $iscsiTargets) {
$iscsiTargetProp = [ordered]@{}
$iscsiTargetProp.Name = $iscsiTarget.Name
$iscsiTargetProp."iSCSI Name" = $iscsiTarget.IScsiName
$iscsiTargetProp.Address = $iscsiTarget.Address
$iscsiTargetProp.Port = $iscsiTarget.Port
$iscsiTargetProp.Authentication = $iscsiTarget.AuthenticationProperties
$iscsiTargetProp.Type = $iscsiTarget.Type
$iscsiTargetProp."iSCSI HBA Name" = $iscsiTarget.IScsiHbaName
$iscsiTargetTemp = New-Object –TypeName PSObject –Prop $iscsiTargetProp
$iscsiTargetInfo += $iscsiTargetTemp
}
If ($iscsiTargetInfo) {
$iscsiTargetInfo | Sort Name | Export-Xlsx -Path $FullPath -WorksheetName "iSCSI Targets" -Title "iSCSI HBA Targets" -AppendWorksheet -SheetPosition "end"
}
# Get Host Diagnostic Partitions
$diagInfo = @()
$diags = $VMHost | Get-VMHostDiagnosticPartition
ForEach ($diag in $diags) {
$diagProp = [ordered]@{}
$diagProp."Canonical Name" = $diag.CanonicalName
$diagProp."Diagnostic Type" = $diag.DiagnosticType
$diagProp."Storage Type" = $diag.StorageType
$diagProp.Slots = $diag.SlotCount
$diagProp.Active = $diag.Active
$diagTemp = New-Object –TypeName PSObject –Prop $diagProp
$diagInfo += $diagTemp
}
If ($diagInfo) {
$diagInfo | Sort Active -Descending | Export-Xlsx -Path $FullPath -WorksheetName "Diagnostic Partitions" -Title "Diagnostic Partitions" -AppendWorksheet -SheetPosition "end"
}
# Get Datastore Info
$DSInfo = @()
$DSs = $VMHost | Get-Datastore
Foreach ($DS in $DSs) {
$DSProp = [ordered]@{}
$DSProp.Name = $DS.Name
$DSProp.Type = $DS.Type
$DSProp."Size (GB)" = [Math]::Round($DS.CapacityGB,2)
$DSProp."Used (GB)" = [Math]::Round($DS.CapacityGB - $DS.FreeSpaceGB,2)
$DSProp."Free (GB)" = [Math]::Round($DS.FreeSpaceGB,2)
$usedPerc = ($DS.CapacityGB - $DS.FreeSpaceGB)/$DS.CapacityGB
$DSProp."Used %" = "{0:P1}" -f $usedPerc
$DSProp."Mount Point" = $DS.ExtensionData.Info.Url
$DSProp.Extents = If ($DS.Type -eq "VMFS"){$DS.ExtensionData.Info.Vmfs.Extent.DiskName}
ElseIf ($DS.Type -eq "NFS"){$DS.ExtensionData.Info.Nas.RemoteHost + ":" + $DS.ExtensionData.Info.Nas.RemotePath}
$DSProp.StorageIOControlEnabled = $DS.StorageIOControlEnabled
$DSProp.FileSystemVersion = $DS.FileSystemVersion
$DSProp.BlockSize = $DS.ExtensionData.Info.Vmfs.BlockSizeMB
$DSProp.SSD = $DS.ExtensionData.Info.Vmfs.Ssd
$DSProp.Local = $DS.ExtensionData.Info.Vmfs.Local
$DSProp."VM Count" = ($DS | Get-VM).Count
$DSProp.State = $DS.State
$DSTemp = New-Object –TypeName PSObject –Prop $DSProp
$DSInfo += $DSTemp
}
If ($DSInfo) {
$DSInfo | Sort Name | Export-Xlsx -Path $FullPath -WorksheetName "Datastores" -Title "Datastores" -AppendWorksheet -SheetPosition "end"
}
# Get Datastore Chart
$DSInfo = @()
Foreach ($DS in $DSs) {
$DSProp = [ordered]@{}
$DSProp.Name = $DS.Name
$DSProp."Used (GB)" = [Math]::Round($DS.CapacityGB - $DS.FreeSpaceGB,2)
$DSProp."Free (GB)" = [Math]::Round($DS.FreeSpaceGB,2)
$DSTemp = New-Object –TypeName PSObject –Prop $DSProp
$DSInfo += $DSTemp
}
If ($DSInfo) {
$DSInfo | Sort Name | Export-Xlsx -Path $FullPath -WorksheetName "Datastores - Chart" -Title "Datastores - Chart" -ChartType xlColumnStacked -AppendWorksheet -SheetPosition "end"
}
# Get Physical NIC Info
$pNICInfo = @()
$NICs = $VMHost | Get-VMHostNetworkAdapter -Physical
Foreach ($NIC in $NICs) {
$NICProp = [ordered]@{}
$NICProp.pNIC = $NIC.DeviceName
$NICProp.Model = ($VMHost.ExtensionData.Hardware.PciDevice | where {$_.Id -eq $NIC.ExtensionData.Pci}).DeviceName
$NICProp.Driver = $NIC.ExtensionData.Driver
$NICProp."Speed (MB)" = $NIC.ExtensionData.LinkSpeed.SpeedMB
$NICProp."Full Duplex" = $NIC.ExtensionData.LinkSpeed.Duplex
$NICProp.MAC = $NIC.Mac
$NICProp."PCI Location" = $NIC.ExtensionData.Pci
$NICProp.vSwitch = ($VMHost | Get-VirtualSwitch | where {$_.Nic -contains $NIC.DeviceName}).Name
$NICTemp = New-Object –TypeName PSObject –Prop $NICProp
$pNICInfo += $NICTemp
}
If ($pNICInfo) {
$pNICInfo | Export-Xlsx -Path $FullPath -WorksheetName "pNIC Info" -Title "Physical NIC Info" -AppendWorksheet -SheetPosition "end"
}
# Get VMKernel Virtual Network Adapter Info
$vNICInfo = @()
$vNICs = $VMHost | Get-VMHostNetworkAdapter -VMKernel
Foreach ($vNIC in $vNICs) {
$vNICProp = [ordered]@{}
$vNICProp.VMKernel = $vNIC.DeviceName
$vNICProp.MAC = $vNIC.Mac
$vNICProp.MTU = $vNIC.Mtu
$vNICProp.IPv6Enabled = $vNIC.IPv6Enabled
$vNICProp.DHCPEnabled = $vNIC.DhcpEnabled
$vNICProp.IP = $vNIC.IP
$vNICProp.SubnetMask = $vNIC.SubnetMask
$vNICProp.PortGroupName = $vNIC.PortGroupName
$vNICProp.MgmtEnabled = $vNIC.ManagementTrafficEnabled
$vNICProp.vMotionEnabled = $vNIC.vMotionEnabled
$vNICProp.FTEnabled = $vNIC.FaultToleranceLoggingEnabled
$vNICProp.VSANEnabled = $vNIC.VsanTrafficEnabled
$vNICTemp = New-Object –TypeName PSObject –Prop $vNICProp
$vNICInfo += $vNICTemp
}
If ($vNICInfo) {
$vNICInfo | Export-Xlsx -Path $FullPath -WorksheetName "VMKernel Info" -Title "VMKernel Info" -AppendWorksheet -SheetPosition "end"
}
# Get Service Console Info
$cNICInfo = @()
$cNICs = $VMHost | Get-VMHostNetworkAdapter -Console
Foreach ($cNIC in $cNICs) {
$cNICProp = [ordered]@{}
$cNICProp.cNIC = $cNIC.DeviceName
$cNICProp.MAC = $cNIC.Mac
$cNICProp.DHCPEnabled = $cNIC.DhcpEnabled
$cNICProp.IP = $cNIC.IP
$cNICProp.SubnetMask = $cNIC.SubnetMask
$cNICProp.PortGroupName = $cNIC.PortGroupName
$cNICTemp = New-Object –TypeName PSObject –Prop $cNICProp
$cNICInfo += $cNICTemp
}
If ($cNICInfo) {
$cNICInfo | Export-Xlsx -Path $FullPath -WorksheetName "Service Console Info" -Title "Service Console Info" -AppendWorksheet -SheetPosition "end"
}
# Get Standard Switch Info
$sSwInfo = @()
$sSwitchs = $VMHost | Get-VirtualSwitch -Standard
Foreach ($sSwitch in $sSwitchs) {
$sSwProp = [ordered]@{}
$sSwProp.Name = $sSwitch.Name
$sSwProp.MTU = $sSwitch.Mtu
$sSwProp."pNIC(s)" = $sSwitch.Nic | Out-String
$sSwProp."Load Balancing" = $sSwitch.ExtensionData.Spec.Policy.NicTeaming.Policy
$sSwProp."Network Failure Detection" = If ($sSwitch.ExtensionData.Spec.Policy.NicTeaming.FailureCriteria.CheckBeacon) {
"Beacon probing"} Else {"Link status only"}
$sSwProp."Notify Switches" = $sSwitch.ExtensionData.Spec.Policy.NicTeaming.NotifySwitches
$sSwProp."Failback" = $sSwitch.ExtensionData.Spec.Policy.NicTeaming.ReversePolicy
$sSwProp."Active pNIC(s)" = $sSwitch.ExtensionData.Spec.Policy.NicTeaming.NicOrder.ActiveNic | Out-String
$sSwProp."Standby pNIC(s)" = $sSwitch.ExtensionData.Spec.Policy.NicTeaming.NicOrder.StandbyNic | Out-String
$sSwProp."Promiscuous Mode" = $sSwitch.ExtensionData.Spec.Policy.Security.AllowPromiscuous
$sSwProp."Mac Address Changes" = $sSwitch.ExtensionData.Spec.Policy.Security.MacChanges
$sSwProp."Forged Transmits" = $sSwitch.ExtensionData.Spec.Policy.Security.ForgedTransmits
$sSwProp."Traffic Shaping Enabled" = $sSwitch.ExtensionData.Spec.Policy.ShapingPolicy.Enabled
$sSwProp."Average Bandwidth" = $sSwitch.ExtensionData.Spec.Policy.ShapingPolicy.AverageBandwidth
$sSwProp."Peak Bandwidth" = $sSwitch.ExtensionData.Spec.Policy.ShapingPolicy.PeakBandwidth
$sSwProp."Burst Size" = $sSwitch.ExtensionData.Spec.Policy.ShapingPolicy.BurstSize
$sSwProp."Portgroup(s)" = $sSwitch | Get-VirtualPortGroup | Select -ExpandProperty Name | Out-String
$sSwTemp = New-Object –TypeName PSObject –Prop $sSwProp
$sSwInfo += $sSwTemp
}
If ($sSwInfo) {
$sSwInfo | Export-Xlsx -Path $FullPath -WorksheetName "Standard Switch Info" -Title "Standard Switch Info" -AppendWorksheet -SheetPosition "end"
}
# Get Distributed Switch Information
$dvSwInfo = @()
$dvSwitchs = $VMHost | Get-VDSwitch
Foreach ($dvSwitch in $dvSwitchs) {
$dvSwProp = [ordered]@{}
$dvSwProp.Name = $dvSwitch.Name
$dvSwProp.MTU = $dvSwitch.Mtu
$dvSwProp."Overall Status" = $dvSwitch.ExtensionData.OverallStatus
$dvSwProp."Config Status" = $dvSwitch.ExtensionData.ConfigStatus
$dvSwProp.Note = "vCenter needed for further info"
$dvSwTemp = New-Object –TypeName PSObject –Prop $dvSwProp
$dvSwInfo += $dvSwTemp
}
If ($dvSwInfo) {
$dvSwInfo | Export-Xlsx -Path $FullPath -WorksheetName "Distributed Switch Info" -Title "Distributed Switch Info" -AppendWorksheet -SheetPosition "end"
}
# Get Standard Portgroup Information
$sPortInfo = @()
$sPortGroups = $VMHost | Get-VirtualPortGroup -Standard
Foreach ($sPortGroup in $sPortGroups) {
$sPortProp = [ordered]@{}
$sPortProp."Virtual Switch" = $sPortGroup.VirtualSwitchName
$sPortProp.Portgroup = $sPortGroup.Name
$sPortProp.VLAN = $sPortGroup.Vlanid
$sPortProp."Load Balancing" = $sPortGroup.ExtensionData.ComputedPolicy.NicTeaming.Policy
$sPortProp."Network Failure Detection" = If ($sPortGroup.ExtensionData.ComputedPolicy.NicTeaming.FailureCriteria.CheckBeacon) {
"Beacon probing"} Else {"Link status only"}
$sPortProp."Notify Switches" = $sPortGroup.ExtensionData.ComputedPolicy.NicTeaming.NotifySwitches
$sPortProp."Failback" = $sPortGroup.ExtensionData.ComputedPolicy.NicTeaming.ReversePolicy
$sPortProp."Active pNIC(s)" = $sPortGroup.ExtensionData.ComputedPolicy.NicTeaming.NicOrder.ActiveNic | Out-String
$sPortProp."Standby pNIC(s)" = $sPortGroup.ExtensionData.ComputedPolicy.NicTeaming.NicOrder.StandbyNic | Out-String
$sPortProp."Promiscuous Mode" = $sPortGroup.ExtensionData.ComputedPolicy.Security.AllowPromiscuous
$sPortProp."Mac Address Changes" = $sPortGroup.ExtensionData.ComputedPolicy.Security.MacChanges
$sPortProp."Forged Transmits" = $sPortGroup.ExtensionData.ComputedPolicy.Security.ForgedTransmits
$sPortProp."Traffic Shaping Enabled" = $sPortGroup.ExtensionData.ComputedPolicy.ShapingPolicy.Enabled
$sPortProp."Average Bandwidth" = $sPortGroup.ExtensionData.ComputedPolicy.ShapingPolicy.AverageBandwidth
$sPortProp."Peak Bandwidth" = $sPortGroup.ExtensionData.ComputedPolicy.ShapingPolicy.PeakBandwidth
$sPortProp."Burst Size" = $sPortGroup.ExtensionData.ComputedPolicy.ShapingPolicy.BurstSize
$sPortProp."VM Count" = ($sPortGroup | Get-VM).Count
$sPortTemp = New-Object –TypeName PSObject –Prop $sPortProp
$sPortInfo += $sPortTemp
}
If ($sPortInfo) {
$sPortInfo | Sort "Virtual Switch", Portgroup | Export-Xlsx -Path $FullPath -WorksheetName "Standard Portgroup Info" -Title "Standard Portgroup Info" -AppendWorksheet -SheetPosition "end"
}
# Get Distributed Portgroup Information
$dvPortInfo = @()
$dvPortGroups = Get-VDPortgroup -Server $ESX
Foreach ($dvPortGroup in $dvPortGroups) {
$dvPortProp = [ordered]@{}
$dvPortProp."Virtual Switch" = $dvPortGroup.VDSwitch
$dvPortProp.Portgroup = $dvPortGroup.Name
$dvPortProp."Port Binding" = $dvPortGroup.PortBinding
$dvPortProp."Overall Status" = $dvPortGroup.ExtensionData.OverallStatus
$dvPortProp."Config Status" = $dvPortGroup.ExtensionData.ConfigStatus
$dvPortProp.Note = "vCenter needed for further info"
$dvPortTemp = New-Object –TypeName PSObject –Prop $dvPortProp
$dvPortInfo += $dvPortTemp
}
If ($dvPortInfo) {
$dvPortInfo | Sort "Virtual Switch", Portgroup | Export-Xlsx -Path $FullPath -WorksheetName "Distributed Portgroup Info" -Title "Distributed Portgroup Info" -AppendWorksheet -SheetPosition "end"
}
# Get Firewall Exceptions
$fwInfo = @()
Try {
$fwExceptions = $VMHost | Get-VMHostFirewallException -ErrorAction Stop
Foreach ($fwException in $fwExceptions) {
$fwProp = [ordered]@{}
$fwProp.Enabled = $fwException.Enabled
$fwProp.Name = $fwException.Name
$fwProp."Incoming Ports" = $fwException.IncomingPorts
$fwProp."Outgoing Ports" = $fwException.OutgoingPorts
$fwProp."Protocol(s)" = $fwException.Protocols
$fwProp."Allow all IPs" = $fwException.ExtensionData.AllowedHosts.AllIp
$fwProp.Service = $fwException.ExtensionData.Service
$fwProp."Service Running" = $fwException.ServiceRunning
$fwTemp = New-Object –TypeName PSObject –Prop $fwProp
$fwInfo += $fwTemp
}
} Catch {}
If ($fwInfo) {
$fwInfo | Sort Enabled, Name | Export-Xlsx -Path $FullPath -WorksheetName "Firewall Exceptions" -Title "Firewall Exceptions" -AppendWorksheet -SheetPosition "end"
}
# Get Services Information
$svcInfo = @()
$services = $VMHost | Get-VMHostService
Foreach ($service in $services) {
$svcProp = [ordered]@{}
$svcProp.Service = $service.Label
$svcProp.Key = $service.Key
$svcProp.Running = $service.Running
switch ($service.Policy)
{
"on" {$svcProp."Startup Policy" = "Start and stop with host"}
"off" {$svcProp."Startup Policy" = "Start and stop manually"}
"automatic" {$svcProp."Startup Policy" = "Start and stop with port usage"}
default {$svcProp."Startup Policy" = "Unknown"}
}
$svcProp.Required = $service.Required
$svcProp.Uninstallable = $service.Uninstallable
$svcProp."Source Package" = $service.ExtensionData.SourcePackage.SourcePackageName
$svcProp."Source Package Desc" = $service.ExtensionData.SourcePackage.Description
$svcTemp = New-Object –TypeName PSObject –Prop $svcProp
$svcInfo += $svcTemp
}
If ($svcInfo) {
$svcInfo | Sort Service | Export-Xlsx -Path $FullPath -WorksheetName "Services Info" -Title "Services Info" -AppendWorksheet -SheetPosition "end"
}
# Get SNMP Info
$snmpInfo = @()
$snmpDetails = Get-VMHostSnmp -Server $ESX
$snmpProp = [ordered]@{}
$snmpProp.Enabled = $snmpDetails.Enabled
$snmpProp.Port = $snmpDetails.Port
$snmpProp."Read Only Communities" = $snmpDetails.ReadOnlyCommunities | Out-String
$snmpProp."Trap Targets" = $snmpDetails.TrapTargets | Out-String
$snmpTemp = New-Object –TypeName PSObject –Prop $snmpProp
$snmpInfo += $snmpTemp
If ($snmpInfo) {
$snmpInfo | Export-Xlsx -Path $FullPath -WorksheetName "SNMP Info" -Title "SNMP Info" -AppendWorksheet -SheetPosition "end"
}
# Get Installed ESX(i) Patches
$patchInfo = @()
Try {
$patches = (Get-EsxCli).software.vib.list()
ForEach ($patch in $patches) {
$patchProp = [ordered]@{}
$patchProp.Name = $patch.Name
$patchProp.ID = $patch.ID
$patchProp.Vendor = $patch.Vendor
$patchProp.Version = $patch.Version
$patchProp."Acceptance Level" = $patch.AcceptanceLevel
$patchProp."Created Date" = $patch.CreationDate
$patchProp."Install Date" = $patch.InstallDate
$patchProp.Status = $patch.Status
$patchTemp = New-Object –TypeName PSObject –Prop $patchProp
$patchInfo += $patchTemp
}
} Catch {
$patches = $VMHost | Get-VMHostPatch
ForEach ($patch in $patches) {
$patchProp = [ordered]@{}
$patchProp.Name = $patch.Description
$patchProp.ID = $patch.ID
$patchProp."Install Date" = $patch.InstallDate
$patchTemp = New-Object –TypeName PSObject –Prop $patchProp
$patchInfo += $patchTemp
}
}
If ($patchInfo) {
$patchInfo | Sort "Install Date" -Descending | Export-Xlsx -Path $FullPath -WorksheetName "Patch Info" -Title "Patch Info" -AppendWorksheet -SheetPosition "end"
}
# Get Local Users
$accountInfo = @()
$accounts = Get-VMHostAccount -Server $ESX
ForEach ($account in $accounts) {
$accountProp = [ordered]@{}
$accountProp.Name = $account.Name
$accountProp.Description = $account.Description
$accountProp.ShellAccess = $account.ShellAccessEnabled
$accountProp.Groups = $account.Groups | Out-String
$accountTemp = New-Object –TypeName PSObject –Prop $accountProp
$accountInfo += $accountTemp
}
If ($accountInfo) {
$accountInfo | Sort IsSystem, Name | Export-Xlsx -Path $FullPath -WorksheetName "Local Users" -Title "Local Users" -AppendWorksheet -SheetPosition "end"
}
# Get Local Groups
$grpInfo = @()
Try {
$grps = Get-VMHostAccount -Server $ESX -Group -ErrorAction Stop
ForEach ($grp in $grps) {
$grpProp = [ordered]@{}
$grpProp.Name = $grp.Name
$grpProp.Description = $grp.Description
$grpProp.Users = $grp.Users | Out-String
$grpTemp = New-Object –TypeName PSObject –Prop $grpProp
$grpInfo += $grpTemp
}
} Catch {}
If ($grpInfo) {
$grpInfo | Sort Name | Export-Xlsx -Path $FullPath -WorksheetName "Local Groups" -Title "Local Groups" -AppendWorksheet -SheetPosition "end"
}
# Get VI Roles
$roleInfo = @()
$roles = Get-VIRole -Server $ESX
ForEach ($role in $roles) {
$roleProp = [ordered]@{}
$roleProp.Name = $role.Name
$roleProp.Description = $role.Description
$roleProp.IsSystem = $role.IsSystem
$roleProp.Privileges = $role.PrivilegeList | Out-String
$roleTemp = New-Object –TypeName PSObject –Prop $roleProp
$roleInfo += $roleTemp
}
If ($roleInfo) {
$roleInfo | Sort IsSystem, Name | Export-Xlsx -Path $FullPath -WorksheetName "VI Roles" -Title "VI Roles" -AppendWorksheet -SheetPosition "end"
}
# Get Permissions
$permInfo = @()
$perms = Get-VIPermission -Server $ESX
ForEach ($perm in $perms) {
$permProp = [ordered]@{}
$permProp.Entity = $perm.Entity
$permProp.Role = $perm.Role
$permProp.Principal = $perm.Principal
$permProp.IsGroup = $perm.IsGroup
$permProp.Propagate = $perm.Propagate
$permTemp = New-Object –TypeName PSObject –Prop $permProp
$permInfo += $permTemp
}
If ($permInfo) {
$permInfo | Sort Entity, Principal | Export-Xlsx -Path $FullPath -WorksheetName "Permissions" -Title "Permissions" -AppendWorksheet -SheetPosition "end"
}
# Get VM Info
$vmInfo = @()
$vms = $VMHost | Get-VM
ForEach ($vm in $vms) {
$vmProp = [ordered]@{}
$vmProp.Name = $vm.Name
$vmProp.State = $vm.PowerState
$vmProp.FullName = If (!$VM.Guest.hostname) {"Tools Not Running\Unknown"} Else {$VM.Guest.hostname}
$vmProp.GuestOS = If (!$VM.Guest.OSFullName) {"Tools Not Running\Unknown"} Else {$VM.Guest.OSFullName}
$vmProp.IP = If (!$VM.Guest.IPAddress[0]) {"Tools Not Running\Unknown"} Else {$VM.Guest.IPAddress[0]}
$vmProp.NumCPU = $vm.NumCPU
[int]$vmProp."Memory (GB)" = $vm.MemoryGB
$vmProp."Disk (GB)" = [Math]::Round((($vm.HardDisks | Measure-Object -Property CapacityKB -Sum).Sum * 1KB / 1GB),2)
$vmProp."DiskFree (GB)" = If (![Math]::Round((($vm.Guest.Disks | Measure-Object -Property FreeSpace -Sum).Sum / 1GB),2)) `
{"Tools Not Running\Unknown"} Else {[Math]::Round((($vm.Guest.Disks | Measure-Object -Property FreeSpace -Sum).Sum / 1GB),2)}
$vmProp."DiskUsed (GB)" = If ($vmProp."DiskFree (GB)" -eq "Tools Not Running\Unknown") `
{"Tools Not Running\Unknown"} Else {$vmProp."Disk (GB)" - $vmProp."DiskFree (GB)"}
$vmProp.Notes = $VM.Notes
$vmTemp = New-Object –TypeName PSObject –Prop $vmProp
$vmInfo += $vmTemp
}
If ($vmInfo) {
$vmInfo | Sort Created -Descending | Export-Xlsx -Path $FullPath -WorksheetName "VM Info" -Title "VM Info" -AppendWorksheet -SheetPosition "end"
}
# Get VM Snapshots
$snapInfo = @()
$snaps = $VMHost | Get-VM | Get-Snapshot
ForEach ($snap in $snaps) {
$snapProp = [ordered]@{}
$snapProp.VM = $snap.VM
$snapProp.Name = $snap.Name
$snapProp.Description = $snap.Description
$snapProp.Created = $snap.Created
$snapProp."Size (GB)" = [Math]::Round($snap.SizeGB,2)
$snapProp.IsCurrent = $snap.IsCurrent
$snapTemp = New-Object –TypeName PSObject –Prop $snapProp
$snapInfo += $snapTemp
}
If ($snapInfo) {
$snapInfo | Sort Created -Descending | Export-Xlsx -Path $FullPath -WorksheetName "Snapshot Info" -Title "Snapshot Info" -AppendWorksheet -SheetPosition "end"
}
Disconnect-VIServer $ESX -Confirm:$false
Write-Host "$ESX Report Complete - $FullPath"
} Else {
Write-Host "Unable to connect to $ESX" -ForegroundColor Red
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment