Error 25085 – Setup failed to register VMware Update Manager extension to VMware vCenter Server

I tried the following KB articles:

http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1024795

http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1003468

http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1032709

Some of them didn’t quite apply because everything was working just fine before the upgrade, but doesn’t hurt to check.

I have two vCenters in linked mode, so I broke the link, still didn’t fix it.  During the setup, I would always specify the FQDN to my vCenter, as well as the VUM server to register in vCenter.  After I thought I’d tried everything (cleaning registry, checking the ADAM database, etc), I decided to try one last time before opening a case with VMware.

I stepped through everything just the same as before, but when I was at the step of specifying the VUM server to register in vCenter (IP or FQDN), I normally selected the hostname, so I decided to select the IP and everything installed and worked fine.

This may or may not work for any readers, but thought I’d share just in case it helps at least one other person.

I have it pull the VM name, vmdk path & name, Size in GB, and if it’s Thin Provisioned (Boolean, which should always be true).

Just copy & paste this into a .ps1 file and run it. The initial instantiation of $vms takes a while, depending on the size of your environment, but the rest goes quickly. Make sure you’re connected to a host or vcenter before you run it, or you won’t get anything.

function find-thin{
    write-host -fore green `n "getting all VMs, this may take a while"

    $vms = get-vm |sort name |get-view

    Write-host -fore green `n "Starting Scan"

    $vmdks = @()

    foreach ($vm in $vms){
        foreach ($device in $vm.config.hardware.Device){
            if($device.GetType().Name -eq "VirtualDisk"){
                if($device.Backing.ThinProvisioned){
                    $info = "" | Select VM, File, SizeInGB, Thin
                    $info.VM = $vm.name
                    $info.File = $device.backing.filename
                    $info.SizeInGB = $device.capacityinkb/1048576
                    $info.thin = $device.Backing.ThinProvisioned
                    $vmdks += $info
                }
            }
        }
    }

    write-host -fore green `n "finished searching all VMs" `n

    $vmdks | export-csv d:\thindisk.csv
}

find-thin

To change where the file is saved, simply change the path in line 27 to the destination of your choice.

I wrote a quick little function to search all VMs that have snapshots and list them.

function get-snaps{
    $vms = get-vm | sort name
    $vmsnaps = @()
    foreach($vm in $vms){
    	$snap = Get-Snapshot $vm
    	if($snap){
		  $vmsnaps += $vm
		  write-host -fore green `n `t $vm
		  $snapshots = Get-Snapshot $vm
		  foreach ($snapshot in $snapshots){
			write-host "name: " $snapshot.name " size: " ($snapshot.sizemb/1024)
    		}
    	}
    }
}

get-snaps

Just save that into a .ps1 file and run it. Make sure you’re connected to a vCenter or it won’t work.

Expected output is like this:

         Server1
name:  Description  size:  0.07853515625

         Server2
name:  Description    size:  3.79728515625

         Server3
name:  Consolidate Helper- 0  size:  1.6565625

         Server4
name:  Consolidate Helper- 0  size:  73.45369140625

         Server5
name:  Consolidate Helper- 0  size:  53.60998046875

         ARPDBW0025202
name:  Description    size:  0.01630859375

Keep in mind, this also shows printers. I didn’t take the time to exclude them, so my script actually finds ~620 vulnerable shares.

For logging, just change $script:logfile = "D:\everyoneshares.txt" to whatever location you wish.

If you want to see more than just Full Control, change if (($AccessMask -eq "FullControl") -AND ($myshare.ID -eq "Everyone")){$script:mylist += $myshare} to match your desired output.

It also ignores any share that ends with a $ (administrative or hidden shares), change $shares = gwmi Win32_LogicalShareSecuritySetting -co $comp -erroraction silentlycontinue |? {$_.Name -notlike "*$"} to $shares = gwmi Win32_LogicalShareSecuritySetting -co $comp -erroraction silentlycontinue and it will look at ALL shares.

Now here’s the code:

#OU Locations, make sure the index is in order, 1, 2, 3, etc.
#you cannot have 3 without 2, etc.
$ous = @{}
$ous[1] = 'LDAP://OU=Servers,DC=domain,DC=com'
$ous[2] = 'LDAP://OU=Another OU,DC=domain,DC=com'
$ous[3] = 'LDAP://OU=Domain Controllers,DC=domain,DC=com'

#set logfile directory
$script:logfile = "D:\everyoneshares.txt"

#This pulls all computer accounts from AD
function getresults($path,$cert) {
	$objDomain = New-Object System.DirectoryServices.DirectoryEntry
	$objSearcher = New-Object System.DirectoryServices.DirectorySearcher
	$objSearcher.SearchRoot = New-Object System.DirectoryServices.DirectoryEntry($path)
	$objSearcher.PageSize = 1000 # How many to retrieve at a time. Not output size.
	$objSearcher.Filter = $strFilter
	$objSearcher.PropertiesToLoad.Add("cn") >$null

	$colResults = $objSearcher.FindAll()
	foreach ($objResult in $colResults)
	{
	  $objItem = $objResult.Properties
	  $computer =  $objItem.cn[0]
	  $computer = $objItem.cn
	  $script:comps += $computer
  	}
}

#This runs the getresults function for each OU supplied above
$script:comps = @()

foreach ($ou in 1 .. $ous.Count) {
		if ($ous.$ou) {
			$strFilter = "(&(objectClass=Computer))"
			getresults $ous.$ou
		}
}

$comps = $script:comps | Sort name
$script:mylist = @()
write-host `n
foreach ($comp in $comps) {#1

#here's where we actually pull each share from the current computer
    $shares = gwmi Win32_LogicalShareSecuritySetting -co $comp -erroraction silentlycontinue |? {$_.Name -notlike "*$"}
    if($shares){#2
    foreach ($share in $shares){#3
        $SecurityDescriptor = $Share.GetSecurityDescriptor()

		ForEach ($DACL in $SecurityDescriptor.Descriptor.DACL)
		{#4
			$myshare = "" | Select Server, Share, ID, AccessMask
            $myshare.Server = $comp
            $myshare.Share = $share.name
			$myshare.ID = $DACL.Trustee.Name
			Switch ($DACL.AccessMask)
			{#5
				2032127 {$AccessMask = "FullControl"}
				1179785 {$AccessMask = "Read"}
				1180063 {$AccessMask = "Read, Write"}
				1179817 {$AccessMask = "ReadAndExecute"}
				-1610612736 {$AccessMask = "ReadAndExecuteExtended"}
				1245631 {$AccessMask = "ReadAndExecute, Modify, Write"}
				1180095 {$AccessMask = "ReadAndExecute, Write"}
				268435456 {$AccessMask = "FullControl (Sub Only)"}
				default {$AccessMask = $DACL.AccessMask}
			}#5
			$myshare.AccessMask = $AccessMask

            if (($AccessMask -eq "FullControl") -AND ($myshare.ID -eq "Everyone")){$script:mylist += $myshare}

			Clear-Variable AccessMask -ErrorAction SilentlyContinue
    	}#4
      }#3
    }#2
}#1
$mylist | out-file $script:logfile
$count = $mylist.count
write-output `n "found $count shares where Everyone was given FullControl" | out-file $script:logfile -append
write-host `n

I pieced this together from a few things I found on the net (querying AD and Shares), then combined the two and added logfile output.

I recommend using Start-Job for this, and get-job to see if it’s finished. You don’t need to provide any input, and depending on your environment size, it could take quite some time. Here’s the expected output:

Server                                       Share                                        ID                                           AccessMask
------                                       -----                                        --                                           ----------
Server-1                                     Share-1                                      Everyone                                     FullControl                                 

found 1 shares where Everyone was given FullControl

Here’s how we list local admins:
First you have to get the group itself: $group =[ADSI]"WinNT://$server/Administrators" Then you have to get the members of that group: $admins = @($group.psbase.Invoke("Members")) Now to output those members: $admins | foreach {$_.GetType().InvokeMember("Name", 'GetProperty', $null, $_, $null)

Adding is just as simple:
Get the domain group: $adgroup =[ADSI]"WinNT://domain/$admingroup" Obviously you’ll have to change ‘domain’ to the fqdn of your domain. Next we get the local group, same as we did above: $localgroup =[ADSI]"WinNT://$server/Administrators" Now we add the domain group to the local group: $localGroup.PSBase.Invoke("Add",$adgroup.PSBase.Path) You can run them separately, but I tied it all together to come up with my script so it shows me which server it’s working on and lists local admins when it’s done.

Servers and Admingroups are an array and can be specified like this: Set-LocalAdmins.ps1 -servers ("host1","host2","host3") -admingroups ("group1","group2","group3") or Set-LocalAdmins.ps1 -servers host1 -admingroups group1

Here’s the script itself (don’t forget to change ‘domain’ on line 10 to the fqdn of your):

param([string[]]$servers = $null, [string[]]$admingroups = $null)

function AddGroup(){
Foreach ($server in $servers){
    $ping = gwmi win32_pingstatus -filter "Address='$server'"
    #if it pings, check it
    if($ping.statuscode -eq 0){
        write-host -foregroundcolor "green" `n `t "Now working on $server"
        Foreach ($admingroup in $admingroups){
            $adgroup =[ADSI]"WinNT://domain/$admingroup"
            $localgroup =[ADSI]"WinNT://$server/Administrators"
            $localGroup.PSBase.Invoke("Add",$adgroup.PSBase.Path)
        }
        $localadmingroup =[ADSI]"WinNT://$server/Administrators"
        $admins = @($localadmingroup.psbase.Invoke("Members"))
        $admins | foreach {$_.GetType().InvokeMember("Name", 'GetProperty', $null, $_, $null)}
        }
    else{write-host -foregroundcolor Red `n`t "$server is not pingable" `n}
}
}

Function Usage(){
	Write-host -foregroundcolor green `n`t"This script is used to add domain groups to local admins."
	Write-host -foregroundcolor green `n`t"You can specify -servers and -admingroups as arrays:"
	write-host -foregroundcolor yellow `n`t`t"Set-LocalAdmins.ps1 -servers (`"host1`",`"host2`",`"host3`") -admingroups (`"group1`",`"group2`",`"group3`")"
	Write-host -foregroundcolor green `n`t"or specify each individually:"
	write-host -foregroundcolor yellow `n`t`t"Set-LocalAdmins.ps1 -servers host1 -admingroups group1" `n
}

if (($servers -eq $null) -or ($admingroups -eq $null)){
Usage
Break
}

AddGroup

You’ll need to change the password on line 11, as ‘changeme’ does not meet default complexity requirements.

param([string[]]$vmhosts = $null)

$esx_host_creds = $host.ui.PromptForCredential("ESX/ESXi Credentials Required", "Please enter credentials to log into the ESX/ESXi host.", "", "")

foreach ($vmhost in $vmhosts){

connect-viserver $vmhost -credential $esx_host_creds > $NULL 2>&1

New-VIRole -name "Console-Only" -Privilege "Console interaction"

New-VMHostAccount -user -id console -password changeme -description "user acct for console only access"	

$AuthMgr = Get-View (Get-View ServiceInstance).Content.AuthorizationManager
$Entity = Get-Folder ha-folder-root | Get-View
$Perm = New-Object VMware.Vim.Permission
$Perm.entity = $Entity.MoRef
$Perm.group = $false
$Perm.principal = "console"
$Perm.propagate = $true
$Perm.roleId = ($AuthMgr.RoleList | where {$_.Name -eq "Console-Only"}).RoleId
$AuthMgr.SetEntityPermissions($Entity.MoRef,$Perm)

disconnect-viserver -confirm $false
}

Usage is like this:

add-user.ps1 -vmhosts ("server1","server2","server3","server4","server5")

It prompts you for a user/pass to connect to each ESXi host, so make sure you either have a working login with admin privs, or lockdown mode is NOT enabled and you have root pw.

Below is the script. After it pulls the information from you, it creates the VM, adds the second disk, sleeps for 15 seconds, pulls the MAC from the new VM, creates the computer object in SCCM, adds it to the collection, sleeps for 15 seconds, refreshes the collection, sleeps for 15 seconds, then powers on the VM. If you’ve got a mandatory OSD advertised to the collection specified, and the OSD is fully automated, it will lay down the OS and the computername will be the name you provided to the script.

There are some variables you will have to set to make it work for you. Our standard is to have two disks per VM, one for the OS, one for data. I have the OS disk hard coded to 64GB, and the script prompts you for the data disk. The OSID labels for the guest OS were taken from the API reference guide.

The SCCM portion was adapted from Antoine Habert, in combination with the /\/\o\/\/ WMI Browser.

This script also thin provisions both disks. This can be changed in the createvm function. Also, you will need PowerShell v2 and PowerCLI 4.1.1 to run this script.

Add-PSSnapin VMware.* -ErrorAction SilentlyContinue

#instantiate script variables
set-variable -name clustername -scope script
set-variable -name vmhostname -scope script
set-variable -name networklabel -scope script
set-variable -name vcenter -scope script
set-variable -name vmname -scope script
set-variable -name vCPU -scope script
set-variable -name vRAM -scope script
set-variable -name vmdisk2 -scope script
set-variable -name store -scope script
set-variable -name desc -scope script
set-variable -name osid -scope script

#function to prompt for confirmation
function Confirm($strMessage)
{
write-host -foregroundcolor yellow `n $strMessage
$answer = $host.ui.rawui.readkey("NoEcho,IncludeKeyUp")
if ($answer.Character -ine "y")
    {
    write ""
    break
    }

write ""
}

#lists our supplied specs
function listspecs{
write-host -foregroundcolor green `n "These are the specs of the new server:"
write-host -foregroundcolor yellow `n`t "Environment:" $script:vcenter
write-host -foregroundcolor yellow `n`t "Server Name:" $script:vmname
write-host -foregroundcolor yellow `n`t "Number of CPUs:" $script:vCPU
write-host -foregroundcolor yellow `n`t "Amount of RAM:" $script:vRAM "GB"
write-host -foregroundcolor yellow `n`t "OS Disk: 64 GB" # 64GB is our standard
write-host -foregroundcolor yellow `n`t "Data Disk:" $script:vmdisk2 "GB"
write-host -foregroundcolor yellow `n`t "Cluster:" $script:clustername
write-host -foregroundcolor yellow `n`t "Network:" $script:networklabel
write-host -foregroundcolor yellow `n`t "Datastore:" $script:store
if($script:osid -eq "winLonghornGuest"){write-host -foregroundcolor yellow `n`t "Installing Windows 2008 x86"}
if($script:osid -eq "winLonghorn64Guest"){write-host -foregroundcolor yellow `n`t "Installing Windows 2008 x64"}
if($script:osid -eq "windows7Server64Guest"){write-host -foregroundcolor yellow `n`t "Installing Windows 2008 R2"}
if($script:osid -eq "winNetEnterpriseGuest"){write-host -foregroundcolor yellow `n`t "Installing Windows 2003 x86"}
if($script:osid -eq "winNetEnterprise64Guest"){write-host -foregroundcolor yellow `n`t "Installing Windows 2003 x64"}
Confirm("Press 'Y' to continue, or any other key to exit...")
}

#prompts for sizing specs of the VM
function getspecs{
    $script:vcenter = (read-host `n "vCenter server").tolower()
    $script:vmname = (read-host `n "Name of VM").toupper() #I like the name being in caps in vC
    $script:desc = (read-host `n "Enter a description for the notes (App, your name, etc)")
    [int]$script:vCPU = (read-host `n "Enter the number of CPUs")
    [int]$script:vram = (read-host `n "Enter the amount of RAM in GB")
    [int]$script:vmdisk2 = (read-host `n "Enter data disk size in GB")
    #need to populate OS ID with proper string to match the label
    write-host `n "Select OS Version"
    write-host `n "0 - Win2k8R2"
    write-host `n "1 - Win2k8x64"
    write-host `n "2 - Win2k8x86"
    write-host `n "3 - Win2k3x86"
    write-host `n "4 - Win2k3x64"
    $answer = read-host `n "Enter the number for the OS you're installing"
    if($answer -eq "0"){$script:osid = "windows7Server64Guest"}
    elseif($answer -eq "1"){$script:osid = "winLonghorn64Guest"}
    elseif($answer -eq "2"){$script:osid = "winLonghornGuest"}
    elseif($answer -eq "3"){$script:osid = "winNetEnterpriseGuest"}
    elseif($answer -eq "4"){$script:osid = "winNetEnterprise64Guest"}
}

#gets the desired cluster
#as well as a host in that cluster to gather network & datastore info from
#then builds on that node of the cluster
#notice no sort order, so it won't pull the same host every time
Function ChooseCluster{
    $clslist = Get-cluster |sort name
    $i = 0
    write-host -foregroundcolor green `n "Choose a cluster"
    foreach ($cluster in $clslist){
    write-host -foregroundcolor green "$i - $cluster"
    $i++
    }
    $answer = read-host `n "Enter the number for the cluster you want"
    $script:clustername = $clslist[$answer]
    $vmhosts = get-vmhost -location $script:clustername
    $script:vmhostname = $vmhosts[0]
}

#lists datastores for one host of the cluster
#shows provisioned space as well as free space
#yellow if less than 150GB free
#red if less than 100GB free
Function ChooseDatastore{
    $datastores = Get-Datastore -vmhost $script:vmhostname |sort FreeSpaceMB -descending
    $i = 0
    write-host -foregroundcolor green `n "Choose a Datastore"
    foreach ($store in $datastores){
        $color = "green"
        if ($store.FreeSpaceMB -lt 153600){$color = "yellow"}
        if ($store.FreeSpaceMB -lt 102400){$color = "red"}
        $ds = Get-Datastore $store |sort name | Get-View
        $dsout = $ds | Select -ExpandProperty Summary | Select Name, @{N="Capacity GB"; E={[math]::round($_.Capacity/1073741824, 2)}}, @{N="Free GB"; E={[math]::round($_.FreeSpace/1073741824, 2)}}, @{N="Provisioned GB"; E={[math]::round(($_.Capacity - $_.FreeSpace + $_.Uncommitted)/1073741824, 2)}} |sort name
        write-host -foregroundcolor $color "$i - $dsout"
        $i++
    }
    $answer = read-host `n "Enter the number for the datastore you want"
    $script:store = $datastores[$answer]
}

#pulls available networks from the host in the cluster
Function ChooseNetwork{
    $networklist = Get-VirtualPortGroup -vmhost $script:vmhostname |sort name
    $i = 0
    write-host -foregroundcolor green `n "Choose a network"
    foreach ($network in $networklist){
    write-host -foregroundcolor green "$i - $network"
    $i++
    }
    $answer = read-host `n "Enter the number for the network you want"
    $script:networklabel = $networklist[$answer]
}

#connects to vcenter
function ConnectVCenter($script:vcenter){
    connect-viserver $script:vcenter > $NULL 2>&1
}

#change -DiskMB to change disk 0:0 to the desired size
function CreateVM{
    #this creates the VM itself
    new-vm -vmhost $script:vmhostname -name $script:vmname -Datastore $script:store -DiskMB 65536 -diskstorageformat Thin -MemoryMB ($script:vRAM * 1024) -NumCpu $script:vcpu -CD -GuestID $script:osid -NetworkName $script:networklabel -Description $script:desc

    #this adds the data disk, since accepted size is kb, and prompt was gb, we have to convert it
    get-vm $script:vmname | New-HardDisk -capacitykb ($script:vmdisk2 * 1048576) -StorageFormat Thin
}

#disconnect from vc, null out variables just in case
function garbagecollection{
$script:clustername = $null
$script:vmhostname = $null
$script:networklabel = $null
$script:vcenter = $null
$script:vmname = $null
$script:vCPU = $null
$script:vRAM = $null
$script:vmdisk2 = $null
$script:store = $null
$script:desc = $null
$script:osid = $null

disconnect-viserver -confirm:$false
}

function AddToSCCM{

#sccm variables here
$SCCMServer = "" #enter the SCCM server name, used for WMI
$SCCMSite = "Site_" #example: Site_WSS, always 'Site_' and then 3 letter site code
$Colon = ":" #don't change this, makes life easier for the wmi path

#we need the mac to import computer into SCCM
$vnic =  Get-NetworkAdapter (get-vm $script:vmname)
$mac = $vnic.MacAddress

#specify collection based on OS ID
if($script:osid -eq "winLonghornGuest"){$targetColl = "2008 x86 Mandatory"}
elseif($script:osid -eq "winLonghorn64Guest"){$targetColl = "2008 x64 Mandatory"}
elseif($script:osid -eq "windows7Server64Guest"){$targetColl = "2008 R2 Mandatory"}
elseif($script:osid -eq "winNetEnterpriseGuest"){$targetColl = "2003 x86 Mandatory"}
elseif($script:osid -eq "winNetEnterprise64Guest"){$targetColl = "2003 x64 Mandatory"}

#create computer object
$Method = "ImportMachineEntry"
$Class = "SMS_Site"
$MC = [WmiClass]"\\$SCCMServer\ROOT\SMS\$SCCMSite$Colon$Class"
$InParams = $mc.psbase.GetMethodParameters($Method)
$InParams.MACAddress = $mac
$InParams.NetbiosName = $script:vmname
$InParams.OverwriteExistingRecord = $false
$inparams.PSBase.properties | select name,Value
$objCMComputer = $mc.PSBase.InvokeMethod($Method, $inParams, $Null)

#create direct rule for collection for target collection
$Class = "SMS_CollectionRuleDirect"
$objColRuledirect = [WmiClass]"\\$SCCMServer\ROOT\SMS\$SCCMSite$Colon$Class"
$objColRuleDirect.psbase.properties["ResourceClassName"].value = "SMS_R_System"
$objColRuleDirect.psbase.properties["ResourceID"].value = $objCMComputer.resourceID
$Collection = gwmi -computer $SCCMServer -namespace "root\sms\$SCCMSite" -class "SMS_Collection"
$svrCollection = $collection | where{$_.Name -eq "$targetColl"}

#add computer to target collection
$Class = "SMS_Collection"
$Method = "AddMembershipRule"
$CollectionID = $svrCollection.CollectionID
$filter="CollectionID = '$CollectionID'"
$MC = Get-WmiObject "SMS_Collection" -computer $SCCMServer -Namespace "ROOT\SMS\$SCCMSite" -filter $filter
$InParams = $mc.psbase.GetMethodParameters($Method)
$InParams.collectionRule = $objColRuledirect

$inparams.PSBase.properties | select name,Value
$AddComp = $mc.PSBase.InvokeMethod($Method, $inParams, $Null)

#update collection membership
start-sleep -s 15 #sleep for 15 seconds before requesting refresh of collection
$Method = "RequestRefresh"
$InParams = $mc.psbase.GetMethodParameters($Method)
$InParams.includesubcollections = $false
$inparams.PSBase.properties | select name,Value

$Refresh = $mc.PSBase.InvokeMethod($Method, $inParams, $Null)

}

function LaunchConsole{
$conuser = "conuser"
$conpw = "conpw"
$vm = get-vm $script:vmname
$currentvmhost = (get-vmhost -vm $vm).name
$vmxpath = $vm.ExtensionData.Summary.config.vmpathname
D:\"Program Files (x86)"\VMware\Infrastructure\"Virtual Infrastructure Client"\4.0\vmware-vmrc.exe -u $conuser -p $conpw -h $currentvmhost `"$vmxpath`"
}

##
#
# and now lets run all the functions
#
##
getspecs

ConnectVCenter($script:vcenter)

ChooseCluster

ChooseNetwork

ChooseDatastore

listspecs

CreateVM

start-sleep -s 15

AddToSCCM

start-sleep -s 15

start-vm $script:vmname > $NULL 2>&1

LaunchConsole

garbagecollection

**UPDATE 06/07/2011**
I added one function to actually launch the remote console (vmware-vmrc.exe). I hard-coded the path (line 222). I have both 4.0 & 4.1 installed, but used 4.0 for no particular reason, and also set the user & pass as variables, or delete the -u & -p from line 222 if you want to manually specify a user/pass each time. This user will need to reside on the host specifically (I have a script that creates the Role, as well as the user, for this). You could comment out the function call itself if you don’t want it (line 252). I know the pw is there in clear text, but if created properly, it can only view the console.

It prompts you for vCenter name, VM name, cpu, ram, description, disk size, queries vcenter for clusters, networks, datastores (sorted by free space), and verifies with you before building…

I’m excited & pleased that it’s actually working. It’s currently proprietary to my work environment, but I will try to strip all that out and let you change what needs to be changed to use it where you like.

Happy Scripting!!!

Instead of constantly searching vCenter, I wrote this quickly during the meeting to query multiple servers.

#only need one parameter here
param([string[]]$servers = "servers")

#add vmware snap-in
Add-PSSnapin VMware.* -erroraction silentlycontinue

#typical usage statements
function usage(){
    Write-host -foregroundcolor green `n`t"This script is used to retreive info for all servers provided."
    Write-host -foregroundcolor green `n`t"It pulls VM Host & cluster info, OS provided in vCenter, number of CPUs & RAM."
    Write-host -foregroundcolor green `n`t"Specify -servers in singular or in an array, like this:"
    write-host -foregroundcolor yellow `n`t`t"Get-VMInfo.ps1 -servers (`"server1`",`"server2`",`"server3`")"
    Write-host -foregroundcolor green `n`t"or"
    write-host -foregroundcolor yellow `n`t`t"Get-VMInfo.ps1 -servers server1" `n
    Write-host -foregroundcolor green `n`t"or"
    write-host -foregroundcolor yellow `n`t`t"Get-VMInfo.ps1 server1" `n
    }

#the main guts of the scripts
function GetInfo(){

foreach($server in $servers){
            #lets check and see if we're already connected somewhere
            if($global:DefaultVIServer){disconnect-viserver -confirm:$false}
            connect-viserver vcentername > $NULL 2>&1
            $vm = get-vm $server -erroraction silentlycontinue
            if ($vm -ne $null){
                $vcls = get-cluster -vm $server
                $vdc = get-datacenter -vm $server
                write-host -foregroundcolor green `n "Server $server"
                write-host -foregroundcolor green `n "OS is" $vm.Guest.OSFullName
                write-host -foregroundcolor green `n "Running on host" $vm.vmhost "in the $vcls cluster in the $vdc Datacenter"
                if ($vm.memorymb -gt 1024){
                    $ram = [math]::round($vm.MemoryMB/1024, 0)
                    write-host -foregroundcolor green `n "It has" $VM.HardDisks.Count "virtual disks," $vm.NumCPU "CPUs, and $ram GB of RAM" `n
                    }
                else{write-host -foregroundcolor green `n "It has" $VM.HardDisks.Count "virtual disks," $vm.NumCPU "CPUs, and" $vm.memorymb "MB of RAM" `n}
                }
            elseif ($vm -eq $null){write-host -foregroundcolor red `n "Cannot find server in vCenter" `n;break}
            if($global:DefaultVIServer){disconnect-viserver -confirm:$false -erroraction silentlycontinue}
            }
    }

#making sure we have parameters
If($servers -eq "servers"){
    usage
    break
    }

getinfo

I hard-coded my vcenter hostname in there, so you’ll need to change that line
connect-viserver vcentername > $NULL 2>&1

Usage is like this:

Get-VMInfo.ps1 servername

or

Get-VMInfo.ps1 ("server1","server2","server3")

And expected output is like this:

Server Server1
OS is Red Hat Enterprise Linux 4 (32-bit)
Running on host esxihost1 in the cluster1 cluster in the vdatacentername Datacenter
It has 1 virtual disks, 1 CPUs, and 2 GB of RAM

Not real sophisticated, but works...