Description

This PowerShell module is used to gather system information about a given computer.

One public cmdlet: Get-SystemInventory (read help-file for more details)

In addition to the cmdlet itself, the module has a series of private functions and also creates several new object types. This cmdlet is ideal for gathering system information for multiple computers, such as all computers of a given OU or even the entire domain, though that might take forever and a day to return. :)

Script

PowerShell
Edit|Remove
#=============================================================================# 
#                                                                             # 
# Windows.System.Inventory.psm1                                               # 
# Powershell Module for System Inventory                                      # 
# Author: Jeremy Engel                                                        # 
# Creation Date: 03.14.2009                                                   # 
# Modified Date: 08.02.2011                                                   # 
# Version: 2.5.0                                                              # 
#                                                                             # 
#=============================================================================# 
 
Add-Type -TypeDefinition @" 
  public struct Processor { 
    public string Name; 
    public string Description; 
    public int Cores; 
    public string Socket; 
    public override string ToString() { return Name; } 
    } 
 
  public struct LogicalDrive { 
    public string Drive; 
    public string Name; 
    public int DriveType; 
    public float Size; 
    public override string ToString() { return Drive; } 
    } 
 
  public struct NetworkConnection { 
    public string Name; 
    public string Model; 
    public string MACAddress; 
    public string IPAddress; 
    public string SubnetMask; 
    public string Gateway; 
    public string[] DNSServers; 
    public string[] WINSServers; 
    public override string ToString() { return Name; } 
    } 
 
  public struct InstalledApplication { 
    public string Name; 
    public string Version; 
    public string Vendor; 
    public override string ToString() { return Name; } 
    } 
 
  public struct SystemInventory { 
    public string Name; 
    public string Domain; 
    public string DomainRole; 
    public string OperatingSystem; 
    public string InstallDate; 
    public string Manufacturer; 
    public string Model; 
    public string SerialNumber; 
    public Processor[] Processors; 
    public float PhysicalMemory; 
    public float VirtualMemory; 
    public LogicalDrive[] LogicalDrives; 
    public NetworkConnection[] Network; 
    public InstalledApplication[] Applications; 
    public override string ToString() { return Name; } 
    } 
"@ 
 
function Get-Processor([string]$ComputerName) { 
  $procs = @() 
  try { $cpus = Get-WmiObject Win32_Processor -ComputerName $ComputerName } 
  catch { } 
  finally { 
    foreach($cpu in $cpus) { 
      $proc = New-Object Processor 
      $proc.Name = $($cpu.Name.Split(" "| Where-Object { $_ }) -Join " " 
      $proc.Description = $cpu.Description 
      $proc.Cores = $cpu.NumberOfCores 
      $proc.Socket = $cpu.SocketDesignation 
      $procs +$proc 
      } 
    } 
  return $procs 
  } 
 
function Get-LogicalDrive([string]$ComputerName) { 
  $lds = @() 
  try { $drives = Get-WmiObject Win32_logicalDisk -ComputerName $ComputerName } 
  catch { } 
  finally { 
    foreach($drive in $drives) { 
      $ld = New-Object LogicalDrive      
      $ld.Drive = $drive.DeviceID 
      $ld.Name = if($drive.VolumeName){$drive.VolumeName}else{$drive.Description} 
      $ld.DriveType = $drive.DriveType 
      $ld.Size = [Math]::Round(($drive.Size/[Math]::Pow(1024,3))+1,2) 
      $lds +$ld 
      } 
    } 
  return $lds 
  } 
 
function Get-NetworkConnection([string]$ComputerName) { 
  $nicList = @() 
  try { $nics = Get-WmiObject Win32_NetworkAdapter -ComputerName $ComputerName | Where-Object { $_.NetConnectionID -ne $null } } 
  catch { return } 
  finally { 
    foreach($nic in $nics) { 
      $adapter = Get-WmiObject Win32_NetworkAdapterConfiguration -ComputerName $ComputerName | Where-Object { $_.Index -eq $nic.DeviceID } 
      if($adapter.IPEnabled) { 
        $net = New-Object NetworkConnection 
        $net.Name = $nic.NetConnectionID 
        $net.Model = $nic.Name 
        $net.MACAddress = $nic.MACAddress 
        if($adapter.IPAddress) { $net.IPAddress = $adapter.IPAddress[0] } 
        if($adapter.IPSubnet) { $net.SubnetMask = $adapter.IPSubnet[0] } 
        if($adapter.DefaultIPGateway) { $net.Gateway = $adapter.DefaultIPGateway[0] } 
        $net.DNSServers = $adapter.DNSServerSearchOrder 
        if($adapter.WINSPrimaryServer) { $net.WINSServers +$adapter.WINSPrimaryServer } 
        if($adapter.WINSSecondaryServer) { $net.WINSServers +$adapter.WINSSecondaryServer } 
        $nicList +$net 
        } 
      } 
    } 
  return $nicList 
  } 
 
function Get-OperatingSystem([PSObject]$WmiOSObject) { 
  $caption = $WmiOSObject.Caption 
  $caption = $caption.replace("(R)","").Replace("®","").Replace("Microsoft","").Replace("Edition","").Replace(",","").Trim() 
  if([int]$WmiOSObject.Version.Split(".")[0] -ge 6) { 
    if(!$caption.Contains("R2")) { return "$caption $($WmiOSObject.OSArchitecture)" } 
    else { return $caption } 
    } 
  else { 
    if($caption.Contains("x64")) { return $caption.Replace("x64","64-bit") } 
    else { return "$caption 32-bit" } 
    } 
  } 
 
function Get-DomainRole([int]$Value) { 
  switch($Value) { 
    0 { return "Standalone Workstation" } 
    1 { return "Member Workstation" } 
    2 { return "Standalone Server" } 
    3 { return "Member Server" } 
    4 { return "Backup Domain Controller" } 
    5 { return "Primary Domain Controller" } 
    } 
  } 
 
function Get-Application([string]$ComputerName) { 
  $applications = @() 
  try { $apps = Get-WmiObject -Class Win32_Product -ComputerName $ComputerName } 
  catch { } 
  finally { 
    foreach($item in $apps) { 
      $app = New-Object InstalledApplication 
      $app.Name = $item.Name 
      $app.Version = $item.Version 
      $app.Vendor = $item.Vendor 
      $applications +$app 
      } 
    } 
  return $applications 
  } 
 
function Get-WmiData([string]$class,[string]$ComputerName) { 
  $i = 0 
  $query = Get-WmiObject $class -ComputerName $ComputerName -AsJob   
  do { $i++Start-Sleep -Seconds 1 } until($query.State -eq "Completed" -or $query.State -eq "Failed" -or $i -ge 10) 
  if($query.State -eq "Completed") { return ($query | Receive-Job) } 
  else { return $null } 
  } 
 
function Get-SystemInventory { 
  <# 
    .Synopsis 
     Gathers system information about a given computer. 
    .Example 
     Get-SystemInventory -ComputerName server1 
     This example gathers information about the server 'server1'. 
    .Description 
     The Get-SystemInventory cmdlet is used to gather information about a given system. The return value for success is the SystemInventory object. 
    .Parameter ComputerName 
     Specifies the computer against which you want to run the management operation. The value can be a fully qualified domain name, a NetBIOS name, or an IP address. Use the local computer name, use localhost, or use a dot (.) to specify the local computer. The local computer is the default. When the remote computer is in a different domain from the user, you must use a fully qualified domain name. 
      
     This parameter can also be piped to the cmdlet. This parameter does not rely on Windows PowerShell remoting, which uses WS-Management. You can use the ComputerName parameter of Get-SystemInventory even if your computer is not configured to run WS-Management remote commands. 
    .Outputs 
     SystemInventory 
    .Notes 
     Name:   Get-SystemInventory 
     Module: Windows.System.Inventory.psm1 
     Author: Jeremy Engel 
     Date:   05.11.2011 
  #> 
  [CmdletBinding()] 
  Param([Parameter(Mandatory=$false,ValueFromPipeline=$true)][string]$ComputerName = $env:ComputerName) 
  if(!($comp = Get-WmiData Win32_ComputerSystem $ComputerName)) { Write-Host "ERROR: WMI errors on $ComputerName." -ForeGroundColor Red; return } 
  if(!($os = Get-WmiData Win32_OperatingSystem $ComputerName)) { Write-Host "ERROR: WMI errors on $ComputerName." -ForeGroundColor Red; return } 
  if(!($chassis = Get-WmiData Win32_SystemEnclosure $ComputerName)) { Write-Host "ERROR: WMI errors on $ComputerName." -ForeGroundColor Red; return } 
  if($os.Count) { $os = $os[0] } 
  $system = New-Object SystemInventory 
  $system.Name = $comp.DNSHostName 
  $system.Domain = $comp.Domain 
  $system.DomainRole = Get-DomainRole -Value $comp.DomainRole 
  $system.OperatingSystem = Get-OperatingSystem -WmiOSObject $os 
  $system.InstallDate = [System.Management.ManagementDateTimeconverter]::ToDateTime($os.InstallDate) 
  $system.Manufacturer = $comp.Manufacturer.Trim() 
  $system.Model = $comp.Model.Trim() 
  $system.SerialNumber = $chassis.SerialNumber.Trim() 
  $system.Processors = Get-Processor -ComputerName $ComputerName 
  $system.PhysicalMemory = [float]([Math]::Round(($os.TotalVisibleMemorySize/[Math]::Pow(1024,2)),2)) 
  $system.VirtualMemory  = [float]([Math]::Round(($os.TotalVirtualMemorySize/[Math]::Pow(1024,2))+1,2))-$system.PhysicalMemory 
  $system.LogicalDrives = Get-LogicalDrive -ComputerName $ComputerName 
  $system.Network = Get-NetworkConnection -ComputerName $ComputerName 
  $system.Applications = Get-Application -ComputerName $ComputerName 
  return $system 
  } 
 
Export-ModuleMember Get-SystemInventory