That means that often when you write a PowerShell script you need to account for servers running different versions and adjust accordingly. It can turn a simple scripting exercise into a big task.

Recently I was looking at ways to include our Exchange 2003 servers in some monitoring scripts that are already running for Exchange 2007/2010 servers. I wanted to perform a mail flow test for the Exchange 2003 servers, because that is a test that (if successful) very quickly confirms a lot of the elements involved in email availability are in fact healthy (ie the server is up, reachable, accepting SMTP connections, processing mail queues, the Information Store is running, and more).

For Exchange 2007/2010 the Test-Mailflow cmdlet can be used for these. You can build it into a health check script if you want to. But if you try to run it against an Exchange 2003 server you’ll get an error like this:

[PS] C:\>Test-Mailflow -Identity EX2007SERVER -TargetMailboxServer EX2003SERVER

Test-Mailflow : "EX2003SERVER" is running a previous version of Exchange and does not support this task.
At line:1 char:14
+ Test-Mailflow <<<<  -Identity EX2007SERVER -TargetMailboxServer EX2003SERVER
    + CategoryInfo          : InvalidArgument: (:) [Test-Mailflow], OperationOnOldServerException
    + FullyQualifiedErrorId : 642F2C5C,Microsoft.Exchange.Monitoring.TestMailFlow

However, if the Exchange 2003 server is in the same organization you can use a different parameter with Test-Mailflow to achieve the same result. All you need is an email address for one of the mailboxes on the Exchange 2003 server. You might want to create a mailbox on each of your Exchange 2003 servers (or even each of the databases on those servers) specifically for this purpose.

Then you simply run the Test-Mailflow cmdlet with the -TargetEmailAddress parameter instead of the -TargetMailboxServer parameter.

[PS] C:\>Test-Mailflow -Identity EX2007SERVER -TargetEmailAddress EX2003SERVER_test@domain.com

TestMailflowResult         MessageLatencyTime          IsRemoteTest
------------------         ------------------          ------------
Success                    00:00:19.5014893            True

As you can see this is a nice, simple way to test your Exchange 2003 server health using PowerShell.

Related posts:

• PowerShell: Configuring Settings on Multiple Exchange Mailbox Databases
• Error: Outlook Was Unable to Recover Some or All of the Items in this Folder
• How to Set Up an Automated Exchange 2010 Database Backup Alert Email
• PowerShell Script: Check Exchange 2010 Database Backups
• Using Test-ServiceHealth for Exchange Server Health Checks

This article Using Test-Mailflow with Exchange 2003 Servers is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

If you’re like me then you get asked this question at least once per day. Of course there usually isn’t anything wrong with our Exchange servers but once the question has been asked then you have no choice but to investigate and confirm that everything is okay.

In this article I’m going to demonstrate how you can quickly check the health of your Exchange Server 2010 mailbox servers, and share a script with you that can help to speed up this task.

Exchange Server 2010 has a series of PowerShell cmdlets that make it easy to do a health check of mailbox servers. For example, we can:

• Run Test-Servicehealth to check the required services are all running
• Run Get-MailboxDatabase to check whether the mailbox databases are mounted
• Run Test-MapiConnectivity to verify that the databases are responding to MAPI requests
• Run Test-MailFlow to confirm that email is able to pass successfully between two servers
• Run Get-MailboxDatabaseCopyStatus for DAG members to check the database copy status, queues, and content indexes

That’s quite a few cmdlets to run, especially if we’ve got more than one mailbox server in the organization. And of course each of those cmdlets needs to run and show you output that you need to interpret.

I like to make life a bit easier and use PowerShell scripts to speed up these types of tasks. So naturally I put together a script for performing all of the above tests (and a few more) on my mailbox servers and display a nice simple colour-coded output so that I can tell at a glance whether there might be a problem.

This isn’t designed to do a diagnosis of any problems, it just checks the fundamentals and gives me a simple pass/fail and a few other indicators that I can then troubleshoot further if necessary.

Download the script file here: Test-MailboxServer.ps1 (downloaded 834 times so far)

Extract Test-MailboxServer.ps1 from the Zip file and run it in your Exchange Management Shell to see output such as this:

If you have any questions or bugs to report please let me know in the comments below.

Change log:

• V1.0, 20/11/2011 – Initial version
• V1.1, 10/01/2011 – Fixed $null’s, bugs with Recovery DBs, and ping failure scenarios

Related posts:

• PowerShell Script: Check Exchange Mailbox Database Last Backup Time
• How to Set Up an Automated Exchange 2010 Database Backup Alert Email
• How to List all Users Who Have Access to Other Exchange Mailboxes
• How to Generate a HTML Report of Your Exchange 2010 Environment
• Exchange 2007/2010: How to Clone a Mailbox Database Configuration

This article How to Health Check an Exchange 2010 Mailbox Server is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

• Part 1 – How to Send SMTP Email Using PowerShell
• Part 2 - How to Add a Message Body to Emails Sent from Scripts
• Part 3 - How to Add a HTML Message Body to Emails Sent from Scripts
• Part 4 - How to Create Formatted HTML Output from Scripts

I also shared with you a script that can be used to check Exchange Server 2010 database backups and alert you to any that have not had a recent backup.

Now it’s time to bring all of that information together and demonstrate how you can set up an automated database backup alert email for your Exchange Server 2010 environment.

The two components of this are:

• The PowerShell script itself (we’ll use the one mentioned earlier but with some modifications to email-enable it)
• Task Scheduler for automatically running the script each day

Script for Exchange Server 2010 Database Backup Email Alerts

To email-enable the script I’ve made just a few modifications. The original script used this conditional logic to display the report in the PowerShell window.

#If alert flag is true output the report
if ($alertflag -eq $true )
{
	Write-Host "The following databases have not been backed up in" $threshold "hours."
	$alerts | ft -AutoSize
}
else
{
	Write-Host "No backup alerts required."
}

To change this to send an email alert we can use this code instead:

#If alert flag is true send the email alert
if ($alertflag -eq $true )
{
	#HTML styles for nice formatting
        $style = "<style>BODY{font-family: Arial; font-size: 10pt;}"
	$style = $style + "TABLE{border: 1px solid black; border-collapse: collapse;}"
	$style = $style + "TH{border: 1px solid black; background: #CC0000; padding: 5px; color: #FFFFFF;}"
	$style = $style + "TD{border: 1px solid black; padding: 5px; }"
	$style = $style + "</style>"

        #SMTP options for sending the report email
	$smtpServer = "ho-ex2010-caht1.exchangeserverpro.net"
	$smtpFrom = "reports@exchangeserverpro.net"
	$smtpTo = "administrator@exchangeserverpro.net"
	$messageSubject = "Exchange Backup Alerts"

        $intro = "The following databases have not been backed up in " + $threshold + " hours.<BR><BR>"
	$report = $alerts | ConvertTo-Html -Fragment

	#Get ready to send email message
	$message = New-Object System.Net.Mail.MailMessage $smtpfrom, $smtpto
	$message.Subject = $messageSubject
	$message.IsBodyHTML = $true
	$message.Body = ConvertTo-Html -Body "$intro $report" -Head $style

	#Send email message
	$smtp = New-Object Net.Mail.SmtpClient($smtpServer)
	$smtp.Send($message)

}

If any parts of that don’t make sense just refer to the previous tutorials on sending email with PowerShell.

Here is the full script code we’ll be using for this:

#
#.SYNOPSIS
#Checks the backup timestamps for the servers
#and alerts if a database hasn't been backed up
#in the last 48 hours
#
#.EXAMPLE
#.\Check-DatabaseBackups.ps1
#

#...................................
# Variables
#...................................

#Suppress errors
$ErrorActionPreference = "SilentlyContinue"
$WarningPreference = "SilentlyContinue"

#Load the Exchange 2010 snap-in
Add-PSSnapin Microsoft.Exchange.Management.PowerShell.E2010

#Array to hold alert objects
$alerts = @()

#Set alert threshold for hours since last successful backup
$day = (Get-Date).DayOfWeek
if ($day -eq "Monday")
{
	[int]$threshold = 72
}
else
{
	[int]$threshold = 48
}

#Current time stamp to compare with databases
$now = [DateTime]::Now

#...................................
# Functions
#...................................

#...................................
# Script
#...................................

#Get all Mailbox and Public Folder databases
Write-Host -ForegroundColor Gray "Getting database list..."
$dbs = Get-MailboxDatabase -Status
$dbs = $dbs += Get-PublicFolderDatabase -Status

#Check each database for most recent backup
foreach ($db in $dbs)
{
	Write-Host -ForegroundColor Gray "Checking" $db.name"..."

	$lastbackup = @{}
	$ago = @()
	[bool]$alertflag = $false

	if ( $db.LastFullBackup -eq $null -and $db.LastIncrementalBackup -eq $nul)
	{
		$lastbackup.time = "Never"
		$lastbackup.type = "Never"
		[string]$ago = "Never"
	}
	elseif ( $db.LastFullBackup -lt $db.LastIncrementalBackup )
	{
		$lastbackup.time = $db.LastIncrementalBackup
		$lastbackup.type = "Incremental"
		[int]$ago = ($now - $lastbackup.time).TotalHours
		$ago = "{0:N0}" -f $ago
	}
	elseif ( $db.LastIncrementalBackup -lt $db.LastFullBackup )
	{
		$lastbackup.time = $db.LastFullBackup
		$lastbackup.type = "Full"
		[int]$ago = ($now - $lastbackup.time).TotalHours
		$ago = "{0:N0}" -f $ago
	}

	if ($db.IsMailboxDatabase -eq $true) {$dbtype = "Mailbox"}
	if ($db.IsPublicFolderDatabase -eq $true) {$dbtype = "Public Folder"}

	#If backup time stamp older than threshold set alert flag and create object for alerting
	if ( $ago -gt $threshold -or $ago -eq "Never")
	{
		$alertflag = $true
		$dbObj = New-Object PSObject
		if ( $dbtype -eq "Public Folder")
		{
			$dbObj | Add-Member NoteProperty -Name "Server/DAG" -Value $db.Server
		}
		else
		{
			$dbObj | Add-Member NoteProperty -Name "Server/DAG" -Value $db.MasterServerOrAvailabilityGroup
		}
		$dbObj | Add-Member NoteProperty -Name "Database" -Value $db.name
		$dbObj | Add-Member NoteProperty -Name "Database Type" -Value $dbtype
		$dbObj | Add-Member NoteProperty -Name "Last Backup Type" -Value $lastbackup.type
		$dbObj | Add-Member NoteProperty -Name "Hrs Ago" -Value $ago
		$dbObj | Add-Member NoteProperty -Name "Time Stamp" -Value $lastbackup.time
		$dbObj | Add-Member NoteProperty -Name "Currently Running" -Value $db.backupinprogress
		$alerts = $alerts += $dbObj
	}
}

#If alert flag is true send the email alert
if ($alertflag -eq $true )
{
	#HTML styles for nice formatting
        $style = "<style>BODY{font-family: Arial; font-size: 10pt;}"
	$style = $style + "TABLE{border: 1px solid black; border-collapse: collapse;}"
	$style = $style + "TH{border: 1px solid black; background: #CC0000; padding: 5px; color: #FFFFFF;}"
	$style = $style + "TD{border: 1px solid black; padding: 5px; }"
	$style = $style + "</style>"

        #SMTP options for sending the report email
	$smtpServer = "ho-ex2010-caht1.exchangeserverpro.net"
	$smtpFrom = "reports@exchangeserverpro.net"
	$smtpTo = "administrator@exchangeserverpro.net"
	$messageSubject = "Exchange Backup Alerts"

        $intro = "The following databases have not been backed up in " + $threshold + " hours.<BR><BR>"
	$report = $alerts | ConvertTo-Html -Fragment

	#Get ready to send email message
	$message = New-Object System.Net.Mail.MailMessage $smtpfrom, $smtpto
	$message.Subject = $messageSubject
	$message.IsBodyHTML = $true
	$message.Body = ConvertTo-Html -Body "$intro $report" -Head $style

	#Send email message
	$smtp = New-Object Net.Mail.SmtpClient($smtpServer)
	$smtp.Send($message)

}

If you’re using this script in your environment you will need to change the SMTP options to suit.

Save the script as Get-DailyBackupAlerts.ps1 in a folder called C:\Scripts on the server where you would like it to run each day. Note that the script depends on the Exchange Server 2010 management tools, so they will also need to be installed.

Using Task Scheduler to Run PowerShell Scripts

Now we need to configure the scheduled task in Task Scheduler. On a Windows Server 2008 server you’ll find this in the Administrative Tools. After you’ve launched Task Scheduler click on Create Task.

Give the task a meaningful name, set it to Run whether user is logged on or not, and also if necessary change the user account that it will run as (you may wish to create a special Exchange administrative account with a strong password for running these types of scripts).

On the Triggers tab click new and add a Weekly trigger for each of your normal business days that you want the script to run (eg Monday – Friday). Set the Start time to suit your normal backups finishing time and your own work schedule.

On the Actions tab click New and add an action of Start a program. Configure the program of powershell.exe and the arguments -command “c:\scripts\get-dailybackupalerts.ps1″

Click OK to finish creating the new task. You will be prompted to enter the credentials for the account that you configured the task to run as.

Now you can test the scheduled task by right-clicking on it in the Task Scheduler Library and choosing Run.

Assuming you have some databases that have not backed up recently you should receive an alert email shortly after running the scheduled task.

Note: if your backups are all up to date you can test the script by changing the $threshold variable to something very low such as 1.

Related posts:

• PowerShell Script: Check Exchange 2010 Database Backups
• PowerShell Script: Check Exchange Mailbox Database Last Backup Time
• Avoid Running Out of Transaction Log Disk Space on Exchange Servers
• Using Test-Mailflow with Exchange 2003 Servers
• How to Health Check an Exchange 2010 Mailbox Server

This article How to Set Up an Automated Exchange 2010 Database Backup Alert Email is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

Perhaps the environment is large enough that the backups are managed by a separate team to the Exchange administrators, and so the Exchange admins just want to keep an eye on their database backups. Or even in a smaller environment the administrators may just want to be sure that their backup software isn’t reporting successful backups when in fact they may be failing.

In this post I will demonstrate a PowerShell script that you can run in an Exchange Server 2010 environment to report on any databases that have not successfully backed up in the last 48 hours. Let’s take a look at how this works.

Firstly, backup time stamps are retrievable using the Get-MailboxDatabase cmdlet for mailbox databases, or Get-PublicFolderDatabase for public folder databases. Here is an example:

PS C:\Scripts> Get-MailboxDatabase -Status | ft name,last* -auto

Name     LastFullBackup       LastIncrementalBackup LastDifferentialBackup LastCopyBackup
----     --------------       --------------------- ---------------------- --------------
MB-HO-01 11/6/2011 1:40:19 PM
MB-HO-02
MB-HO-03
MB-BR-01

You can see that one of the databases above has been backed up, but the others have not. In a script that checks both mailbox and public folder databases we could use this code to generate the report.

$dbs = Get-MailboxDatabase -Status
$dbs = $dbs += Get-PublicFolderDatabase -Status
$dbs | ft name,last*

Now we can see both the mailbox and the public folder databases.

Name                    LastFullBackup          LastIncrementalBackup   LastDifferentialBackup  LastCopyBackup
----                    --------------          ---------------------   ----------------------  --------------
MB-HO-01                11/6/2011 1:40:19 PM
MB-HO-02
MB-HO-03
MB-BR-01
PF-HO-01                11/6/2011 1:40:20 PM
PF-BR-01

It would be a simple matter to run that command and read the output every single day, but that would not be the most efficient way of checking database backups. There could be dozens or even hundreds of databases in that output, and we’d have to mentally perform the calculations to determine whether the backup time stamp is within the last 48 hours or not.

Instead we want to only to see databases that have not been backed up within the 48 hour threshold. To do this we can use some date maths. Because we’ve already retrieved the database objects into a collection called $dbs we can loop through them to perform the date calculations like this. Note that in this example only Full and Incremental backups are being considered.

foreach ($db in $dbs)
{
	Write-Host -ForegroundColor Gray "Checking" $db.name"..."

	$lastbackup = @{}
	$ago = @()
	[bool]$alertflag = $false

	if ( $db.LastFullBackup -eq $nul -and $db.LastIncrementalBackup -eq $nul)
	{
		$lastbackup.time = "Never"
		$lastbackup.type = "Never"
		[string]$ago = "Never"
	}
	elseif ( $db.LastFullBackup -lt $db.LastIncrementalBackup )
	{
		$lastbackup.time = $db.LastIncrementalBackup
		$lastbackup.type = "Incremental"
		[int]$ago = ($now - $lastbackup.time).TotalHours
		$ago = "{0:N0}" -f $ago
	}
	elseif ( $db.LastIncrementalBackup -lt $db.LastFullBackup )
	{
		$lastbackup.time = $db.LastFullBackup
		$lastbackup.type = "Full"
		[int]$ago = ($now - $lastbackup.time).TotalHours
		$ago = "{0:N0}" -f $ago
	}
}

One of three possible scenarios will be true:

• If the database has not been backed up at all then both Full and Incremental time stamps will be nul, so all of the resulting values are set to “Never”
• If the most recent backup was an Incremental then the type is set to “Incremental” and the $ago variable is set to the number of hours that has passed since that Incremental backup finished
• If the most recent backup was a Full then the type is set to “Full” and the $ago variable is set to the number of hours that has passed since that Full backup finished

Now, because we’re only interested in databases that haven’t backed up in the last 48 hours (or have never been backed up at all) we can compare the $ago variable to our threshold of 48 hours, and if an alert needs to be raised set the alert flag to True and create an object with all of the desired information for our report.

if ( $ago -gt $threshold -or $ago -eq "Never")
	{
		$alertflag = $true
		$dbObj = New-Object PSObject
		$dbObj | Add-Member NoteProperty -Name "Server/DAG" -Value $db.MasterServerOrAvailabilityGroup
		$dbObj | Add-Member NoteProperty -Name "Database" -Value $db.name
		$dbObj | Add-Member NoteProperty -Name "Database Type" -Value $dbtype
		$dbObj | Add-Member NoteProperty -Name "Last Backup Type" -Value $lastbackup.type
		$dbObj | Add-Member NoteProperty -Name "Hrs Ago" -Value $ago
		$dbObj | Add-Member NoteProperty -Name "Time Stamp" -Value $lastbackup.time
		$alerts = $alerts += $dbObj
	}

That code actually goes inside the ForEach loop for the $dbs collection.

The final piece of the script is the report itself. We output it based on whether the alert flag is set to True or False.

if ($alertflag = $true )
{
	Write-Host "The following databases have not been backed up in" $threshold "hours."
	$alerts | ft -AutoSize
}
else
{
	Write-Host "No backup alerts required."
}

This example outputs the report to the PowerShell window but you could write your PowerShell script to send an email report instead if you wish.

Here is an example report:

PS C:\Scripts> .\Check-DatabaseBackups.ps1
Getting database list...
Checking MB-HO-01 ...
Checking MB-HO-02 ...
Checking MB-HO-03 ...
Checking MB-BR-01 ...
Checking PF-HO-01 ...
Checking PF-BR-01 ...
The following databases have not been backed up in 48 hours.

Server/DAG     Database Database Type Last Backup Type Hrs Ago Time Stamp
----------     -------- ------------- ---------------- ------- ----------
dag-headoffice MB-HO-02 Mailbox       Never            Never   Never
dag-headoffice MB-HO-03 Mailbox       Never            Never   Never
BR-EX2010-MB   MB-BR-01 Mailbox       Never            Never   Never
BR-EX2010-MB   PF-BR-01 Public Folder Never            Never   Never

And here is the complete script.

#
#.SYNOPSIS
#Checks the backup timestamps for the servers
#and alerts if a database hasn't been backed up
#in the last 48 hours
#
#.EXAMPLE
#.\Check-DatabaseBackups.ps1
#

#...................................
# Variables
#...................................

$ErrorActionPreference = "SilentlyContinue"
$WarningPreference = "SilentlyContinue"

$alerts = @()
[int]$threshold = 48

$now = [DateTime]::Now

#...................................
# Script
#...................................

#Get all Mailbox and Public Folder databases
Write-Host -ForegroundColor Gray "Getting database list..."
$dbs = Get-MailboxDatabase -Status
$dbs = $dbs += Get-PublicFolderDatabase -Status

#Check each database for most recent backup
foreach ($db in $dbs)
{
	Write-Host -ForegroundColor Gray "Checking" $db.name"..."

	$lastbackup = @{}
	$ago = @()
	[bool]$alertflag = $false

	if ( $db.LastFullBackup -eq $null -and $db.LastIncrementalBackup -eq $nul)
	{
		$lastbackup.time = "Never"
		$lastbackup.type = "Never"
		[string]$ago = "Never"
	}
	elseif ( $db.LastFullBackup -lt $db.LastIncrementalBackup )
	{
		$lastbackup.time = $db.LastIncrementalBackup
		$lastbackup.type = "Incremental"
		[int]$ago = ($now - $lastbackup.time).TotalHours
		$ago = "{0:N0}" -f $ago
	}
	elseif ( $db.LastIncrementalBackup -lt $db.LastFullBackup )
	{
		$lastbackup.time = $db.LastFullBackup
		$lastbackup.type = "Full"
		[int]$ago = ($now - $lastbackup.time).TotalHours
		$ago = "{0:N0}" -f $ago
	}

	if ($db.IsMailboxDatabase -eq $true) {$dbtype = "Mailbox"}
	if ($db.IsPublicFolderDatabase -eq $true) {$dbtype = "Public Folder"}

	#If backup time stamp older than threshold set alert flag and create object for alerting
	if ( $ago -gt $threshold -or $ago -eq "Never")
	{
		$alertflag = $true
		$dbObj = New-Object PSObject
		$dbObj | Add-Member NoteProperty -Name "Server/DAG" -Value $db.MasterServerOrAvailabilityGroup
		$dbObj | Add-Member NoteProperty -Name "Database" -Value $db.name
		$dbObj | Add-Member NoteProperty -Name "Database Type" -Value $dbtype
		$dbObj | Add-Member NoteProperty -Name "Last Backup Type" -Value $lastbackup.type
		$dbObj | Add-Member NoteProperty -Name "Hrs Ago" -Value $ago
		$dbObj | Add-Member NoteProperty -Name "Time Stamp" -Value $lastbackup.time
		$alerts = $alerts += $dbObj
	}
}

#If alert flag is true output the report
if ($alertflag = $true )
{
	Write-Host "The following databases have not been backed up in" $threshold "hours."
	$alerts | ft -AutoSize
}
else
{
	Write-Host "No backup alerts required."
}

Related posts:

• How to Set Up an Automated Exchange 2010 Database Backup Alert Email
• PowerShell: Configuring Settings on Multiple Exchange Mailbox Databases
• PowerShell Script: Check Exchange Mailbox Database Last Backup Time
• Using Test-Mailflow with Exchange 2003 Servers
• Using Test-ServiceHealth for Exchange Server Health Checks

This article PowerShell Script: Check Exchange 2010 Database Backups is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

• Part 1 – How to Send SMTP Email Using PowerShell
• Part 2 - How to Add a Message Body to Emails Sent from Scripts
• Part 3 - How to Add a HTML Message Body to Emails Sent from Scripts
• Part 4 - How to Create Formatted HTML Output from Scripts

One of the downsides to creating HTML output from PowerShell scripts is that the formatting is not very nice. The default formatting results in messages that look something like this.

The HTML for that email message was created by piping the output from one command into the ConvertTo-HTML cmdlet. Fortunately ConvertTo-HTML has the -Head parameter that can be used to add style information to the HTML that it generates.

For example, by adding this line to the script used in the last article we can change the font to something a little nicer to look at.

$style = "< style>BODY{font:arial 10pt;}< /style>"

Note: extra spaces have been added to the style tags so that WordPress does not remove them.

Then modify the ConvertTo-HTML cmdlet to add the -Head parameter.

$message.Body = Get-ExchangeServer | Select-Object Name,ServerRole | ConvertTo-Html -Head $style

This time when the script is run the email looks like this instead.

That is a little better, but we can do a lot more. How about we add some more styles to the table and really make it look nice.

$style = "< style>BODY{font-family: Arial; font-size: 10pt;}"
$style = $style + "TABLE{border: 1px solid black; border-collapse: collapse;}"
$style = $style + "TH{border: 1px solid black; background: #dddddd; padding: 5px; }"
$style = $style + "TD{border: 1px solid black; padding: 5px; }"
$style = $style + "< /style>"

Again note that extra spaces were added to the style tags above to preserve them in WordPress.

Now the script produces an email that looks like this.

Although this requires you to know a little bit about how HTML styles work, it is a pretty easy topic to learn and once you get a few working styles in your scripting tool kit you can just use them over and over again.

Related posts:

• How to Send SMTP Email Using PowerShell (Part 3)
• How to Send SMTP Email Using PowerShell (Part 2)
• Using Test-Mailflow with Exchange 2003 Servers
• How to Set Up an Automated Exchange 2010 Database Backup Alert Email
• PowerShell Script: Check Exchange 2010 Database Backups

This article How to Send SMTP Email Using PowerShell (Part 4) is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

I’ve tried a few different PowerShell editors and PowerGUI is the one I now use on a daily basis. From the PowerGUI website:

PowerGUI® Pro is graphical PowerShell administration console with an integrated editor and debugger. PowerGUI Pro has all the same great features from our freeware PowerGUI, plus it enables use of PowerShell from mobile devices and protects your scripts with integrated version control.

To be in the running to win this great prize all you have to do is write a PowerShell script to meet one (or more if you like) of the scripting challenges posted in the Exchange Server Pro forums.

There are three challenges:

• Top 12 Mailbox Size Report
• Exchange Backups Check
• Mailbox Statistics Report

You can read the full details here.

The contest runs until midnight on Saturday 13th November (Australian EST) to allow plenty of time to create good quality scripts.

Best of luck!

Related posts:

• Using Test-Mailflow with Exchange 2003 Servers
• How to Set Up an Automated Exchange 2010 Database Backup Alert Email
• PowerShell Script: Check Exchange 2010 Database Backups
• How to Send SMTP Email Using PowerShell (Part 4)
• How to Send SMTP Email Using PowerShell (Part 3)

This article Win a Free PowerGUI Pro License is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

• Part 1 – How to Send SMTP Email Using PowerShell
• Part 2 - How to Add a Message Body to Emails Sent from Scripts
• Part 3 - How to Add a HTML Message Body to Emails Sent from Scripts
• Part 4 - How to Create Formatted HTML Output from Scripts

In this article we’ll take it a step further by adding a HTML message body to an email.

For this to work we’ll be using an System.Net.Mail.MailMessage .NET object. This is basically a message object that can be sent via the SmtpClient .NET object that we used in the previous articles. The benefit of using this object in a script is that it can be used to create HTML email messages.

To create the script we can start with similar variables to last time.

$smtpServer = "ho-ex2010-caht1.exchangeserverpro.net"
$smtpFrom = "reports@exchangeserverpro.net"
$smtpTo = "administrator@exchangeserverpro.net"
$messageSubject = "List of Exchange Servers"

Next we create the new MailMessage object using the variables above as the To and From addresses, and then set the message subject as well.

$message = New-Object System.Net.Mail.MailMessage $smtpfrom, $smtpto
$message.Subject = $messageSubject

Now comes the important bit, setting the message body to be HTML.

$message.IsBodyHTML = $true

Now all we need is some HTML content to go into the message body. As an example let’s just get a list of Exchange servers and their server roles.

$message.Body = Get-ExchangeServer | Select-Object Name,ServerRole | ConvertTo-Html

All I needed to do above is run Get-ExchangeServer, pipe the output into a Select-Object command to grab just the server name and roles, and then pipe that into the ConvertTo-Html command.

The final step is to create the SmtpClient object and send the mail message.

$smtp = New-Object Net.Mail.SmtpClient($smtpServer)
$smtp.Send($message)

The result is an email that looks similar to this.

Here is the complete example script.

$smtpServer = "ho-ex2010-caht1.exchangeserverpro.net"
$smtpFrom = "reports@exchangeserverpro.net"
$smtpTo = "administrator@exchangeserverpro.net"
$messageSubject = "List of Exchange Servers"

$message = New-Object System.Net.Mail.MailMessage $smtpfrom, $smtpto
$message.Subject = $messageSubject
$message.IsBodyHTML = $true

$message.Body = Get-ExchangeServer | Select-Object Name,ServerRole | ConvertTo-Html

$smtp = New-Object Net.Mail.SmtpClient($smtpServer)
$smtp.Send($message)

As you can see this is a pretty simple technique that can be used to easily create basic HTML email messages.

Related posts:

• How to Send SMTP Email Using PowerShell (Part 2)
• How to Send SMTP Email Using PowerShell (Part 4)
• How to Send SMTP Email Using PowerShell (Part 1)
• Using Test-Mailflow with Exchange 2003 Servers
• How to Set Up an Automated Exchange 2010 Database Backup Alert Email

This article How to Send SMTP Email Using PowerShell (Part 3) is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

As the name suggests, Test-ServiceHealth checks the state of the services that should be running on the Exchange server. One of the best things about this cmdlet is that it checks the services depending on the Exchange server roles that are installed.

So for example, for a Hub Transport server only those services relating to the Hub Transport role will be checked. While for a “typical” Exchange 2010 server the services for the Hub Transport, Client Access, and Mailbox server roles will be checked.

Here is an example of the Test-ServiceHealth results.

[PS] C:\>Test-ServiceHealth br-ex2010-mb

Role                    : Mailbox Server Role
RequiredServicesRunning : True
ServicesRunning         : {IISAdmin, MSExchangeADTopology, MSExchangeIS, MSExchangeMailboxAssistants, MSExchangeMailSub
                          mission, MSExchangeRepl, MSExchangeRPC, MSExchangeSA, MSExchangeSearch, MSExchangeServiceHost
                          , MSExchangeThrottling, MSExchangeTransportLogSearch, W3Svc, WinRM}
ServicesNotRunning      : {}

Role                    : Client Access Server Role
RequiredServicesRunning : True
ServicesRunning         : {IISAdmin, MSExchangeAB, MSExchangeADTopology, MSExchangeFBA, MSExchangeFDS, MSExchangeMailbo
                          xReplication, MSExchangeProtectedServiceHost, MSExchangeRPC, MSExchangeServiceHost, W3Svc, Wi
                          nRM}
ServicesNotRunning      : {}

Role                    : Hub Transport Server Role
RequiredServicesRunning : True
ServicesRunning         : {IISAdmin, MSExchangeADTopology, MSExchangeEdgeSync, MSExchangeServiceHost, MSExchangeTranspo
                          rt, MSExchangeTransportLogSearch, W3Svc, WinRM}
ServicesNotRunning      : {}

As you can see that is a lot of useful information. But whenever possible I like to see just the minimum relevant information for my servers. In the case of Test-ServiceHealth the RequiredServicesRunning result is the thing I am most interested in.

So in this case I could run the following command to see just that information:

[PS] C:\>Test-ServiceHealth br-ex2010-mb | ft Role,RequiredServicesRunning -auto

Role                      RequiredServicesRunning
----                      -----------------------
Mailbox Server Role                          True
Client Access Server Role                    True
Hub Transport Server Role                    True

Much better.

Now suppose I wanted to run that for all of my Exchange servers. I could do that with the following command:

[PS] C:\>Get-ExchangeServer | Test-ServiceHealth | ft Role,RequiredServicesRunning -auto

Role                      RequiredServicesRunning
----                      -----------------------
Client Access Server Role                    True
Hub Transport Server Role                    True
Client Access Server Role                    True
Hub Transport Server Role                    True
Mailbox Server Role                         False
Mailbox Server Role                          True
Client Access Server Role                    True
Hub Transport Server Role                    True
Mailbox Server Role                          True
Client Access Server Role                    True
Hub Transport Server Role                    True

Interesting, especially the one that failed the test for the Mailbox server role. But in that output I can’t tell which server failed.

Let’s try this instead:

[PS] C:\>$servers = Get-ExchangeServer
[PS] C:\>foreach ($server in $servers) {
>> Write-Host "Checking" $server.name
>> Test-ServiceHealth $server | ft Role,RequiredServicesRunning -auto
>> }
>>

Now we get output that is a little more useful, and tells me which server failed the test.

Checking HO-EX2010-CAHT1

Role                      RequiredServicesRunning
----                      -----------------------
Client Access Server Role                    True
Hub Transport Server Role                    True

Checking HO-EX2010-CAHT2

Role                      RequiredServicesRunning
----                      -----------------------
Client Access Server Role                    True
Hub Transport Server Role                    True

Checking HO-EX2010-MB1

Role                RequiredServicesRunning
----                -----------------------
Mailbox Server Role                   False

Checking HO-EX2010-MB2

Role                RequiredServicesRunning
----                -----------------------
Mailbox Server Role                    True

Checking BR-EX2010-CAHT

Role                      RequiredServicesRunning
----                      -----------------------
Client Access Server Role                    True
Hub Transport Server Role                    True

Checking BR-EX2010-MB

Role                      RequiredServicesRunning
----                      -----------------------
Mailbox Server Role                          True
Client Access Server Role                    True
Hub Transport Server Role                    True

But it still isn’t quite enough, so let’s wrap this up into a handy script that will do the following:

• Run Test-SystemHealth for all of the Exchange servers in the organization
• Tell me which servers passed the test
• Tell me which servers failed the test, and why

Here is the script code that will perform those steps.

#Get the list of Exchange servers in the organization
$servers = Get-ExchangeServer

#Loop through each server
ForEach ($server in $servers)
{
	Write-Host -ForegroundColor White "---------- Testing" $server

	#Initialize an array object for the Test-ServiceHealth results
	[array]$servicehealth = @()

	#Run Test-ServiceHealth
	$servicehealth = Test-ServiceHealth $server

	#Output the results
	ForEach($serverrole in $servicehealth)
	{
		If ($serverrole.RequiredServicesRunning -eq $true)
		{
			Write-Host $serverrole.Role -NoNewline; Write-Host -ForegroundColor Green "Pass"
		}
		Else
		{
			Write-Host $serverrole.Role -nonewline; Write-Host -ForegroundColor Red "Fail"
			[array]$notrunning = @()
			$notrunning = $serverrole.ServicesNotRunning
			ForEach ($svc in $notrunning)
			{
				$alertservices += $svc
			}
			Write-Host $serverrole.Role "Services not running:"
			ForEach ($al in $alertservices)
				{
					Write-Host -ForegroundColor Red `t$al
				}
		}
	}
}

The output from running the script will look something like this.

You can now see at a glance which servers have passed the test, which ones failed, and which services aren’t running for the servers that failed.

Related posts:

• How to Migrate a Relay Connector from Exchange Server 2007 to 2010
• How to List all Users Who Have Access to Other Exchange Mailboxes
• Exchange 2007/2010: How to Clone a Mailbox Database Configuration
• Exchange 2007/2010 Public Folder Store in an Inconsistent State
• PowerShell: Configuring Settings on Multiple Exchange Mailbox Databases

This article Using Test-ServiceHealth for Exchange Server Health Checks is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

Now it is pretty easy to get the sizes for Exchange mailboxes and to handle the formatting of the Exchange 2010 mailbox statistics so that they are easier to perform calculations on, but it gets a bit boring running those commands day after day.

Even worse, after running the commands to create a CSV report I still had to open that in Excel, remove the unwanted details, use Excel formulas to convert the values from bytes to megabytes, sort them into order, and so on. Again not difficult, just boring after doing it hundreds of times.

So I created a PowerShell script to do all of the heavy lifting for me, and I’m sharing that script with you here. Let’s take a look at how the script works.

Firstly the script accepts two optional parameters; -database or -file. These tell the script whether to run a report on a given mailbox database, or to run a report on a list of mailbox names in a text file.

param(
	[string]$database = "",
	[string]$file = ""
)

You can specify either parameter, but not both at once, nor can you run the script without any parameters.

#Determine whether correct parameters have been used

if( $database -eq "" -and $file -eq "" )
{
	Write-Host -ForegroundColor Red "You must specify either -database or -file"
}

if( $database -ne "" -and $file -ne "" )
{
	Write-Host -ForegroundColor Red "You can't use both -database and -file"
}

With the correct parameter used the script executes one of two functions to generate the report.

#Get the report

if( $database -ne "" )
{
	Get-ReportDBMode $database
}

if( $file -ne "" )
{
	Get-ReportFileMode $file
}

Those functions simply retrieve the mailbox statistics, sort them in order of largest to smallest, perform the conversions of the values from bytes to megabytes, and then clean up the output to just the relevant information.

#...................................
# Functions
#...................................

function Get-ReportDBMode {

	param ($database)
	$report = Get-MailboxStatistics -database $database | Sort-Object TotalItemSize -Descending | Select-Object DisplayName,@{Label="Size(Mb)"; Expression={$_.TotalItemSize.Value.ToMb()}},LastLogonTime
	return ($report)
}

function Get-ReportFileMode {

	param ($file)
	$report = Get-Content $file | Get-MailboxStatistics | Sort-Object TotalItemSize -Descending | Select-Object DisplayName,@{Label="Size(Mb)"; Expression={$_.TotalItemSize.Value.ToMb()}},LastLogonTime
	return ($report)
}

The output will be similar to this:

Here are a few examples of how to run the script:

.\Get-MailboxReport.ps1 -database MB-HO-01

.\Get-MailboxReport.ps1 -file .\users.txt

.\Get-MailboxReport.ps1 -file .\users.txt | Export-CSV -NoTypeInformation -Path report.csv

Here is the complete script:

#Get-MailboxReport.ps1
#Written By: Paul Cunningham
#URL: http://exchangeserverpro.com
#
#Change Log
#V1.0, 15/10/2011 - Initial version
#
#.SYNOPSIS
#Lists the mailboxes and mailbox sizes for
#the specified database or list of users. Output
#is sorted by TotalItemSize in descending order.
#
#.EXAMPLE
#.\Get-MailboxReport.ps1 -database MB-HO-01
#Returns a report with the mailbox statistics for all mailbox users in
#database MB-HO-01
#
#.EXAMPLE
#.\Get-MailboxReport.ps1 -file .\users.txt
#Returns a report with the mailbox statistics for all mailbox users in
#the file users.txt
#
#.EXAMPLE
#.\Get-MailboxReport.ps1 -file .\users.txt | Export-CSV -NoTypeInformation -Path report.csv
#Exports the report into a CSV file so that it can be opened in Microsoft Excel for
#further analysis
#

param(
	[string]$database = "",
	[string]$file = ""
)

#...................................
# Static Variables
#...................................

#...................................
# Functions
#...................................

function Get-ReportDBMode {

	param ($database)
	$report = Get-MailboxStatistics -database $database | Sort-Object TotalItemSize -Descending | Select-Object DisplayName,@{Label="Size(Mb)"; Expression={$_.TotalItemSize.Value.ToMb()}},LastLogonTime
	return ($report)
}

function Get-ReportFileMode {

	param ($file)
	$report = Get-Content $file | Get-MailboxStatistics | Sort-Object TotalItemSize -Descending | Select-Object DisplayName,@{Label="Size(Mb)"; Expression={$_.TotalItemSize.Value.ToMb()}},LastLogonTime
	return ($report)
}

#...................................
# Script
#...................................

#Determine whether correct parameters have been used

if( $database -eq "" -and $file -eq "" )
{
	Write-Host -ForegroundColor Red "You must specify either -database or -file"
}

if( $database -ne "" -and $file -ne "" )
{
	Write-Host -ForegroundColor Red "You can't use both -database and -file"
}

#Get the report

if( $database -ne "" )
{
	Get-ReportDBMode $database
}

if( $file -ne "" )
{
	Get-ReportFileMode $file
}

Related posts:

• How to Move Exchange Mailboxes in a Text File using PowerShell
• Using Test-Mailflow with Exchange 2003 Servers
• PowerShell Script: Check Exchange 2010 Database Backups
• Using Test-ServiceHealth for Exchange Server Health Checks
• Exchange 2010 FAQ: How to Minimise Downtime During Mailbox Migration from Exchange 2007

This article PowerShell Script to Create a Mailbox Size Report for Exchange Server 2010 is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com

• Part 1 – How to Send SMTP Email Using PowerShell
• Part 2 - How to Add a Message Body to Emails Sent from Scripts
• Part 3 - How to Add a HTML Message Body to Emails Sent from Scripts
• Part 4 - How to Create Formatted HTML Output from Scripts

In this article we’ll take a closer look at how you can create the email message body for emails that you are sending via PowerShell.

In the last article I demonstrated a simple PowerShell script for sending emails that contained the following code, using the SmtpClient .NET object .

#
#.SYNOPSIS
#Sends SMTP email via the Hub Transport server
#
#.EXAMPLE
#.\Send-Email.ps1 -To "administrator@exchangeserverpro.net" -Subject "Test email" -Body "This is a test"
#

param(
[string]$to,
[string]$subject,
[string]$body
)

$smtpServer = "ho-ex2010-caht1.exchangeserverpro.net"
$smtpFrom = "reports@exchangeserverpro.net"
$smtpTo = $to
$messageSubject = $subject
$messageBody = $body

$smtp = New-Object Net.Mail.SmtpClient($smtpServer)
$smtp.Send($smtpFrom,$smtpTo,$messagesubject,$messagebody)

Now let’s build on that example by adding more content to the message body of the emails.

Using Command Output as Email Message Content with PowerShell

When running this script anything that we specify with the -Body parameter will be the message body of the email. It could be a text string, or it could even be the output from another PowerShell command. For example:

[PS] C:\Scripts>.\Send-Email.ps1 -To "administrator@exchangeserverpro.net" -Subject "List of Exchange Servers" -Body (Get-ExchangeServer)

The command above would produce an email that looks like this:

Neat trick, but notice how the list of Exchange servers appears as all one string that wraps over two lines? Wouldn’t it be nicer to see the server names displayed in an easier to read list format? Let’s take a look at how you can achieve that.

[PS] C:\Scripts>[string]$emailbody = ""

[PS] C:\Scripts>$servers = Get-ExchangeServer

[PS] C:\Scripts>foreach ($server in $servers) {$emailbody = $emailbody + $server.name + "`r`n"}

[PS] C:\Scripts>.\Send-Email.ps1 -To "administrator@exchangeserverpro.net" -Subject "List of Exchange Servers" -Body $emailbody

So what did I do there? Here are the steps I just followed:

1. Declare a variable $emailbody as type string. This will be the variable that is passed to the script to be the message body of the email that gets sent.
2. Used the Get-ExchangeServer cmdlet to retrieve a list of the Exchange servers in the organization into an array of $servers.
3. Looped through the array using the ForEach-Object (abbreviated to “foreach”) cmdlet and appended each server name to the $emailbody string, including (and this is the important part) a carriage return after each server name.
4. Ran the script using the $emailbody variable for the -Body script parameter.

The result is an email that looks like this; much better don’t you agree?

Now this is only a demonstration. In reality you probably aren’t going to want to send yourself an email with a list of your Exchange servers, at least not very often.

However you can use the same techniques I’ve just demonstrated to build scripts that email you any command or script output, such as a list of mailboxes with no storage quotas that you have emailed to yourself automatically each month.

Using File Contents as Email Message Content with PowerShell

Another technique for getting content for the message body of an email sent via PowerShell is to use the contents of a file.

For example, I run continuous pings between certain servers to detect any network interruptions that may be occurring. An entry is written to a log file any time a ping times out. Every day I want to receive an email with the results of the previous day’s ping monitoring, so I can do that using a script like this.

#
#.SYNOPSIS
#Sends daily dropped ping report
#
#.EXAMPLE
#.\Send-DroppedPingReport.ps1
#

$smtpServer = "ho-ex2010-caht1.exchangeserverpro.net"
$smtpFrom = "reports@exchangeserverpro.net"
$smtpTo = "administrator@exchangeserverpro.net"
$messageSubject = "Dropped ping report"

[string]$messagebody = ""

$logs = Get-Content C:\Logs\droppedpings.log

foreach ($log in $logs )
{
	$messagebody = $messagebody + $log + "`r`n"
}

$smtp = New-Object Net.Mail.SmtpClient($smtpServer)
$smtp.Send($smtpFrom,$smtpTo,$messagesubject,$messagebody)

This is the same technique that was used earlier to create an array and loop through it to add the carriage returns so that the email is formatted nicely. The main difference is the use of Get-Content instead of Get-ExchangeServer.

As you can see it is very simple to create useful, informative emails that are sent by your PowerShell scripts.

Related posts:

• How to Send SMTP Email Using PowerShell (Part 3)
• How to Send SMTP Email Using PowerShell (Part 4)
• How to Send SMTP Email Using PowerShell (Part 1)
• Using Test-Mailflow with Exchange 2003 Servers
• How to Set Up an Automated Exchange 2010 Database Backup Alert Email

This article How to Send SMTP Email Using PowerShell (Part 2) is © 2011 ExchangeServerPro.com

Get more Exchange Server tips at ExchangeServerPro.com