$vCenterServerName = "MyVC1.domain.local", "myVC2.domain.local" # Enter your vCenter server name here. In case of multiple vCenter servers, separate using a comma.
 
$ErrorActionPreference = "Stop"
 
# Connect to vCenter(s)
Write-Host "Connecting..."
$VC = Connect-VIServer $vCenterServerName
 
Write-Host "Counting physical cpu's and vRAM in your environment. Please be patient..."
# Gather information
$pCpu = (Get-VMHost | Get-View | Select -ExpandProperty Hardware | Select -ExpandProperty CpuInfo | Measure-Object -Property NumCpuPackages -Sum).Sum
$vRAM = [Math]::Round((Get-VM | Where {$_.PowerState -eq "PoweredOn"} | Measure-Object -Property MemoryMB -Sum).Sum/1024,0)
Write-Host "======"
"pCpu Count: {0}" -f $pCpu
"vRAM (GB):  {0}" -f $vRAM
Write-Host "======"
# Disconnect
Disconnect-VIServer $vCenterServerName -Confirm:$false
 
# Calculate required licenses
$licCol = @()
$licObj = "" | Select Edition, Entitlement, Licenses
$licObj.Edition = "Essentials/Essentials Plus/Standard"
$licObj.Entitlement = "1 pCpu + 32 GB vRAM"
If (($vRAM/32) -gt $pCpu)
{
	$licObj.Licenses = "{0} with {1} pCpu overhead" -f [Math]::Ceiling($vRAM/32), ([Math]::Ceiling($vRAM/32) - $pCpu)
}
Else
{
	$licObj.Licenses = "{0} with {1} GB vRAM overhead" -f $pCpu, ((32 * $pCpu) - $vRAM)
}
$licCol += $licObj
$licObj = "" | Select Edition, Entitlement, Licenses
$licObj.Edition = "Enterprise"
$licObj.Entitlement = "1 pCpu + 64 GB vRAM"
If (($vRAM/64) -gt $pCpu)
{
	$licObj.Licenses = "{0} with {1} pCpu overhead" -f [Math]::Ceiling($vRAM/64), ([Math]::Ceiling($vRAM/64) - $pCpu)
}
Else
{
	$licObj.Licenses = "{0} with {1} GB vRAM overhead" -f $pCpu, ((64 * $pCpu) - $vRAM)
}
$licCol += $licObj
$licObj = "" | Select Edition, Entitlement, Licenses
$licObj.Edition = "Enterprise Plus"
$licObj.Entitlement = "1 pCpu + 96 GB vRAM"
If (($vRAM/96) -gt $pCpu)
{
	$licObj.Licenses = "{0} with {1} pCpu overhead" -f [Math]::Ceiling($vRAM/96), ([Math]::Ceiling($vRAM/96) - $pCpu)
}
Else
{
	$licObj.Licenses = "{0} with {1} GB vRAM overhead" -f $pCpu, ((96 * $pCpu) - $vRAM)
}
$licCol += $licObj
# Displaying output
Write-Host "Resulting license options:"
$licCol
Write-Host "======"
Write-Host "NOTE: vRAM only counts memory allocated to vm's that are POWERED ON." -ForegroundColor Red 
Write-Host "NOTE: Please double check the results of this script, since hosts may have been omitted due to errors." -ForegroundColor Red 
Write-Host "Disclaimer: No rights can be deduced from this calculation." -ForegroundColor Red
Write-Host "======"

$vCenterServer = MyvCenterServer.domain.local #Enter your vCenter server FQDN here
 
#Connect to vCenter Server
$VC = Connect-VIServer $vCenterServer
 
#Gathering data
ForEach ($vm in get-vm)
{
	$vmView = $vm | get-view
 
	Write-Host "======"
	Write-Host "VM: $($vm.Name)"
	Write-Host "Current Limit: $($vmView.config.MemoryAllocation.Limit)"
 
	If ($vmView.config.MemoryAllocation.Limit -ne -1)
	{
		#Preparing modified data
		$spec = New-Object VMware.Vim.VirtualMachineConfigSpec
		$MemoryAllocation = New-Object VMware.Vim.ResourceAllocationInfo
		$MemoryAllocation.Limit = -1
		$spec.MemoryAllocation = $MemoryAllocation
 
		#Applying modification
		Write-Host "Removing Memory Limit"
		$vmView.ReconfigVM($spec)
 
		#Reloading data
		$vm = get-vm $vm.name
		$vmView = $vm | get-view
		Write-Host "Current Limit: $($vmView.config.MemoryAllocation.Limit)"
	}
 
	#Cleanup
	Clear-Variable vmView -ErrorAction SilentlyContinue
}
 
#Disconnect
Disconnect-VIServer $vCenterServer -Confirm:$false

#Folder name you like
$syslogFolderName = "syslog"
 
#Connect to vCenter
Connect-VIServer vcenter.domain.local
 
#Loop through hosts
ForEach ($vmhost in Get-VMHost)
	{
	#Get only the first part of the FQDN (only if you used the FQDN to add the ESX server to vCenter)
	$hostname = $vmhost.name.split(".")[0].ToUpper()
 
	#Local datastore name (equal to hostname in my case)
	$datastorename = $hostname
 
	#Make the local datastore accessible as a PSdrive
	New-PSDrive -Name $hostname -Root \ -PSProvider VimDatastore -Datastore (Get-Datastore $datastorename) -Scope global
 
	#Access the new PSDrive
	Set-Location $hostname":"
 
	#Create the syslog folder
	New-Item $syslogFolderName -ItemType directory
 
	#Set the advanced parameter to configure the syslog on the local datastore
	$value = "[$datastorename] $syslogFoldername/$hostname.log"
	Set-VMHostAdvancedConfiguration -VMHost $vmhost -Name "Syslog.Local.DatastorePath" -Value $value
 
	#Cleanup
	Set-Location $PSHOME
	Remove-PSDrive $hostname
	Clear-Variable hostname -ErrorAction SilentlyContinue
	Clear-Variable datastorename -ErrorAction SilentlyContinue
	Clear-Variable value -ErrorAction SilentlyContinue
	}
 
#Disconnect from vCenter
Disconnect-VIServer -confirm:$false

# Convert function scripts to Module
 
#Variables
$myModuleName = "myModule123"
$inputFolder = 'D:\scripts\Functions'
$outputFolder = "$PSHOME\Modules\$myModuleName"
 
#Create the module directory
$null = New-Item $outputFolder -ItemType directory
 
#Create the module with a nice oneliner
Get-ChildItem $inputFolder -Filter "*.ps1" | Get-Content | Out-File "$outputFolder\$myModuleName.psm1" -Append
 
#Import the module
Import-Module $myModuleName
 
#Show functions loaded from the module
Get-Command -Module $myModuleName

$VC = Connect-VIServer "MyvCenter.local"
 
ForEach ($Vapp in Get-VApp)
{	
	$VAppView = $VApp | Get-View
	ForEach ($Entity in $VAppView.VAppConfig.EntityConfig)
	{
		If ($Entity.StopAction -ne "guestShutdown")
		{
		$VAppConfigSpec = New-Object VMware.Vim.VAppConfigSpec
		$EntityConfig = New-Object VMware.Vim.VAppEntityConfigInfo
			$EntityConfig.Key = (Get-View $Entity.Key).MoRef
			$EntityConfig.StopAction = "guestShutdown"
		$VAppConfigSpec.EntityConfig = $EntityConfig
 
		$VAppView.UpdateVAppConfig($VAppConfigSpec)
		}
	}
}
 
Disconnect-VIServer -Confirm:$false

 
function Get-LunId
{
	param($CanonicalName, $VMHost)
 
	#Get advanced host properties
	$VMHostView = Get-VMHost $VMHost | Get-View
 
	#Get two different collections with luns
	#The first one matches the canonical name with a key
	$HostLunsByCanonicalName = Get-VMHost $VMHost | Get-SCSILun
	#The second one matches the key with a lun id
	$HostLunsByKey = $VMHostView.Config.StorageDevice.ScsiTopology | 
		ForEach {$_.Adapter} | ForEach {$_.Target} | ForEach {$_.Lun}
 
	#Use the first collection to translate the canonicalname into the key
	$Key = ($HostLunsByCanonicalName | Where {$_.CanonicalName -eq $CanonicalName}).Key
	#Use the second colleciton to find the luns with the key
	$MatchingLuns = $HostLunsByKey | Where {$_.ScsiLun -eq $Key}
 
	#Every path to the lun will be a match, 
	#so let's deduplicate and see if there is really a single result
	$NumResults = ($MatchingLuns | Group-Object Lun | Measure-Object).Count
	If ($NumResults -gt 1)
	{
		#Multiple luns found
		$MatchingLuns | Group-Object Lun | ForEach {$_.Name}
	}
	ElseIf ($NumResults -eq 1)
	{
		#Single result found
		($MatchingLuns | Select -First 1).Lun
	}
	Else
	{
		#No results found
		"No result"
	}
}

function Fix-RsmDcom
{
	Param($ServerName = 'blank')
 
	If ($ServerName -eq 'blank')
	{
		$ServerName = Read-Host "ServerName"
	}
 
	$Hive = 'LocalMachine'
	$AppIDKeyName = "Software\Classes\AppID"
	$AppIDSubKey = "{D61A27C1-8F53-11D0-BFA0-00A024151983}"
	$CLSIDKeyName = "Software\Classes\CLSID"
	$CLSIDSubKey = "{D61A27C6-8F53-11D0-BFA0-00A024151983}"
	$Writable = $true
 
	Write	-Host "Processing Server $Servername"
 
	$Registry = [Microsoft.Win32.RegistryKey]::OpenRemoteBaseKey([Microsoft.Win32.RegistryHive]::$Hive, $ServerName)
	If ($Registry)
	{
		$AppID = $Registry.OpenSubKey($AppIDKeyName, $Writable)
		If ($AppID)
		{
			If ($AppID.GetSubKeyNames() -contains $AppIDSubKey)
			{
				Write-Host "`tRemoving AppID subkey"
				$AppID.DeleteSubKey($AppIDSubKey)
			}
			Else
			{
				Write-Warning "AppID SubKey not found on $ServerName"
			}
		}
		Else
		{
			Write-Warning "Failed to open AppID subkey on $ServerName"
		}
 
		$CLSID = $Registry.OpenSubKey($CLSIDKeyName, $Writable)
		If ($CLSID)
		{
			If ($CLSID.GetSubKeyNames() -contains $CLSIDSubKey)
			{
				Write-Host "`tRemoving CSLID subkey tree"
				$CLSID.DeleteSubKeyTree($CLSIDSubKey)
			}
			Else
			{
				Write-Warning "CLSID SubKey not found on $ServerName"
			}
		}
		Else
		{
			Write-Warning "Failed to open CLSID subkey on $ServerName"
		}
	}
	Else
	{
		Write-Warning "Failed to connect to registry on $ServerName"
	}
}

# Report vSphere Alarms
# by Hugo Peeters
# www.peetersonline.nl
 
#Region Variables
$VCServer = "myVCServer"
$Outfile = "D:\scripts\Alarms.txt"
 
Connect-VIServer $VCServer
$SI = Get-View ServiceInstance
$AM = Get-View $SI.Content.AlarmManager
$myCol = @()
ForEach ($Folder in (Get-Folder))
	{
	ForEach ($Alarm in ($AM.GetAlarm(($Folder|Get-View).MoRef)))
		{
		$Alarm = Get-View $Alarm
		$myObj = "" | Select Folder, Name, Description, Enabled, Summary
		$myObj.Folder = $Folder.Name
		$myObj.Name = $Alarm.Info.Name
		$myObj.Description = $Alarm.Info.Description
		$myObj.Enabled = $Alarm.Info.Enabled
		$myObj.Summary = $Alarm.Info.Expression.Expression | Out-String
		$myObj
		$myCol += $myObj
		}
	}
$myCol | Where {$_.Enabled} | Out-File $Outfile
ii $Outfile

##############################
# Script created by Hugo Peeters #
# http://www.peetersonline.nl   #
##############################
 
# Variables
$VCServerName = "MYVCSERVER"
$CustomFieldName = "VMX"
$ManagedObjectType = "VirtualMachine"
 
# Script
$VC = Connect-VIServer $VCServerName
$SI = Get-View ServiceInstance
$CFM = Get-View $SI.Content.CustomFieldsManager
 
$myCustomField = $CFM.Field | Where {$_.Name -eq $CustomFieldName}
If (!$myCustomField)
	{
	# Create Custom Field
	$FieldCopy = $CFM.Field[0]
	$CFM.AddCustomFieldDef($CustomFieldName,$ManagedObjectType,$FieldCopy.FieldDefPrivileges,$FieldCopy.FieldInstancePrivileges)
	$myCustomField = $CFM.Field | Where {$_.Name -eq $CustomFieldName}
	}
 
# Fill Custom Fields
$VMs = Get-VM
ForEach ($VM in $VMs)
	{
	$VMView = $VM | Get-View
	$VMXPath = $VMView.Config.Files.VMPathName
	# Compare value to current value
	If ($VMXPath -ne ($VMView.CustomValue | ?{$_.Key -eq $myCustomField.Key}).Value)
		{
		# Set Custom Value
		$VMView.setCustomValue($CustomFieldName,$VMXPath)
		}
	Clear-Variable VMXPath -ErrorAction SilentlyContinue
	Clear-Variable VMView -ErrorAction SilentlyContinue
	}
Disconnect-VIServer -Confirm:$False

# Description:
# Set's the Working Location for a VM. This location will hold the vswap and snapshot delta files.
 
# Usage:
# First, connect to a virtual server server (Connect-VIServer)
#
# Set snapshot location for one vm (folder must already exist on datastore):
# Set-VMSnapshotLocation -vm VM001 -Location "[BigAssDatastore] Snapshots"
#
# For all vms at once (no folder specified will put all in the root of the datastore):
# Get-VM | ForEach-Object {Set-VMSnapshotLocation -vm $_ -Location "[BigAssDatastore]"}
#
# Reset the location to the original location (with the vmx file):
# Set-VMSnapshotLocation -vm VM001 -Reset
 
Function Set-VMSnapshotLocation
	{
	param($vm, [string]$Location, [switch]$Reset=$False)
 
	#Region Input Validation
	# Check vm parameter
	If (!$vm)
		{
		Throw "No VM specified."
		}
	# Check Location parameter.
	# Can be empty when using Reset, can be "[datastore]" or can be "[datastore] folder" (folder must exist).
	If (!$Reset -and $Location -notmatch "\[\S+\](\s\w+)?")
		{
		Throw "Invalid location specified. Syntax: [Datastore] Folder"
		}
	# Specifying Reset will set Location to empty, which causes the original location to be used (same location as vmx file).
	If ($Reset)
		{
		$Location = ""
		}
	# Make sure to get a vm object to work with.
	# This allows both using a vm name when targeting one vm (Set-VMSnapshotLocation -vm VM001 -Reset);
	# AND piping a collection of vm's (Get-VM | ForEach (Set-VMSnapshotLocation -vm $_ -Location "[BigAssDatastore] Snapshots" ).
	If ($vm.GetType().Name -eq "String")
		{
		$oVM = Get-VM $vm
		}
	ElseIf ($vm.GetType().Name -eq "VirtualMachineImpl")
		{
		$oVM = $vm
		}
	Else
		{
		Throw "Parameter vm is of an invalid type."
		}
	#EndRegion InputValidation
 
	#Region Main
	# Get advanced properties of vm
	$vmView = $oVM | Get-View
	# Create object containing new properties
	$vmConfigSpec = New-Object VMware.Vim.VirtualMachineConfigSpec
	$vmConfigSpec.Files = New-Object VMware.Vim.VirtualMachineFileInfo
	$vmConfigSpec.Files.SnapshotDirectory = $Location
	# Reconfigure VM using new properties
	$vmView.ReconfigVM($vmConfigSpec)
	#EndRegion Main
	}