Getting the Free Disk Space of Remote Computers Revisited
Published 18 April, 2017Several years ago, I wrote a fairly simplistic script to get the free disk space of remote computers. It wasn't all that sophisticated, but it got the job that I needed done, so I shared it here on my blog, since I thought others might find it useful. Which, based on the number of hits here, and the comments, they did. However, based on some of those comments, it had a problem for some users.
The problem was that I used Write-Host in it. That was fine for me, because I only used it to write to my screen. But it's a bad practice to be using Write-Host unless you really need to manipulate screen colours. The reason it's a bad practice is that it prevents any sort of redirection! This meant that those users who wanted to capture the result of the script in a file were horked, because Write-Host will ALWAYS write to ( ... wait for it... )
The Host. You can't redirect it. The fix, of course, is easy -- use Write-Object instead, which is what I should have done in the first place.
While I was in the process of making that change, I thought it would be nice to add in a basic Get-Help page for it, which was trivial. But then it occurred to me that I really should let it handle pipeline input, allowing me to use other PowerShell commands to select the group of machines I wanted the free disk space on, and then pipe that result directly to Get-myFreeSpace.
Seemed like a good idea, but it turned out I had to almost completely rewrite the script to use the Begin{}/Process{}/End{} syntax. Accepting pipeline input is not as simple as just saying you do in the Parameter statement, you need to actually process that input. The result is the new, improved version of Get-myFreeSpace.ps1 shown below. (If you care about how I got to this script in the first place, do check out the original post, here. There's some useful information there about the whole process. )
<#
.Synopsis
Gets the disk utilization of one or more computers
.Description
Get-myFreeSpace queries an array of remote computers and returns a nicely formatted display of
their current disk utilization and free space. The output can be redirected to a file or other
output option using standard redirection.
.Example
Get-myFreeSpace
Gets the disk utilization and free space of all drives on the local host.
.Example
Get-myFreeSpace -ComputerName Server1,Server2
Gets the disk utilization and free space of all drives on the Server1 and Server2
.Example
(Get-VM -Name "*server*" | Where State -eq 'Running' ).Name | Get-myFreeSpace
PS C:\>(Get-VM -Name "*server*" | Where-Object {$_.State -eq 'Running').Name | Get-myFreeSpace
Gets a list of running VMs with Server in their name, and passes it to Get-myFreeSpace to process for
their current disk utilization. The first version of this example uses PowerShell v5 syntax, while
the second version uses the older syntax that works on earlier versions.
.Parameter ComputerName
An array of computer names from which you want the disk utilization
.Inputs
[string[]]
.Notes
Author: Charlie Russel
Copyright: 2017 by Charlie Russel
: Permission to use is granted but attribution is appreciated
Initial: 26 Nov, 2014 (cpr)
ModHist: 29 Sep, 2016 -- Changed default to array of localhost (cpr)
: 18 Apr, 2017 -- Changed to use Write-Output,accept Pipeline,added man page, (cpr)
:
#>
[CmdletBinding()]
Param(
[Parameter(Mandatory=$False,Position=0,`
ValueFromPipeline=$True,`
ValueFromPipelineByPropertyName=$True,`
ValueFromRemainingArguments=$True)]
[alias("Name","Computer")]
[string[]]
$ComputerName = @("localhost")
)
Begin {
if ($Input) {
$ComputerName = @($Input)
}
Write-Output ""
# Save ErrorActionPreference so we can reset it when we're done
$eap = $ErrorActionPreference
}
Process {
$ErrorActionPreference = 'SilentlyContinue'
ForEach ( $Computer in $ComputerName ) {
Write-Output "Disk Utilization for Computer $Computer is: "
Get-WmiObject -ComputerName $Computer -Class Win32_Volume `
| Format-Table -auto `
@{Label="Drive";`
Expression={$_.DriveLetter};`
Align="Right"},`
@{Label="Free(GB)";`
Expression={"{0:N0}" -f ($_.FreeSpace/1GB)};`
Align="Right"},`
@{Label="% Free";`
Expression={"{0:P0}" -f ($_.FreeSpace / $_.Capacity)};`
Align="Right"},`
@{Label="Size(GB)";`
Expression={"{0:N0}" -f ($_.Capacity / 1GB)};`
Align="Right"},`
@{Label="Volume Label";`
Expression={$_.Label};`
Width=25}
} #EndForEach
} #EndProcessBlock
End {
# Reset ErrorActionPreference to original value
$ErrorActionPreference = $eap
}
And there you have it. A new and improved version of one of the most popular scripts I've ever posted here. You can use it to get the disk utilization on your current machine, or any list of remote computers to which you have the rights to run WMI against.
I hope you find this script useful, and I'd love to hear comments, suggestions for improvements, or bug reports as appropriate. As always, if you use this script as the basis for your own work, please respect my copyright and provide appropriate attribution.
Getting Automatic Services That Are Stopped With PowerShell
Published 29 September, 2016One of the first things I check when I am troubleshooting a system is whether all the services that should be running, are. I could just open up services.msc, click on the "Startup Type" column to sort by the startup type, and scroll down through the Automatic services to see which ones aren't running. But that's so…. GUI :p. And slower, and so very one machine at a time. Instead, let's use PowerShell to make it all easier.
First, I checked Get-Service, thinking it would give me what I need. but it doesn't. There's no way with Get-Service to find out what the startup type is -- it's not a property returned by Get-Service. (Yes, I think this is a deficiency. And yes, I expect someday we might get an improvement to Get-Service. But for the moment, we have to work around it. )
Instead, I decided to use the Get-WmiObject cmdlet to find what we need. (If the machine you're running this from is running PowerShell v3 or later, you can substitute Get-CimInstance for Get-WmiObject. But if you do, you won't be able to use -Credential.)
Get-WmiObject Win32_Service returns a list of all the services on the local machine. We can extend it with -ComputerName to query the services on a remote computer. And we can filter those services, though the filtering uses WQL as the query language, which is a nuisance since it doesn't match up to the Filter syntax for the ActiveDirectory module, for example.
To get a list of all the services that should have started automatically, but that are not currently running, on the local machine:
Get-WmiObject -ClassName Win32_Service -Filter "StartMode='Auto' AND State<>'Running'"
But that output is a bit ugly, so we'll throw some Format-Table at it, and come up with:
Get-WmiObject -ClassName Win32_Service `
-Filter "StartMode='Auto' AND State<>'Running'" `
| Format-Table -Auto DisplayName,Name,StartMode,State
Not bad. That gives us an easy to read output with all the information we need. We can wrap that up in a simple cmdlet that assumes the local computer, but that allows us to run it against multiple computers. And we want it to be able to get that list of computer names through the pipeline, of course. Plus, we'll add a Credential parameter to allow us to run against machines on a different domain, or a workgroup, so long as we provide an appropriate credential.
If we're going to get output from multiple computers, however, we need to know which one has which services that aren't running. To do that, we take advantage of Format-Tables GroupBy parameter:
Get-WmiObject -ClassName Win32_Service `
-Filter "StartMode='Auto' AND State<>'Running'" `
| Format-Table -AutoSize `
-Property DisplayName,Name,StartMode,State `
-GroupBy PSComputer
Now we have everything we need to pull our script together.
Get-myStoppedService.ps1
<#
.Synopsis
Gets a list of stopped services
.Description
Get-myStoppedService takes a list of computer names and returns
a table of the stopped services on that computer that are set to
automatically start. The default is to return a list on the local computer.
.Example
Get-myStoppedService
Returns a table of stopped services on the local computer
.Example
Get-myStoppedService -ComputerName 'server1','client2'
Returns a table of stopped services on server1 and client2,
grouped by computer name
.Parameter ComputerName
A list of remote computer names to query. If the current account
doesn't have permission to query WMI on the remote computer, use
the Credential parameter to provide alternate credentials.
The default is the local host.
.Parameter Credential
Standard PSCredential object. Use Get-Credential.
.Inputs
[string[]]
[PSCredential]
.Notes
Author: Charlie Russel
Copyright: 2016 by Charlie Russel
: Permission to use is granted but attribution is appreciated
Initial: 29 September, 2016 (cpr)
ModHist:
:
#>
[CmdletBinding()]
Param(
[Parameter(Mandatory=$False,Position=0,ValueFromPipeline=$True)]
[Alias("Name","VMName")]
[string[]]
$ComputerName = ".",
[Parameter(Mandatory=$False,ValueFromPipeline=$True)]
[PSCredential]
$Credential = $NULL
)
if ($Credential) {
Get-WMIObject -ClassName Win32_Service `
-Credential $Credential `
-ComputerName $ComputerName `
-Filter "StartMode='Auto' AND State<>'Running'" `
| Format-Table -Auto DisplayName,Name,StartMode,State -GroupBy PSComputerName
} else {
Get-WmiObject -ClassName Win32_Service `
-ComputerName $ComputerName `
-Filter "StartMode='Auto' AND State<>'Running'" `
| Format-Table -Auto DisplayName,Name,StartMode,State -GroupBy PSComputerName
}
Unmapping Network Drives
Published 27 June, 2015Unmapping network drives with PowerShell should be easy, and it is, but with some caveats. If you always create your network drive mappings with New-PSDrive, then it's easy to unmap them with Remove-PSDrive. But if some of them are created with Group Policy, some of them with the legacy "net use" commands, some of them with New-SmbMapping, and some with New-PSDrive, it's really not that easy to fully clean up the list of mapped drives. I've used a variety of techniques over the years to map and unmap drives, and I've finally come to the conclusion that using New-PSDrive and Remove-PSDrive is the cleanest way for most things. However, if you've got a mix of mapped drives, created with more than one method, here's a script to remove them all.
<#
.SYNOPSIS
Unmaps network drives
.DESCRIPTION
Unmapdrives removes all currently mapped network drives. It's smart enough to
remove drives mapped with "net use", "New-SmbMapping" and "New-PSDrive". This
cmdlet accepts no parameters and assumes -Force for all unmappings.
.EXAMPLE
UnMapDrives
Unmaps all currently mapped network drives
.NOTES
Author: Charlie Russel
Copyright: 2015 by Charlie Russel
: Permission to use is granted but attribution is appreciated
Initial: 06/27/2015 (cpr)
ModHist:
:
#>
[CmdletBinding()]
# Build a dynamic list of currently mapped drives
$DriveList = Get-WMIObject Win32_LogicalDisk `
| Where-Object { $_.DriveType -eq 4 }
# Don't bother running this if we don't have any mapped drives
if ($DriveList) {
$SmbDriveList = $DriveList.DeviceID
} else {
Write-Host "No mapped drives found"
Return
}
Write-host "Unmapping drive: " -NoNewLine
Write-Host $SmbDriveList
Write-Host " "
Foreach ($drive in $SmbDriveList) {
$psDrive = $drive -replace ":" #remove unwanted colon from PSDrive name
Remove-SmbMapping -LocalPath $Drive -Force -UpdateProfile
If ( (Get-PSDrive -Name $psDrive) 2>$Null ) {
Remove-PSDrive -Name $psDrive -Force
}
}
Write-Host " "
# Report back all FileSystem drives to confirm that only local drives are present.
Get-PSDrive -PSProvider FileSystem
This is the simple form of a more generalized script that can accept a parameter of either -All or a list of mapped drive letters to remove. (And yes, unmap isn't an approved verb. But this script started out life many, many years ago as a batch file ("unmapdrives.cmd"), so it's still got the same base name it has always had, because that's what my fingers remember!)
Posted in PowerShell, WMI | 
Get-WmiObject, PowerShell, PowerShell v3, Remove-PSDrive, Remove-SmbMapping, WMI | 
2 CommentsGetting the Free Disk Space of Remote Computers
Published 26 November, 2014(For an updated version of this post and script, see Getting the Free Disk Space of Remote Computers Revisited.)
This started out as a simple script to try to get the free space on one of my servers, but I quickly discovered that using WMI’s Win32_LogicalDisk could only give me part of the solution. The catch is that Win32_LogicalDisk doesn’t return the information about volumes that aren’t assigned drive letters. Which is a problem if what you really need to know is how close to out of space your backup disk is! Because Windows Server Backup takes total control of the backup target disk, and doesn’t mount it as a drive letter, you need to use a different WMI Class to get the information you need. After asking some friends (PowerShell MVPs ROCK!), I was pointed to Win32_Volume, which returns all sorts of information about disk volumes whether they are assigned drive letters or not.
The next issue was how to get the actual information I wanted, and then to format it so that it actually made some sense. For example:
(Get-WmiObject –ComputerName Server1 –Class Win32_Volume).FreeSpace 21654667264 103541030912 75879378944 142417367040 5500928 565375053824 PSH>
This doesn’t really cut it. OK, let’s try at least getting it into a table:
Get-WmiObject –ComputerName Server1 –Class Win32_Volume | ft –auto DriveLetter,Label,FreeSpace DriveLetter Label FreeSpace ----------- ----- --------- C: 21655351296 D: DATA 103541030912 E: EXCHANGE 75879378944 F: FILES 142417367040 Y: New Volume 5500928 Server1 2014_10_15 10:57 DISK_03 565375053824
Well, that’s a bit more useful, but frankly, that number for the backup volume seems big, but is it 500 GB, or 50 GB? At first glance, I have no idea. And if it’s 50 GB, I’m in trouble, but if it’s 500 GB, we’re fine. So, we need to do a bit of manipulation to the output from Format-Table, and the tool for this is to create an Expression that allows you to calculate and format a result in a way that makes more sense. For this, we use an expression as the property to display. So, for example, to display that “565375053824” as Gigabytes, we use:
Get-WmiObject –ComputerName Server1 –Class Win32_Volume ` | ft –auto DriveLetter,` Label,` @{Label=”Free(GB)”;Expression={'{0:N0}’ –F ($_.FreeSpace/1GB)}}DriveLetter Label Free(GB) ----------- ----- -------- C: 20 D: DATA 96 E: EXCHANGE 71 F: FILES 133 Y: New Volume 0 Server1 2014_10_15 10:57 DISK_03 527
Now we’re getting somewhere. But what did we do? We use the @{} to tell Format-Table that we were going to use an expression to define a column of data. The Label=”Free(GB)” creates a new column header, and the Expression={“{0:N0}” –F means we’re going to have a numeric value (including thousands separators) with no decimal values. The calculated value for the column is ($_.FreeSpace/1GB).
So we now have a useful listing of free space on the remote server. Of course, it might be even more useful to know the percentage free. No problem, for that we use the formatting expression “{0:P0}” to express the column as a percentage, and use the calculation of ($_.FreeSpace/$_.Capacity), letting PowerShell do the work of converting that to a percentage. So:
Get-WmiObject –ComputerName Server1 –Class Win32_Volume ` | ft –auto DriveLetter,` Label,` @{Label=”Free(GB)”;Expression={“{0:N0}” –F ($_.FreeSpace/1GB)}},` @{Label=”%Free”;Expression={“{0:P0}” –F ($_.FreeSpace/$_.Capacity)}}DriveLetter Label Free(GB) %Free ----------- ----- -------- ----- C: 20 17 % D: DATA 96 48 % E: EXCHANGE 71 71 % F: FILES 133 18 % Y: New Volume 0 58 % Server1 12014_10_15 10:57 DISK_03 527 51 % <br>
Now we almost have it. Next, it would probably be useful to get the total capacity of the disk while we’re at it, and since I have more than one server, we should probably plan on passing this whole thing an array of computer names. So, the final script, at least for this first pass:
# *********************************************
# ScriptName: Get-myFreeSpace.ps1
#
# Description: Script to get the free disk space
# : on a remote computer and display it usefully
#
# ModHist: 26/11/2014 - Initial, Charlie
# : 18/04/2017 - Change to Write-Output.
#
#
# *********************************************
[CmdletBinding()]
Param ([Parameter(Mandatory=$False,Position=0)]
[String[]]$ComputerName = "Server1")
Write-Output ""
ForEach ( $Name in $ComputerName ) {
Write-Output "Disk Utilization for server $Name is: "
Get-WmiObject -ComputerName $Name -Class Win32_Volume `
| Format-Table -auto `
@{Label="Drive";`
Expression={$_.DriveLetter};`
Align="Right"},`
@{Label="Free(GB)";`
Expression={"{0:N0}" -f ($_.FreeSpace/1GB)};`
Align="Right"},`
@{Label="% Free";`
Expression={"{0:P0}" -f ($_.FreeSpace / $_.Capacity)};`
Align="Right"},`
@{Label="Size(GB)";`
Expression={"{0:N0}" -f ($_.Capacity / 1GB)};`
Align="Right"},`
@{Label="Volume Label";`
Expression={$_.Label};`
Width=25}
}
You’ll see I tweaked the formatting to right align the calculated expressions, and gave my volume label column some extra space to improve readability. The result is:
Get-myFreeSpace.ps1 –ComputerName “Server1”,”Server2” Disk Utilization for server Server1 is: Drive Free(GB) % Free Size(GB) Volume Label ----- -------- ------ -------- ------------ C: 20 17 % 120 D: 96 48 % 200 DATA E: 71 71 % 100 EXCHANGE F: 133 18 % 750 FILES Y: 0 58 % 0 New Volume 527 51 % 1,024 Server1 2014_10_15 10:57 DISK_03 Disk Utilization for server Server2 is: Drive Free(GB) % Free Size(GB) Volume Label ----- -------- ------ -------- ------------ 0 25 % 0 D: 1,697 53 % 3,214 Data C: 484 95 % 512
ETA: Changed to use Write-Output instead of Write-Host. No need for the features of Write-Host, and it was causing issues for those who wanted to redirect the output to a file. This is more flexible.
ETA: Changed to clean up the problem formatting from the switch in syntax highlighters. Sigh.
Finding out what RAM DIMMs are installed on a computer without opening the box
Published 9 September, 2014OK, so I needed to know exactly what RAM was installed on a computer and how many slots there were. I could have had the user shutdown his machine, opened up the box, got out a flashlight, popped out the DIMMs, written down the obscure part numbers, plugged them back in, and closed it up. But not only was that way too much like work, it would totally have disrupted his workday. So, instead, I let PowerShell and WMI do the heavy lisfting. The following script will get the currently installed memory modules, the maximum RAM supported on the computer, and the number slots available.
#****************************************
#
# Script Name: Get-MemoryModule.ps1
#
# Script to get the number of memory slots, and the installed memory, on
# the local computer. Could easily be updated to go against remote computers.
#
# ModHist: 12/29/2012 - initial, Charlie.
# : 08/26/2014 - Charlie. Added logic to get slots and max RAM.
# :
#****************************************
$strComputer = "."
$ComputerName = (hostname)
$colSlots = Get-WmiObject `
-class "Win32_PhysicalMemoryArray" `
-namespace "root\CIMV2" `
-Computername $strComputer
$nSlots = $colSlots.MemoryDevices
$nMax = $colSlots.MaxCapacity
$gbMax = $nMax/(1024*1024)
$colModules = Get-WMIObject `
-class "Win32_PhysicalMemory" `
-namespace "root\CIMV2" `
-computername $strComputer
foreach ($objItem in $colModules) {
Write-host "Bank Label: " $objItem.BankLabel
write-host "Capacity: " $objItem.Capacity
write-host "Caption: " $objItem.Caption
write-host "Creation Class Name: " $objItem.CreationClassName
write-host "Data Width: " $objItem.DataWidth
write-host "Description: " $objItem.Description
write-host "Device Locator: " $objItem.DeviceLocator
write-host "Form Factor: " $objItem.FormFactor
write-host "Hot-Swappable: " $objItem.HotSwappable
write-host "Installation Date: " $objItem.InstallDate
write-host "Interleave Data Depth: " $objItem.InterleaveDataDepth
write-host "Interleave Position: " $objItem.InterleavePosition
write-host "Manufacturer: " $objItem.Manufacturer
write-host "Memory Type: " $objItem.MemoryType
write-host "Model: " $objItem.Model
write-host "Name: " $objItem.Name
write-host "Other Identifying Information: " $objItem.OtherIdentifyingInfo
write-host "Part Number: " $objItem.PartNumber
write-host "Position In Row: " $objItem.PositionInRow
write-host "Powered-On: " $objItem.PoweredOn
write-host "Removable: " $objItem.Removable
write-host "Replaceable: " $objItem.Replaceable
write-host "Serial Number: " $objItem.SerialNumber
write-host "SKU: " $objItem.SKU
write-host "Speed: " $objItem.Speed
write-host "Status: " $objItem.Status
write-host "Tag: " $objItem.Tag
write-host "Total Width: " $objItem.TotalWidth
write-host "Type Detail: " $objItem.TypeDetail
write-host "Version: " $objItem.Version
write-host
}
Write-Host -nonewline "Computer $ComputerName has $nSlots Memory Slots, and a Maximum"
write-host "Memory of $gbMax GigaBytes of RAM" $colModules `
| ft -auto "BankLabel",@{Label="CurrentMem(MB)";Expression={$_.Capacity/(1024*1024)}},"Speed"
I’ve shown the “local” version of this, but it would be trivial to modify the script to run against a remote computer by adding support for a –ComputerName parameter. Also, at least some computers (most notably laptops) will not report their maximum supported memory correctly. I’ve run this script against the 6 physical computers running here and all worked fine expect for my HP laptop. That has 16 GB of RAM in it, but says the maximum RAM is 8 GB.
Getting Drive Information Using WMI and PowerShell
Published 15 June, 2013In my ongoing quest to remove dependency on legacy DOS commands, I recently created this script to get a list of all the local and mapped drives on a machine and how much free space each has on it. This script could be easily extended to display additional information (such as the underlying filesystem type) by simply adding to the output tables. All the information is already captured in the Get-WMIObject call at the beginning, but the fun is in the formatting (and math) of the tables to provide useful information at a glance.
# Filename: GetDrives.ps1 # # A script to get a list and information on the "local" drives without using "Net" # # ModHist: 08/05/2013 - Initial # : # # *********************************************************************** $LogicalDisks = Get-WMIObject Win32_LogicalDisk $LocalHDisks = $LogicalDisks | Where-Object { $_.DriveType -eq 3 } $RemoteDrives = Get-WMIObject Win32_LogicalDisk | Where-Object { $_.DriveType -eq 4 } $OpticalDrives = Get-WMIObject Win32_CDRomDrive$LocalHDisks | ft -auto @{Label="Drive";` Expression={$_.DeviceID}; width=5 align="Right"},` @{Label="Volume Label";` Expression={$_.VolumeName}; Width=25},` @{Label="%Free";` Expression={[int]($_.FreeSpace/$_.Size * 100)};` Width=8},` @{Label="GBFree";` Expression={$([math]::round(($_.FreeSpace/1gb),0))};` Width=8},` @{Label="Size(GB)";` Expression={$([math]::round(($_.Size/1gb),0))};` Width=8} $OpticalDrives | Sort Drive | ft -auto ` @{Label="Drive";` Expression={$_.Drive};` Width=5 Align="Right"}, @{Label="Capabilities";` Expression={ if ($_.Capabilities -eq 4) { ` "Read/Write" ` } else { ` "Read-Only"}}},` @{Label="Disk Volume Label";` Expression={$_.VolumeName}} $RemoteDrives | ft -auto @{Label="Drive";` Expression={$_.DeviceID};` width=5 align="Right"},` @{Label="Remote Share";` Expression={$_.ProviderName};` Width=25}, @{Label="%Free";` Expression={[int]($_.FreeSpace/$_.Size * 100)};` Width=8},` @{Label="GBFree";` Expression={$([math]::round(($_.FreeSpace/1gb),0))};` Width=8},` @{Label="Size(GB)";` Expression={$([math]::round(($_.Size/1gb),0))};` Width=8}
If you find this script interesting or useful, great. And if you have improvements to it, I'd be delighted to hear about them.
Charlie.
Stopping All Running Virtual Machines (Hyper-V)
Published 6 April, 2012So, a good friend and fellow MVP asked me for a script to shut down all running virtual machines on a server so she could do cold backups of them. This seemed like a perfectly reasonable request, and my first thought was “Well, this gets really obvious and easy in Windows Server 8” since we have a full set of Hyper-V cmdlets there. But then I sort of remembered doing something like this before, and hunted around and found this old TechNet Wiki article I wrote over a year ago. It wasn’t a full fledged script, but had all the pieces I needed to put together a simple script to stop all the VMs on the local Hyper-V host:
# This is a simple script to stop all the currently running VMs on the local
# Hyper-V host. It could easily be extended to accept a command line
# argument of the name of a remote Hyper-V hosts or a list of hosts into an array
$VMs = Get-WmiObject MSVM_ComputerSystem -computer "." -namespace "root\virtualization"
foreach ($vm in $VMs) {
if ( $vm.name -ne $vm.elementname ) {
# skip the parent's name
if ( $vm.EnabledState -eq 2 ) {
# If the VM is running
$shutdown = Get-WmiObject MSVM_ComputerSystem `
-namespace "root\virtualization" `
–query “Associators of {$vm} where ResultClass=Msvm_ShutdownComponent”
$shutdown.iniateShutdown($true,”System Maintenance”)
sleep 5
}
}
}
So, what’s happening in that script? Well, Get-WmiObject grags a list of all the VMs on the local Hyper-V Host (-computer “.”), then we simply loop through the list (skipping host itself ($vm.name -ne $vm.elementname), and for each VM that is running ($vm.EnabledState -eq 2), we get a shutdown object for that specific VM and then call the initiateShutdown method on that object.
Note that this is a “forced shutdown”, so is equivalent to “shutdown –s –f” at the command line. Some processes may not get politely shutdown. Too bad, so sad. Since we need this to work regardless of what else is happening, that’s a necessary risk.
ETA: Wow, this is an old script. Written before we had built-in Hyper-V cmdlets to do this. This still works, and isn't version dependent so far as I know, but I've written updated versions of this a couple of times since. The most recent was 2016, here. You might want to check that post out. It's a modern, PowerShell v5 version.
Starting Exchange Services after a Power Failure
Published 15 March, 2011In my environment, with a virtualized SBS 2011 Standard, there are occasionally Microsoft Exchange 2010 services that don't properly restart if there has been an abrupt power failure on the Hyper-V host. (Don't ask.)
Now, of course, the first time this happened, I just logged in to the server and started the services. But when it happened again, it's time to write a script. And it was a fun script, since it uses WMI and PowerShell remoting and other fun stuff.
# Script to start Exchange services on SBS 2011 Server after power failure
#
# Accepts a parameter of the exchange server name, but defaults to SRV2 if none entered
# Assumes you are logged in to the domain with Domain Admin credentials
#
# Created: 14/03/2011 by Charlie
# ModHist: 15/03/11 -switched to using WMI in the session to get StartMode
#
#
param ($ExchSrv = "SRV2" )# first, open a session to the Exchange server
$srv = New-PSSession $ExchSrv#Now use Invoke-Command with -Session
Invoke-Command -Session $srv -scriptblock {
$exsvc = gwmi win32_service | Where-Object {$_.Name -like "MsExch*" `
-and $_.StartMode -eq "Auto" -and $_.State -eq "Stopped" }
if ($exsvc ) {
foreach ($svc in $exsvc ) {
Start-Service $svc.name
}
}
}
The if statement in there is to prevent an error if all the services are running. Of course, for this script to work as it's written, you'll need to run it from a workstation in the SBS domain, and you'll have to enable PowerShell remoting on both the server and the client. If you haven't done that yet, I've posted a quick setup guide on TechNet.
I've posted this script up to the Microsoft Script Center, so if you have comments or suggestions to improve it, please comment there.
Charlie.
PowerShell, Hyper-V and WMI
Published 15 February, 2011I’ve started an article over on the PowerShell Survival Guide Wiki to drop in quick hits how to do “stuff” with Hyper-V, using PowerShell and the native WMI interface of Hyper-V. The WMI namespace for Hyper-V is “root\virtualization”. Turns out managing Hyper-V isn’t as hard as I thought, at least in no small part because working with WMI in PowerShell is actually pretty straightforward. I’m still learning and poking around, but this stuff is all over the net if your bingle skills are good. Today I added the simple steps needed to create a VHD, either dynamic or fixed, to the Wiki page. Any one who wants to join in is more than welcome – that’s what a Wiki is all about after all.
Charlie.
Guest Post — Get-myFreeSpace Revisited
Today's post comes by way of a co-worker, Robert Carlson, who took my previous post on getting the free disk space of remote computers and offered a very useful suggestion -- instead of outputting strings, which is only useful for a display or report, he suggests creating a PSCustomObject and outputting that. Slick! I like it.
So, why a PSCustomObject? Because now he can use it to drive automation, rather than simply reporting. A very handy change, and a good reminder for all of us that we should put off formatting until the last possible moment, because once you pipe something to Format-*, you're done. All your precious objects and their properties are gone, and you're left with a simple string.
The other thing Robert has done is change this from a script to a function. This makes it easier to call from other scripts and allows it to be added to your "toolbox" module. (More on Toolbox Modules soon. ) A worthy change. So, without further ado, here's Robert's revised Get-myFreeSpace function.
function Get-myFreeSpace { <# .Synopsis Gets the disk utilization of one or more computers .Description Get-myFreeSpace queries an array of remote computers and returns a nicely formatted display of their current disk utilization and free space. The output can be redirected to a file or other output option using standard redirection, or can be piped to further commands. .Parameter ComputerName An array of computer names from which you want the disk utilization .Example (Get-VM -Name “*server*” | Where-Object {$_.State -eq ‘Running’).Name } | Get-myFreeSpace Gets the free disk space of the running virtual machines whose name includes 'server' .Inputs [string[]] .Notes Original Author: Charlie Russel Secondary Author: Robert Carlson Copyright: 2017 by Charlie Russel : Permission to use is granted but attribution is appreciated Initial: 26 Nov, 2014 (cpr) ModHist: 29 Sep, 2016 — Changed default to array of localhost (cpr) : 18 Apr, 2017 — Changed to use Write-Output,accept Pipeline,added man page, (cpr) : 20 Apr, 2017 — Changed output to pscustomobject rather than string, etc.(RC) #> [CmdletBinding()] Param( [Parameter(Mandatory=$False,Position=0,` ValueFromPipeline=$True,` ValueFromPipelineByPropertyName=$True,` ValueFromRemainingArguments=$True)] [alias(“Name”,”Computer”)] [string[]] $ComputerName = @(“localhost”) ) Begin { if ($Input) { $ComputerName = @($Input) } } Process { ForEach ( $Computer in $ComputerName ) { $volumes = Get-WmiObject -ComputerName $Computer -Class Win32_Volume -ErrorAction SilentlyContinue foreach ($volume in $volumes) { $volumeData = [pscustomobject]@{ ComputerName=$Computer Drive=$volume.DriveLetter VolumeLabel=$volume.Label VolumeSize=”{0:N0}” -f ($volume.Capacity / 1GB) FreeSpace=”{0:N0}” -f ($volume.FreeSpace/1GB) } if ($volume.Capacity) { $percentage = “{0:P0}” -f ($volume.FreeSpace / $volume.Capacity) $volumeData | Add-Member -NotePropertyName “PercentageFree” -NotePropertyValue $percentage } else { $volumeData | Add-Member -NotePropertyName “PercentageFree” -NotePropertyValue “n/a” } Write-Output $volumeData } } } }I really appreciate Robert's contribution, and I thank him profoundly for his suggestion. I learned something, and I hope you have too. I hope you found this useful, and I'd love to hear comments, suggestions for improvements, or bug reports as appropriate. As always, if you use this script as the basis for your own work, please respect my copyright and provide appropriate attribution.