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
	}

# Description: Ask a user to answer a question with either yes or no.
 
# Example use: 
# If (Ask-YesOrNo)
# 	{ 
#	# User has confirmed
#	...
#	}
#	Else
#	{
#	# User did not confirm
#	...
#	}
 
Function Ask-YesOrNo
	{
	param([string]$title="Confirm",[string]$message="Are you sure?")
	$choiceYes = New-Object System.Management.Automation.Host.ChoiceDescription "&Yes", "Answer Yes."
	$choiceNo = New-Object System.Management.Automation.Host.ChoiceDescription "&No", "Answer No."
	$options = [System.Management.Automation.Host.ChoiceDescription[]]($choiceYes, $choiceNo)
	$result = $host.ui.PromptForChoice($title, $message, $options, 1)
		switch ($result)
    	{
			0 
			{
			Return $true
			}
 
			1 
			{
			Return $false
			}
		}
	}

$VC = Connect-VIServer "MyVCServer"
$myCol = @()
ForEach ($VMHost in (Get-VMHost | Sort Name))
	{
	ForEach ($VM in ($VMHost | Get-VM))
		{
		ForEach ($NIC in (Get-NetworkAdapter -VM $VM))
			{
			$myObj = "" | Select VMHost, VM, NIC, PortGroup, vSwitch
			$myObj.VMHost = $VMHost.Name
			$myObj.VM = $VM.Name
			$myObj.NIC = $NIC.Name
			$myObj.PortGroup = Get-VirtualPortGroup -VM $VM -Name $NIC.NetworkName
			$myObj.vSwitch = $myObj.PortGroup.VirtualSwitchName
			$myCol += $myObj
			}
		}
	}
$myCol | Group-Object VMHost, vSwitch -NoElement | Sort Name | Select Name, Count
Disconnect-VIServer -Confirm:$false

# Variables
$OutFile = "D:\Scripts\ReadyTimes.csv"
$VIServer = "MyVIServer.domain.local"
 
# Connect to Virtual Center
$VI = Connect-VIServer $VIServer
 
$myCol = @()
ForEach ($VMHost in (Get-VMHost | Sort Name))
	{
	ForEach ($VM in ($VMHost | Get-VM | Sort Name))
		{
		# Gather Stats
		$Ready = $VM | Get-Stat -Stat Cpu.Ready.Summation -RealTime
		$Used = $VM | Get-Stat -Stat Cpu.Used.Summation -RealTime
		$Wait = $VM | Get-Stat -Stat Cpu.Wait.Summation -RealTime
		For ($a = 0; $a -lt $VM.NumCpu; $a++)
			{
			$myObj = "" | Select VMHost, VM, Instance, %RDY, %USED, %WAIT
			$myObj.VMHost = $VMHost.Name
			$myObj.VM = $VM.Name
			$myObj.Instance = $a
			$myObj."%RDY" = [Math]::Round((($Ready | Where {$_.Instance -eq $a} | Measure-Object -Property Value -Average).Average)/200,1)
			$myObj."%USED" = [Math]::Round((($Used | Where {$_.Instance -eq $a} | Measure-Object -Property Value -Average).Average)/200,1)
			$myObj."%WAIT" = [Math]::Round((($Wait | Where {$_.Instance -eq $a} | Measure-Object -Property Value -Average).Average)/200,1)
			$myCol += $myObj
			}
		Clear-Variable Ready -ErrorAction SilentlyContinue 
		Clear-Variable Wait -ErrorAction SilentlyContinue 
		Clear-Variable Used -ErrorAction SilentlyContinue 
		Clear-Variable myObj -ErrorAction SilentlyContinue
		}
	}
 
Disconnect-VIServer -Confirm:$false
 
# Export and launch output
$myCol | Export-Csv $OutFile
Invoke-Item $OutFile

Function Get-ScheduledTask
	{
	param([string]$ComputerName = "localhost")
	Write-Host "Computer: $ComputerName"
	$Command = "schtasks.exe /query /s $ComputerName"
	Invoke-Expression $Command
	Clear-Variable Command -ErrorAction SilentlyContinue
	Write-Host "`n"
	}
 
# EXAMPLE: Get-ScheduledTask -ComputerName Server01
 
Function Remove-ScheduledTask
	{
	param(
	[string]$ComputerName = "localhost",
	[string]$TaskName = "blank"
	)
	If ((Get-ScheduledTask -ComputerName $ComputerName) -match $TaskName)
		{
		If ((Read-Host "Are you sure you want to remove task $TaskName from $ComputerName(y/n)") -eq "y")
			{
			$Command = "schtasks.exe /delete /s $ComputerName /tn $TaskName /F"
			Invoke-Expression $Command
			Clear-Variable Command -ErrorAction SilentlyContinue
			}
		}
	Else
		{
		Write-Warning "Task $TaskName not found on $ComputerName"
		}
	}
 
# EXAMPLE: Remove-ScheduledTask -ComputerName Server01 -TaskName MyTask
 
Function Create-ScheduledTask
	{
	param(
	[string]$ComputerName = "localhost",
	[string]$RunAsUser = "System",
	[string]$TaskName = "MyTask",
	[string]$TaskRun = '"C:\Program Files\Scripts\Script.vbs"',
	[string]$Schedule = "Monthly",
	[string]$Modifier = "second",
	[string]$Days = "SUN",
	[string]$Months = '"MAR,JUN,SEP,DEC"',
	[string]$StartTime = "13:00",
	[string]$EndTime = "17:00",
	[string]$Interval = "60"	
	)
	Write-Host "Computer: $ComputerName"
	$Command = "schtasks.exe /create /s $ComputerName /ru $RunAsUser /tn $TaskName /tr $TaskRun /sc $Schedule /mo $Modifier /d $Days /m $Months /st $StartTime /et $EndTime /ri $Interval /F"
	Invoke-Expression $Command
	Clear-Variable Command -ErrorAction SilentlyContinue
	Write-Host "`n"
	}
 
# EXAMPLE: Create-ScheduledTask -ComputerName MyServer -TaskName MyTask02 -TaskRun "D:\scripts\script2.vbs"

Function Increment-PowerGuiXmlVersion
	{
	Param(
	$PersonalXmlFile = (Join-Path $env:appdata "Quest Software\PowerGUI\config.xml"),
	$CentralXmlFile = 'P:\Centrally Managed Files\config.xml',
	$XPath = "//container[@name='version']",
	$IncrementMajor = $false,
	$IncrementMinor = $true
	)
 
	# Load central xml file (for backup and reading the current version number)
	$CentralConfig = New-Object System.Xml.XmlDocument
	$CentralConfig.Load($CentralXmlFile)
 
	# Select the correct node
	$NodeToRead = $CentralConfig.SelectSingleNode($XPath)
 
	# Read the current version
	$CurrentVersion = $NodeToRead.Value
	$MajorVersion = [Int]($CurrentVersion.Split(".")[0])
	$MinorVersion = [Int]($CurrentVersion.Split(".")[1])
	Write-Host "Current Version of Central Xml File: $CurrentVersion"
 
	# Backup central xml file
	$BackupFileName = $CentralXmlFile.Replace(".xml", ("_{0}.xml" -f $CurrentVersion))
	$CentralConfig.Save($BackupFileName)
 
	# Load personal xml file
	$PersonalConfig = New-Object System.Xml.XmlDocument
	$PersonalConfig.Load($PersonalXmlFile)
 
	# Select the correct node
	$NodeToBeChanged = $PersonalConfig.SelectSingleNode($XPath)
 
	# Increment the version
	If ($IncrementMinor){$MinorVersion++}
	If ($IncrementMajor){$MajorVersion++; $MinorVersion = 0}
	$newVersion = [string]::Concat($MajorVersion,".",$MinorVersion)
	Write-Host "New Version of Central Xml File: $newVersion"
 
	# Write the new version
	$NodeToBeChanged.Value = $newVersion
 
	# Save the personal xml file as the new central xml file
	$PersonalConfig.Save($CentralXmlFile)	
	}