|
<# |
|
|
|
.SYNOPSIS |
|
My Veeam Report is a flexible reporting script for Veeam Backup and |
|
Replication. |
|
|
|
.DESCRIPTION |
|
My Veeam Report is a flexible reporting script for Veeam Backup and |
|
Replication. This report can be customized to report on Backup, Replication, |
|
Backup Copy, Tape Backup, SureBackup and Endpoint Backup jobs as well as |
|
infrastructure details like repositories, proxies and license status. Work |
|
through the User Variables to determine what you would like to see and |
|
determine if you would like to save the results to a file or have them |
|
emailed to you. |
|
|
|
.EXAMPLE |
|
.\MyVeeamReport.ps1 |
|
Run script from (an elevated) PowerShell console |
|
|
|
.NOTES |
|
Author: Shawn Masterson |
|
Last Updated: October 2016 |
|
Version: 9.0.3 |
|
|
|
Requires: |
|
Veeam Backup & Replication v9 (full or console install) |
|
VMware Infrastructure |
|
|
|
#> |
|
|
|
#region User-Variables |
|
# VBR Server (Server Name, FQDN or IP) |
|
$vbrServer = "yourVBRserver" |
|
# Report mode (RPO) - valid modes: any number of hours, Weekly or Monthly |
|
# 24, 48, "Weekly", "Monthly" |
|
$reportMode = 24 |
|
# Report Title |
|
$rptTitle = "My Veeam Report" |
|
# Append Report Mode to Report Title E.g. My Veeam Report (Last 24 Hours) |
|
$modeTitle = $true |
|
# Append VBR Server name to Report Title |
|
$vbrTitle = $true |
|
# HTML Report Width (Pixels) |
|
$rptWidth = 1024 |
|
|
|
# Location of Veeam executable (Veeam.Backup.Shell.exe) |
|
$veeamExePath = "C:\Program Files\Veeam\Backup and Replication\Backup\Veeam.Backup.Shell.exe" |
|
|
|
# Show VM Backup Protection Summary (across entire infrastructure) |
|
$showSummaryProtect = $true |
|
# Show VMs with No Successful Backups within RPO ($reportMode) |
|
$showUnprotectedVMs = $true |
|
# Show VMs with Successful Backups within RPO ($reportMode) |
|
# Also shows VMs with Only Backups with Warnings within RPO ($reportMode) |
|
$showProtectedVMs = $true |
|
# Exclude VMs from Missing and Successful Backups sections |
|
# $excludevms = @("vm1","vm2","*_replica") |
|
$excludeVMs = @("") |
|
# Exclude VMs from Missing and Successful Backups sections in the following (vCenter) folder(s) |
|
# $excludeFolder = @("folder1","folder2","*_testonly") |
|
$excludeFolder = @("") |
|
# Exclude VMs from Missing and Successful Backups sections in the following (vCenter) datacenter(s) |
|
# $excludeDC = @("dc1","dc2","dc*") |
|
$excludeDC = @("") |
|
# Exclude Templates from Missing and Successful Backups sections |
|
$excludeTemp = $false |
|
|
|
# Show Backup Session Summary |
|
$showSummaryBk = $true |
|
# Show Backup Job Status |
|
$showJobsBk = $true |
|
# Show Backup Job Size (total) |
|
$showBackupSizeBk = $true |
|
# Show detailed information for Backup Jobs/Sessions (Avg Speed, Total(GB), Processed(GB), Read(GB), Transferred(GB), Dedupe, Compression) |
|
$showDetailedBk = $true |
|
# Show all Backup Sessions within time frame ($reportMode) |
|
$showAllSessBk = $false |
|
# Show all Backup Tasks from Sessions within time frame ($reportMode) |
|
$showAllTasksBk = $false |
|
# Show Running Backup Jobs |
|
$showRunningBk = $true |
|
# Show Running Backup Tasks |
|
$showRunningTasksBk = $true |
|
# Show Backup Sessions w/Warnings or Failures within time frame ($reportMode) |
|
$showWarnFailBk = $true |
|
# Show Backup Tasks w/Warnings or Failures from Sessions within time frame ($reportMode) |
|
$showTaskWFBk = $true |
|
# Show Successful Backup Sessions within time frame ($reportMode) |
|
$showSuccessBk = $true |
|
# Show Successful Backup Tasks from Sessions within time frame ($reportMode) |
|
$showTaskSuccessBk = $true |
|
# Only show last Session for each Backup Job |
|
$onlyLastBk = $false |
|
# Only report on the following Backup Job(s) |
|
#$backupJob = @("Backup Job 1","Backup Job 3","Backup Job *") |
|
$backupJob = @("") |
|
|
|
# Show Running Restore VM Sessions |
|
$showRestoRunVM = $true |
|
# Show Completed Restore VM Sessions within time frame ($reportMode) |
|
$showRestoreVM = $true |
|
|
|
# Show Replication Session Summary |
|
$showSummaryRp = $true |
|
# Show Replication Job Status |
|
$showJobsRp = $true |
|
# Show detailed information for Replication Jobs/Sessions (Avg Speed, Total(GB), Processed(GB), Read(GB), Transferred(GB), Dedupe, Compression) |
|
$showDetailedRp = $true |
|
# Show all Replication Sessions within time frame ($reportMode) |
|
$showAllSessRp = $false |
|
# Show all Replication Tasks from Sessions within time frame ($reportMode) |
|
$showAllTasksRp = $false |
|
# Show Running Replication Jobs |
|
$showRunningRp = $true |
|
# Show Running Replication Tasks |
|
$showRunningTasksRp = $true |
|
# Show Replication Sessions w/Warnings or Failures within time frame ($reportMode) |
|
$showWarnFailRp = $true |
|
# Show Replication Tasks w/Warnings or Failures from Sessions within time frame ($reportMode) |
|
$showTaskWFRp = $true |
|
# Show Successful Replication Sessions within time frame ($reportMode) |
|
$showSuccessRp = $true |
|
# Show Successful Replication Tasks from Sessions within time frame ($reportMode) |
|
$showTaskSuccessRp = $true |
|
# Only show last session for each Replication Job |
|
$onlyLastRp = $false |
|
# Only report on the following Replication Job(s) |
|
#$replicaJob = @("Replica Job 1","Replica Job 3","Replica Job *") |
|
$replicaJob = @("") |
|
|
|
# Show Backup Copy Session Summary |
|
$showSummaryBc = $true |
|
# Show Backup Copy Job Status |
|
$showJobsBc = $true |
|
# Show Backup Copy Job Size (total) |
|
$showBackupSizeBc = $true |
|
# Show detailed information for Backup Copy Sessions (Avg Speed, Total(GB), Processed(GB), Read(GB), Transferred(GB), Dedupe, Compression) |
|
$showDetailedBc = $true |
|
# Show all Backup Copy Sessions within time frame ($reportMode) |
|
$showAllSessBc = $false |
|
# Show all Backup Copy Tasks from Sessions within time frame ($reportMode) |
|
$showAllTasksBc = $false |
|
# Show Idle Backup Copy Sessions |
|
$showIdleBc = $true |
|
# Show Pending Backup Copy Tasks |
|
$showPendingTasksBc = $true |
|
# Show Working Backup Copy Jobs |
|
$showRunningBc = $true |
|
# Show Working Backup Copy Tasks |
|
$showRunningTasksBc = $true |
|
# Show Backup Copy Sessions w/Warnings or Failures within time frame ($reportMode) |
|
$showWarnFailBc = $true |
|
# Show Backup Copy Tasks w/Warnings or Failures from Sessions within time frame ($reportMode) |
|
$showTaskWFBc = $true |
|
# Show Successful Backup Copy Sessions within time frame ($reportMode) |
|
$showSuccessBc = $true |
|
# Show Successful Backup Copy Tasks from Sessions within time frame ($reportMode) |
|
$showTaskSuccessBc = $true |
|
# Only show last Session for each Backup Copy Job |
|
$onlyLastBc = $false |
|
# Only report on the following Backup Copy Job(s) |
|
#$bcopyJob = @("Backup Copy Job 1","Backup Copy Job 3","Backup Copy Job *") |
|
$bcopyJob = @("") |
|
|
|
# Show Tape Backup Session Summary |
|
$showSummaryTp = $true |
|
# Show Tape Backup Job Status |
|
$showJobsTp = $true |
|
# Show detailed information for Tape Backup Sessions (Avg Speed, Total(GB), Read(GB), Transferred(GB)) |
|
$showDetailedTp = $true |
|
# Show all Tape Backup Sessions within time frame ($reportMode) |
|
$showAllSessTp = $false |
|
# Show all Tape Backup Tasks from Sessions within time frame ($reportMode) |
|
$showAllTasksTp = $false |
|
# Show Waiting Tape Backup Sessions |
|
$showWaitingTp = $true |
|
# Show Idle Tape Backup Sessions |
|
$showIdleTp = $true |
|
# Show Pending Tape Backup Tasks |
|
$showPendingTasksTp = $true |
|
# Show Working Tape Backup Jobs |
|
$showRunningTp = $true |
|
# Show Working Tape Backup Tasks |
|
$showRunningTasksTp = $true |
|
# Show Tape Backup Sessions w/Warnings or Failures within time frame ($reportMode) |
|
$showWarnFailTp = $true |
|
# Show Tape Backup Tasks w/Warnings or Failures from Sessions within time frame ($reportMode) |
|
$showTaskWFTp = $true |
|
# Show Successful Tape Backup Sessions within time frame ($reportMode) |
|
$showSuccessTp = $true |
|
# Show Successful Tape Backup Tasks from Sessions within time frame ($reportMode) |
|
$showTaskSuccessTp = $true |
|
# Only show last Session for each Tape Backup Job |
|
$onlyLastTp = $false |
|
# Only report on the following Tape Backup Job(s) |
|
#$tapeJob = @("Tape Backup Job 1","Tape Backup Job 3","Tape Backup Job *") |
|
$tapeJob = @("") |
|
|
|
# Show all Tapes |
|
$showTapes = $false |
|
# Show all Tapes by (Custom) Media Pool |
|
$showTpMp = $false |
|
# Show all Tapes by Vault |
|
$showTpVlt = $false |
|
# Show all Expired Tapes |
|
$showExpTp = $false |
|
# Show Expired Tapes by (Custom) Media Pool |
|
$showExpTpMp = $true |
|
# Show Expired Tapes by Vault |
|
$showExpTpVlt = $false |
|
# Show Tapes written to within time frame ($reportMode) |
|
$showTpWrt = $true |
|
|
|
# Show Endpoint Backup Session Summary |
|
$showSummaryEp = $true |
|
# Show Endpoint Backup Job Status |
|
$showJobsEp = $true |
|
# Show Endpoint Backup Job Size (total) |
|
$showBackupSizeEp = $true |
|
# Show all Endpoint Backup Sessions within time frame ($reportMode) |
|
$showAllSessEp = $false |
|
# Show Running Endpoint Backup jobs |
|
$showRunningEp = $true |
|
# Show Endpoint Backup Sessions w/Warnings or Failures within time frame ($reportMode) |
|
$showWarnFailEp = $true |
|
# Show Successful Endpoint Backup Sessions within time frame ($reportMode) |
|
$showSuccessEp = $true |
|
# Only show last session for each Endpoint Backup Job |
|
$onlyLastEp = $false |
|
# Only report on the following Endpoint Backup Job(s) |
|
#$epbJob = @("Endpoint Backup Job 1","Endpoint Backup Job 3","Endpoint Backup Job *") |
|
$epbJob = @("") |
|
|
|
# Show SureBackup Session Summary |
|
$showSummarySb = $true |
|
# Show SureBackup Job Status |
|
$showJobsSb = $true |
|
# Show all SureBackup Sessions within time frame ($reportMode) |
|
$showAllSessSb = $false |
|
# Show all SureBackup Tasks from Sessions within time frame ($reportMode) |
|
$showAllTasksSb = $false |
|
# Show Running SureBackup Jobs |
|
$showRunningSb = $true |
|
# Show Running SureBackup Tasks |
|
$showRunningTasksSb = $true |
|
# Show SureBackup Sessions w/Warnings or Failures within time frame ($reportMode) |
|
$showWarnFailSb = $true |
|
# Show SureBackup Tasks w/Warnings or Failures from Sessions within time frame ($reportMode) |
|
$showTaskWFSb = $true |
|
# Show Successful SureBackup Sessions within time frame ($reportMode) |
|
$showSuccessSb = $true |
|
# Show Successful SureBackup Tasks from Sessions within time frame ($reportMode) |
|
$showTaskSuccessSb = $true |
|
# Only show last Session for each SureBackup Job |
|
$onlyLastSb = $false |
|
# Only report on the following SureBackup Job(s) |
|
#$surebJob = @("SureBackup Job 1","SureBackup Job 3","SureBackup Job *") |
|
$surebJob = @("") |
|
|
|
# Show Configuration Backup Summary |
|
$showSummaryConfig = $true |
|
# Show Proxy Info |
|
$showProxy = $true |
|
# Show Repository Info |
|
$showRepo = $true |
|
# Show Replica Target Info |
|
$showReplicaTarget = $true |
|
# Show Veeam Services Info (Windows Services) |
|
$showServices = $true |
|
# Show only Services that are NOT running |
|
$hideRunningSvc = $true |
|
# Show License expiry info |
|
$showLicExp = $true |
|
|
|
# Save HTML output to a file |
|
$saveHTML = $false |
|
# HTML File output path and filename |
|
$pathHTML = "E:\MyVeeamReport_$(Get-Date -format MMddyyyy_hhmmss).htm" |
|
# Launch HTML file after creation |
|
$launchHTML = $false |
|
|
|
# Email configuration |
|
$sendEmail = $true |
|
$emailHost = "smtp.yourserver.com" |
|
$emailUser = "" |
|
$emailPass = "" |
|
$emailFrom = "MyVeeamReport@yourdomain.com" |
|
$emailTo = "you@youremail.com" |
|
# Send HTML report as attachment (else HTML report is body) |
|
$emailAttach = $false |
|
# Email Subject |
|
$emailSubject = $rptTitle |
|
# Append Report Mode to Email Subject E.g. My Veeam Report (Last 24 Hours) |
|
$modeSubject = $true |
|
# Append VBR Server name to Email Subject |
|
$vbrSubject = $true |
|
|
|
# Highlighting Thresholds |
|
# Repository Free Space Remaining % |
|
$repoCritical = 10 |
|
$repoWarn = 20 |
|
# Replica Target Free Space Remaining % |
|
$replicaCritical = 10 |
|
$replicaWarn = 20 |
|
# License Days Remaining |
|
$licenseCritical = 30 |
|
$licenseWarn = 90 |
|
#endregion |
|
|
|
#region VersionInfo |
|
$MVRversion = "9.0.3" |
|
# Version 9.0.3 - SM |
|
# Added report section - VM Backup Protection Summary (across entire infrastructure) |
|
# Split report section - Split out VMs with only Backups with Warnings within RPO to separate from Successful |
|
# Added report section - Backup Job Size (total) |
|
# Added report section - All Backup Sessions |
|
# Added report section - All Backup Tasks |
|
# Added report section - Running Backup Tasks |
|
# Added report section - Backup Tasks with Warnings or Failures |
|
# Added report section - Successful Backup Tasks |
|
# Added report section - Replication Job/Session Summary |
|
# Added report section - Replication Job Status |
|
# Added report section - All Replication Sessions |
|
# Added report section - All Replication Tasks |
|
# Added report section - Running Replication Jobs |
|
# Added report section - Running Replication Tasks |
|
# Added report section - Replication Job/Sessions with Warnings or Failures |
|
# Added report section - Replication Tasks with Warnings or Failures |
|
# Added report section - Successful Replication Jobs/Sessions |
|
# Added report section - Successful Replication Tasks |
|
# Added report section - Backup Copy Session Summary |
|
# Added report section - Backup Copy Job Status |
|
# Added report section - Backup Copy Job Size (total) |
|
# Added report section - All Backup Copy Sessions |
|
# Added report section - All Backup Copy Tasks |
|
# Added report section - Idle Backup Copy Sessions |
|
# Added report section - Pending Backup Copy Tasks |
|
# Added report section - Working Backup Copy Jobs |
|
# Added report section - Working Backup Copy Tasks |
|
# Added report section - Backup Copy Sessions with Warnings or Failures |
|
# Added report section - Backup Copy Tasks with Warnings or Failures |
|
# Added report section - Successful Backup Copy Sessions |
|
# Added report section - Successful Backup Copy Tasks |
|
# Added report section - Tape Backup Session Summary |
|
# Added report section - Tape Job Status |
|
# Added report section - All Tape Backup Sessions |
|
# Added report section - All Tape Backup Tasks |
|
# Added report section - Waiting Tape Backup Sessions |
|
# Added report section - Idle Tape Backup Sessions |
|
# Added report section - Pending Tape Backup Tasks |
|
# Added report section - Working Tape Backup Jobs |
|
# Added report section - Working Tape Backup Tasks |
|
# Added report section - Tape Backup Sessions with Warnings or Failures |
|
# Added report section - Tape Backup Tasks with Warnings or Failures |
|
# Added report section - Successful Tape Backup Sessions |
|
# Added report section - Successful Tape Backup Tasks |
|
# Added report section - All Tapes |
|
# Added report section - All Tapes by (Custom) Media Pool |
|
# Added report section - All Tapes by Vault |
|
# Added report section - All Expired Tapes |
|
# Added report section - Expired Tapes by (Custom) Media Pool - Thanks to Patrick IRVING & Olivier Dubroca! |
|
# Added report section - Expired Tapes by Vault |
|
# Added report section - All Tapes written to within time frame ($reportMode) |
|
# Added report section - Endpoint Backup Job Size (total) |
|
# Added report section - All Endpoint Backup Sessions |
|
# Added report section - SureBackup Session Summary |
|
# Added report section - SureBackup Job Status |
|
# Added report section - All SureBackup Sessions |
|
# Added report section - All SureBackup Tasks |
|
# Added report section - Running SureBackup Jobs |
|
# Added report section - Running SureBackup Tasks |
|
# Added report section - SureBackup Sessions with Warnings or Failures |
|
# Added report section - SureBackup Tasks with Warnings or Failures |
|
# Added report section - Successful SureBackup Sessions |
|
# Added report section - Successful SureBackup Tasks |
|
# Added report section - Configuration Backup Status |
|
# Added report section - Scale Out Repository Info - Thanks to Patrick IRVING & Olivier Dubroca! |
|
# Added exclusion for Templates to VM Backup Protection sections |
|
# Added Last Start and End times to VMs with Successful/Warning Backups |
|
# Added Dedupe and Compression to Backup/Backup Copy/Replication session detailed info |
|
# Added ability to report only on particular jobs (backup/replica/backup copy/tape/surebackup/endpoint) |
|
# Added Mode/Type and Maximum Tasks to Proxy and Repository Info |
|
# Filtered some heavy lifting commands to only run when/if needed |
|
# Converted durations from Mins to HH:MM:SS |
|
# Added html formatting of cells (vertical-align: middle;text-align:center;) |
|
# Lots of misc tweaks/cleanup |
|
# |
|
# Version 9.0.2 - SM |
|
# Fixed issue with Proxy details reported when using IP address instead of server names |
|
# Fixed an issue where services were reported multiple times per server |
|
# |
|
# Version 9.0.1 - SM |
|
# Initial version for VBR v9 |
|
# Updated version to follow VBR version (VeeamMajorVersion.VeeamMinorVersion.MVRVersion) |
|
# Fixed Proxy Information (change in property names in v9) |
|
# Rewrote Repository Info to use newly available properties (yay!) |
|
# Updated Get-VMsBackupStatus to remove obsolete commandlet warning (Thanks tsightler!) |
|
# Added ability to run from console only install |
|
# Added ability to include VBR server in report title and email subject |
|
# Rewrote License Info gathering to allow remote info gathering |
|
# Misc minor tweaks/cleanup |
|
# |
|
# Version 2.0 - SM |
|
# Misc minor tweaks/cleanup |
|
# Proxy host IP info now always returns IPv4 address |
|
# Added ability to query Veeam database for Repository size info |
|
# Big thanks to tsightler - http://forums.veeam.com/powershell-f26/get-vbrbackuprepository-why-no-size-info-t27296.html |
|
# Added report section - Backup Job Status |
|
# Added option to show detailed Backup Job/Session information (Avg Speed, Total(GB), Processed(GB), Read(GB), Transferred(GB)) |
|
# Added report section - Running VM Restore Sessions |
|
# Added report section - Completed VM Restore Sessions |
|
# Added report section - Endpoint Backup Results Summary |
|
# Added report section - Endpoint Backup Job Status |
|
# Added report section - Running Endpoint Backup Jobs |
|
# Added report section - Endpoint Backup Jobs/Sessions with Warnings or Failures |
|
# Added report section - Successful Endpoint Backup Jobs/Sessions |
|
# |
|
# Version 1.4.1 - SM |
|
# Fixed issue with summary counts |
|
# Version 1.4 - SM |
|
# Misc minor tweaks/cleanup |
|
# Added variable for report width |
|
# Added variable for email subject |
|
# Added ability to show/hide all report sections |
|
# Added Protected/Unprotected VM Count to Summary |
|
# Added per object details for sessions w/no details |
|
# Added proxy host name to Proxy Details |
|
# Added repository host name to Repository Details |
|
# Added section showing successful sessions |
|
# Added ability to view only last session per job |
|
# Added Cluster field for protected/unprotected VMs |
|
# Added catch for cifs repositories greater than 4TB as erroneous data is returned |
|
# Added % Complete for Running Jobs |
|
# Added ability to exclude multiple (vCenter) folders from Missing and Successful Backups section |
|
# Added ability to exclude multiple (vCenter) datacenters from Missing and Successful Backups section |
|
# Tweaked license info for better reporting across different date formats |
|
# |
|
# Version 1.3 - SM |
|
# Now supports VBR v8 |
|
# For VBR v7, use report version 1.2 |
|
# Added more flexible options to save and launch file |
|
# |
|
# Version 1.2 - SM |
|
# Added option to show VMs Successfully backed up |
|
# |
|
# Version 1.1.4 - SM |
|
# Misc tweaks/bug fixes |
|
# Reconfigured HTML a bit to help with certain email clients |
|
# Added cell coloring to highlight status |
|
# Added $rptTitle variable to hold report title |
|
# Added ability to send report via email as attachment |
|
# |
|
# Version 1.1.3 - SM |
|
# Added Details to Sessions with Warnings or Failures |
|
# |
|
# Version 1.1.2 - SM |
|
# Minor tweaks/updates |
|
# Added Veeam version info to header |
|
# |
|
# Version 1.1.1 - Shawn Masterson |
|
# Based on vPowerCLI v6 Army Report (v1.1) by Thomas McConnell |
|
# http://www.vpowercli.co.uk/2012/01/23/vpowercli-v6-army-report/ |
|
# http://pastebin.com/6p3LrWt7 |
|
# |
|
# Tweaked HTML header (color, title) |
|
# |
|
# Changed report width to 1024px |
|
# |
|
# Moved hard-coded path to exe/dll files to user declared variables ($veeamExePath/$veeamDllPath) |
|
# |
|
# Adjusted sorting on all objects |
|
# |
|
# Modified info group/counts |
|
# Modified - Total Jobs = Job Runs |
|
# Added - Read (GB) |
|
# Added - Transferred (GB) |
|
# Modified - Warning = Warnings |
|
# Modified - Failed = Failures |
|
# Added - Failed (last session) |
|
# Added - Running (currently running sessions) |
|
# |
|
# Modified job lines |
|
# Renamed Header - Sessions with Warnings or Failures |
|
# Fixed Write (GB) - Broke with v7 |
|
# |
|
# Added support license renewal |
|
# Credit - Gavin Townsend http://www.theagreeablecow.com/2012/09/sysadmin-modular-reporting-samreports.html |
|
# Original Credit - Arne Fokkema http://ict-freak.nl/2011/12/29/powershell-veeam-br-get-total-days-before-the-license-expires/ |
|
# |
|
# Modified Proxy section |
|
# Removed Read/Write/Util - Broke in v7 - Workaround unknown |
|
# |
|
# Modified Services section |
|
# Added - $runningSvc variable to toggle displaying services that are running |
|
# Added - Ability to hide section if no results returned (all services are running) |
|
# Added - Scans proxies and repositories as well as the VBR server for services |
|
# |
|
# Added VMs Not Backed Up section |
|
# Credit - Tom Sightler - http://sightunseen.org/blog/?p=1 |
|
# http://www.sightunseen.org/files/vm_backup_status_dev.ps1 |
|
# |
|
# Modified $reportMode |
|
# Added ability to run with any number of hours (8,12,72 etc) |
|
# Added bits to allow for zero sessions (semi-gracefully) |
|
# |
|
# Added Running Jobs section |
|
# Added ability to toggle displaying running jobs |
|
# |
|
# Added catch to ensure running v7 or greater |
|
# |
|
# |
|
# Version 1.1 |
|
# Added job lines as per a request on the website |
|
# |
|
# Version 1.0 |
|
# Clean up for release |
|
# |
|
# Version 0.9 |
|
# More cmdlet rewrite to improve perfomace, credit to @SethBartlett |
|
# for practically writing the Get-vPCRepoInfo |
|
# |
|
# Version 0.8 |
|
# Added Read/Write stats for proxies at requests of @bsousapt |
|
# Performance improvement of proxy tear down due to rewrite of cmdlet |
|
# Replaced 2 other functions |
|
# Added Warning counter, .00 to all storage returns and fetch credentials for |
|
# remote WinLocal repos |
|
# |
|
# Version 0.7 |
|
# Added Utilisation(Get-vPCDailyProxyUsage) and Modes 24, 48, Weekly, and Monthly |
|
# Minor performance tweaks |
|
#endregion |
|
|
|
#region Connect |
|
# Load Veeam Snapin |
|
If (!(Get-PSSnapin -Name VeeamPSSnapIn -ErrorAction SilentlyContinue)) { |
|
If (!(Add-PSSnapin -PassThru VeeamPSSnapIn)) { |
|
Write-Error "Unable to load Veeam snapin" -ForegroundColor Red |
|
Exit |
|
} |
|
} |
|
|
|
# Connect to VBR server |
|
$OpenConnection = (Get-VBRServerSession).Server |
|
If ($OpenConnection -ne $vbrServer){ |
|
Disconnect-VBRServer |
|
Try { |
|
Connect-VBRServer -server $vbrServer -ErrorAction Stop |
|
} Catch { |
|
Write-Host "Unable to connect to VBR server - $vbrServer" -ForegroundColor Red |
|
exit |
|
} |
|
} |
|
#endregion |
|
|
|
#region NonUser-Variables |
|
# Get all Backup/Backup Copy/Replica Jobs |
|
$allJobs = @() |
|
If ($showSummaryBk + $showJobsBk + $showAllSessBk + $showAllTasksBk + $showRunningBk + |
|
$showRunningTasksBk + $showWarnFailBk + $showTaskWFBk + $showSuccessBk + $showTaskSuccessBk + |
|
$showSummaryRp + $showJobsRp + $showAllSessRp + $showAllTasksRp + $showRunningRp + |
|
$showRunningTasksRp + $showWarnFailRp + $showTaskWFRp + $showSuccessRp + $showTaskSuccessRp + |
|
$showSummaryBc + $showJobsBc + $showAllSessBc + $showAllTasksBc + $showIdleBc + |
|
$showPendingTasksBc + $showRunningBc + $showRunningTasksBc + $showWarnFailBc + |
|
$showTaskWFBc + $showSuccessBc + $showTaskSuccessBc) { |
|
$allJobs = Get-VBRJob |
|
} |
|
# Get all Backup Jobs |
|
$allJobsBk = @($allJobs | ?{$_.JobType -eq "Backup"}) |
|
# Get all Replication Jobs |
|
$allJobsRp = @($allJobs | ?{$_.JobType -eq "Replica"}) |
|
# Get all Backup Copy Jobs |
|
$allJobsBc = @($allJobs | ?{$_.JobType -eq "BackupSync"}) |
|
# Get all Tape Jobs |
|
$allJobsTp = @() |
|
If ($showSummaryTp + $showJobsTp + $showAllSessTp + $showAllTasksTp + |
|
$showWaitingTp + $showIdleTp + $showPendingTasksTp + $showRunningTp + $showRunningTasksTp + |
|
$showWarnFailTp + $showTaskWFTp + $showSuccessTp + $showTaskSuccessTp) { |
|
$allJobsTp = @(Get-VBRTapeJob) |
|
} |
|
# Get all Endpoint Backup Jobs |
|
$allJobsEp = @() |
|
If ($showSummaryEp + $showJobsEp + $showAllSessEp + $showRunningEp + |
|
$showWarnFailEp + $showSuccessEp) { |
|
$allJobsEp = @(Get-VBREPJob) |
|
} |
|
# Get all SureBackup Jobs |
|
$allJobsSb = @() |
|
If ($showSummarySb + $showJobsSb + $showAllSessSb + $showAllTasksSb + |
|
$showRunningSb + $showRunningTasksSb + $showWarnFailSb + $showTaskWFSb + |
|
$showSuccessSb + $showTaskSuccessSb) { |
|
$allJobsSb = @(Get-VSBJob) |
|
} |
|
|
|
# Get all Backup/Backup Copy/Replica Sessions |
|
$allSess = @() |
|
If ($allJobs) { |
|
$allSess = Get-VBRBackupSession |
|
} |
|
# Get all Restore Sessions |
|
$allSessResto = @() |
|
If ($showRestoRunVM + $showRestoreVM) { |
|
$allSessResto = Get-VBRRestoreSession |
|
} |
|
# Get all Tape Backup Sessions |
|
$allSessTp = @() |
|
If ($allJobsTp) { |
|
Foreach ($tpJob in $allJobsTp){ |
|
$tpSessions = [veeam.backup.core.cbackupsession]::GetByJob($tpJob.id) |
|
$allSessTp += $tpSessions |
|
} |
|
} |
|
# Get all Endpoint Backup Sessions |
|
$allSessEp = @() |
|
If ($allJobsEp) { |
|
$allSessEp = Get-VBREPSession |
|
} |
|
# Get all SureBackup Sessions |
|
$allSessSb = @() |
|
If ($allJobsSb) { |
|
$allSessSb = Get-VSBSession |
|
} |
|
|
|
# Get all Backups |
|
$jobBackups = @() |
|
If ($showBackupSizeBk + $showBackupSizeBc + $showBackupSizeEp) { |
|
$jobBackups = Get-VBRBackup |
|
} |
|
# Get Backup Job Backups |
|
$backupsBk = @($jobBackups | ?{$_.JobType -eq "Backup"}) |
|
# Get Backup Copy Job Backups |
|
$backupsBc = @($jobBackups | ?{$_.JobType -eq "BackupSync"}) |
|
# Get Endpoint Backup Job Backups |
|
$backupsEp = @($jobBackups | ?{$_.JobType -eq "EndpointBackup"}) |
|
|
|
# Get all Media Pools |
|
$mediaPools = Get-VBRTapeMediaPool |
|
# Get all Media Vaults |
|
$mediaVaults = Get-VBRTapeVault |
|
# Get all Tapes |
|
$mediaTapes = Get-VBRTapeMedium |
|
# Get all Tape Libraries |
|
$mediaLibs = Get-VBRTapeLibrary |
|
# Get all Tape Drives |
|
$mediaDrives = Get-VBRTapeDrive |
|
|
|
# Get Configuration Backup Info |
|
$configBackup = Get-VBRConfigurationBackupJob |
|
# Get VBR Server object |
|
$vbrServerObj = Get-VBRLocalhost |
|
# Get all Proxies |
|
$proxyList = Get-VBRViProxy |
|
# Get all Repositories |
|
$repoList = Get-VBRBackupRepository |
|
$repoListSo = Get-VBRBackupRepository -ScaleOut |
|
# Get all Tape Servers |
|
$tapesrvList = Get-VBRTapeServer |
|
|
|
# Convert mode (timeframe) to hours |
|
If ($reportMode -eq "Monthly") { |
|
$HourstoCheck = 720 |
|
} Elseif ($reportMode -eq "Weekly") { |
|
$HourstoCheck = 168 |
|
} Else { |
|
$HourstoCheck = $reportMode |
|
} |
|
|
|
# Gather all Backup Sessions within timeframe |
|
$sessListBk = @($allSess | ?{($_.EndTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.CreationTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.State -eq "Working") -and $_.JobType -eq "Backup"}) |
|
If ($backupJob -ne $null -and $backupJob -ne "") { |
|
$allJobsBkTmp = @() |
|
$sessListBkTmp = @() |
|
$backupsBkTmp = @() |
|
Foreach ($bkJob in $backupJob) { |
|
$allJobsBkTmp += $allJobsBk | ?{$_.Name -like $bkJob} |
|
$sessListBkTmp += $sessListBk | ?{$_.JobName -like $bkJob} |
|
$backupsBkTmp += $backupsBk | ?{$_.JobName -like $bkJob} |
|
} |
|
$allJobsBk = $allJobsBkTmp | sort Id -Unique |
|
$sessListBk = $sessListBkTmp | sort Id -Unique |
|
$backupsBk = $backupsBkTmp | sort Id -Unique |
|
} |
|
If ($onlyLastBk) { |
|
$tempSessListBk = $sessListBk |
|
$sessListBk = @() |
|
Foreach($job in $allJobsBk) { |
|
$sessListBk += $tempSessListBk | ?{$_.Jobname -eq $job.name} | Sort-Object EndTime -Descending | Select-Object -First 1 |
|
} |
|
} |
|
# Get Backup Session information |
|
$totalXferBk = 0 |
|
$totalReadBk = 0 |
|
$sessListBk | %{$totalXferBk += $([Math]::Round([Decimal]$_.Progress.TransferedSize/1GB, 2))} |
|
$sessListBk | %{$totalReadBk += $([Math]::Round([Decimal]$_.Progress.ReadSize/1GB, 2))} |
|
$successSessionsBk = @($sessListBk | ?{$_.Result -eq "Success"}) |
|
$warningSessionsBk = @($sessListBk | ?{$_.Result -eq "Warning"}) |
|
$failsSessionsBk = @($sessListBk | ?{$_.Result -eq "Failed"}) |
|
$runningSessionsBk = @($sessListBk | ?{$_.State -eq "Working"}) |
|
$failedSessionsBk = @($sessListBk | ?{($_.Result -eq "Failed") -and ($_.WillBeRetried -ne "True")}) |
|
|
|
# Gather VM Restore Sessions within timeframe |
|
$sessListResto = @($allSessResto | ?{$_.EndTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.CreationTime -ge (Get-Date).AddHours(-$HourstoCheck) -or !($_.IsCompleted)}) |
|
# Get VM Restore Session information |
|
$completeResto = @($sessListResto | ?{$_.IsCompleted}) |
|
$runningResto = @($sessListResto | ?{!($_.IsCompleted)}) |
|
|
|
# Gather all Replication Sessions within timeframe |
|
$sessListRp = @($allSess | ?{($_.EndTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.CreationTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.State -eq "Working") -and $_.JobType -eq "Replica"}) |
|
If ($replicaJob -ne $null -and $replicaJob -ne "") { |
|
$allJobsRpTmp = @() |
|
$sessListRpTmp = @() |
|
$backupsRpTmp = @() |
|
Foreach ($rpJob in $replicaJob) { |
|
$allJobsRpTmp += $allJobsRp | ?{$_.Name -like $rpJob} |
|
$sessListRpTmp += $sessListRp | ?{$_.JobName -like $rpJob} |
|
$backupsRpTmp += $backupsRp | ?{$_.JobName -like $rpJob} |
|
} |
|
$allJobsRp = $allJobsRpTmp | sort Id -Unique |
|
$sessListRp = $sessListRpTmp | sort Id -Unique |
|
$backupsRp = $backupsRpTmp | sort Id -Unique |
|
} |
|
If ($onlyLastRp) { |
|
$tempSessListRp = $sessListRp |
|
$sessListRp = @() |
|
Foreach($job in $allJobsRp) { |
|
$sessListRp += $tempSessListRp | ?{$_.Jobname -eq $job.name} | Sort-Object EndTime -Descending | Select-Object -First 1 |
|
} |
|
} |
|
# Get Replication Session information |
|
$totalXferRp = 0 |
|
$totalReadRp = 0 |
|
$sessListRp | %{$totalXferRp += $([Math]::Round([Decimal]$_.Progress.TransferedSize/1GB, 2))} |
|
$sessListRp | %{$totalReadRp += $([Math]::Round([Decimal]$_.Progress.ReadSize/1GB, 2))} |
|
$successSessionsRp = @($sessListRp | ?{$_.Result -eq "Success"}) |
|
$warningSessionsRp = @($sessListRp | ?{$_.Result -eq "Warning"}) |
|
$failsSessionsRp = @($sessListRp | ?{$_.Result -eq "Failed"}) |
|
$runningSessionsRp = @($sessListRp | ?{$_.State -eq "Working"}) |
|
$failedSessionsRp = @($sessListRp | ?{($_.Result -eq "Failed") -and ($_.WillBeRetried -ne "True")}) |
|
|
|
# Gather all Backup Copy Sessions within timeframe |
|
$sessListBc = @($allSess | ?{($_.EndTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.CreationTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.State -match "Working|Idle") -and $_.JobType -eq "BackupSync"}) |
|
If ($bcopyJob -ne $null -and $bcopyJob -ne "") { |
|
$allJobsBcTmp = @() |
|
$sessListBcTmp = @() |
|
$backupsBcTmp = @() |
|
Foreach ($bcJob in $bcopyJob) { |
|
$allJobsBcTmp += $allJobsBc | ?{$_.Name -like $bcJob} |
|
$sessListBcTmp += $sessListBc | ?{$_.JobName -like $bcJob} |
|
$backupsBcTmp += $backupsBc | ?{$_.JobName -like $bcJob} |
|
} |
|
$allJobsBc = $allJobsBcTmp | sort Id -Unique |
|
$sessListBc = $sessListBcTmp | sort Id -Unique |
|
$backupsBc = $backupsBcTmp | sort Id -Unique |
|
} |
|
If ($onlyLastBc) { |
|
$tempSessListBc = $sessListBc |
|
$sessListBc = @() |
|
Foreach($job in $allJobsBc) { |
|
$sessListBc += $tempSessListBc | ?{$_.Jobname -eq $job.name -and $_.BaseProgress -eq 100} | Sort-Object EndTime -Descending | Select-Object -First 1 |
|
} |
|
} |
|
# Get Backup Copy Session information |
|
$totalXferBc = 0 |
|
$totalReadBc = 0 |
|
$sessListBc | %{$totalXferBc += $([Math]::Round([Decimal]$_.Progress.TransferedSize/1GB, 2))} |
|
$sessListBc | %{$totalReadBc += $([Math]::Round([Decimal]$_.Progress.ReadSize/1GB, 2))} |
|
$idleSessionsBc = @($sessListBc | ?{$_.State -eq "Idle"}) |
|
$successSessionsBc = @($sessListBc | ?{$_.Result -eq "Success"}) |
|
$warningSessionsBc = @($sessListBc | ?{$_.Result -eq "Warning"}) |
|
$failsSessionsBc = @($sessListBc | ?{$_.Result -eq "Failed"}) |
|
$workingSessionsBc = @($sessListBc | ?{$_.State -eq "Working"}) |
|
|
|
# Gather all Tape Backup Sessions within timeframe |
|
$sessListTp = @($allSessTp | ?{$_.EndTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.CreationTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.State -match "Working|Idle"}) |
|
If ($tapeJob -ne $null -and $tapeJob -ne "") { |
|
$allJobsTpTmp = @() |
|
$sessListTpTmp = @() |
|
Foreach ($tpJob in $tapeJob) { |
|
$allJobsTpTmp += $allJobsTp | ?{$_.Name -like $tpJob} |
|
$sessListTpTmp += $sessListTp | ?{$_.JobName -like $tpJob} |
|
} |
|
$allJobsTp = $allJobsTpTmp | sort Id -Unique |
|
$sessListTp = $sessListTpTmp | sort Id -Unique |
|
} |
|
If ($onlyLastTp) { |
|
$tempSessListTp = $sessListTp |
|
$sessListTp = @() |
|
Foreach($job in $allJobsTp) { |
|
$sessListTp += $tempSessListTp | ?{$_.Jobname -eq $job.name} | Sort-Object EndTime -Descending | Select-Object -First 1 |
|
} |
|
} |
|
# Get Tape Backup Session information |
|
$totalXferTp = 0 |
|
$totalReadTp = 0 |
|
$sessListTp | %{$totalXferTp += $([Math]::Round([Decimal]$_.Progress.TransferedSize/1GB, 2))} |
|
$sessListTp | %{$totalReadTp += $([Math]::Round([Decimal]$_.Progress.ReadSize/1GB, 2))} |
|
$idleSessionsTp = @($sessListTp | ?{$_.State -eq "Idle"}) |
|
$successSessionsTp = @($sessListTp | ?{$_.Result -eq "Success"}) |
|
$warningSessionsTp = @($sessListTp | ?{$_.Result -eq "Warning"}) |
|
$failsSessionsTp = @($sessListTp | ?{$_.Result -eq "Failed"}) |
|
$workingSessionsTp = @($sessListTp | ?{$_.State -eq "Working"}) |
|
$waitingSessionsTp = @($sessListTp | ?{$_.State -eq "WaitingTape"}) |
|
|
|
# Gather all Endpoint Backup Sessions within timeframe |
|
$sessListEp = $allSessEp | ?{($_.EndTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.CreationTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.State -eq "Working")} |
|
If ($epbJob -ne $null -and $epbJob -ne "") { |
|
$allJobsEpTmp = @() |
|
$sessListEpTmp = @() |
|
$backupsEpTmp = @() |
|
Foreach ($eJob in $epbJob) { |
|
$allJobsEpTmp += $allJobsEp | ?{$_.Name -like $eJob} |
|
$backupsEpTmp += $backupsEp | ?{$_.JobName -like $eJob} |
|
} |
|
Foreach ($job in $allJobsEpTmp) { |
|
$sessListEpTmp += $sessListEp | ?{$_.JobId -eq $job.Id} |
|
} |
|
$allJobsEp = $allJobsEpTmp | sort Id -Unique |
|
$sessListEp = $sessListEpTmp | sort Id -Unique |
|
$backupsEp = $backupsEpTmp | sort Id -Unique |
|
} |
|
If ($onlyLastEp) { |
|
$tempSessListEp = $sessListEp |
|
$sessListEp = @() |
|
Foreach($job in $allJobsEp) { |
|
$sessListEp += $tempSessListEp | ?{$_.JobId -eq $job.Id} | Sort-Object EndTime -Descending | Select-Object -First 1 |
|
} |
|
} |
|
# Get Endpoint Backup Session information |
|
$successSessionsEp = @($sessListEp | ?{$_.Result -eq "Success"}) |
|
$warningSessionsEp = @($sessListEp | ?{$_.Result -eq "Warning"}) |
|
$failsSessionsEp = @($sessListEp | ?{$_.Result -eq "Failed"}) |
|
$runningSessionsEp = @($sessListEp | ?{$_.State -eq "Working"}) |
|
|
|
# Gather all SureBackup Sessions within timeframe |
|
$sessListSb = @($allSessSb | ?{$_.EndTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.CreationTime -ge (Get-Date).AddHours(-$HourstoCheck) -or $_.State -ne "Stopped"}) |
|
If ($surebJob -ne $null -and $surebJob -ne "") { |
|
$allJobsSbTmp = @() |
|
$sessListSbTmp = @() |
|
Foreach ($SbJob in $surebJob) { |
|
$allJobsSbTmp += $allJobsSb | ?{$_.Name -like $SbJob} |
|
$sessListSbTmp += $sessListSb | ?{$_.JobName -like $SbJob} |
|
} |
|
$allJobsSb = $allJobsSbTmp | sort Id -Unique |
|
$sessListSb = $sessListSbTmp | sort Id -Unique |
|
} |
|
If ($onlyLastSb) { |
|
$tempSessListSb = $sessListSb |
|
$sessListSb = @() |
|
Foreach($job in $allJobsSb) { |
|
$sessListSb += $tempSessListSb | ?{$_.Jobname -eq $job.name} | Sort-Object EndTime -Descending | Select-Object -First 1 |
|
} |
|
} |
|
# Get SureBackup Session information |
|
$successSessionsSb = @($sessListSb | ?{$_.Result -eq "Success"}) |
|
$warningSessionsSb = @($sessListSb | ?{$_.Result -eq "Warning"}) |
|
$failsSessionsSb = @($sessListSb | ?{$_.Result -eq "Failed"}) |
|
$runningSessionsSb = @($sessListSb | ?{$_.State -ne "Stopped"}) |
|
|
|
# Append Report Mode to Report Title |
|
If ($modeTitle) { |
|
If (($reportMode -ne "Weekly") -And ($reportMode -ne "Monthly")) { |
|
$rptTitle = "$rptTitle (Last $reportMode Hrs)" |
|
} Else { |
|
$rptTitle = "$rptTitle ($reportMode)" |
|
} |
|
} |
|
|
|
# Append VBR Server to Report Title |
|
If ($vbrTitle) { |
|
$rptTitle = "$rptTitle - $vbrServer" |
|
} |
|
|
|
# Append Report Mode to Email subject |
|
If ($modeSubject) { |
|
If (($reportMode -ne "Weekly") -And ($reportMode -ne "Monthly")) { |
|
$emailSubject = "$emailSubject (Last $reportMode Hrs)" |
|
} Else { |
|
$emailSubject = "$emailSubject ($reportMode)" |
|
} |
|
} |
|
|
|
# Append VBR Server to Email subject |
|
If ($vbrSubject) { |
|
$emailSubject = "$emailSubject - $vbrServer" |
|
} |
|
#endregion |
|
|
|
#region Functions |
|
|
|
Function Get-VBRProxyInfo { |
|
[CmdletBinding()] |
|
param ( |
|
[Parameter(Position=0, ValueFromPipeline=$true)] |
|
[PSObject[]]$Proxy |
|
) |
|
Begin { |
|
$outputAry = @() |
|
Function Build-Object {param ([PsObject]$inputObj) |
|
$ping = new-object system.net.networkinformation.ping |
|
$isIP = '\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b' |
|
If ($inputObj.Host.Name -match $isIP) { |
|
$IPv4 = $inputObj.Host.Name |
|
} Else { |
|
$DNS = [Net.DNS]::GetHostEntry("$($inputObj.Host.Name)") |
|
$IPv4 = ($DNS.get_AddressList() | Where {$_.AddressFamily -eq "InterNetwork"} | Select -First 1).IPAddressToString |
|
} |
|
$pinginfo = $ping.send("$($IPv4)") |
|
If ($pinginfo.Status -eq "Success") { |
|
$hostAlive = "Alive" |
|
$response = $pinginfo.RoundtripTime |
|
} Else { |
|
$hostAlive = "Dead" |
|
$response = $null |
|
} |
|
If ($inputObj.IsDisabled) { |
|
$enabled = "False" |
|
} Else { |
|
$enabled = "True" |
|
} |
|
$tMode = switch ($inputObj.Options.TransportMode) { |
|
"Auto" {"Automatic"} |
|
"San" {"Direct SAN"} |
|
"HotAdd" {"Hot Add"} |
|
"Nbd" {"Network"} |
|
default {"Unknown"} |
|
} |
|
$vPCFuncObject = New-Object PSObject -Property @{ |
|
ProxyName = $inputObj.Name |
|
RealName = $inputObj.Host.Name.ToLower() |
|
Disabled = $inputObj.IsDisabled |
|
pType = $inputObj.ChassisType |
|
Status = $hostAlive |
|
IP = $IPv4 |
|
Response = $response |
|
Enabled = $enabled |
|
maxtasks = $inputObj.Options.MaxTasksCount |
|
tMode = $tMode |
|
} |
|
Return $vPCFuncObject |
|
} |
|
} |
|
Process { |
|
Foreach ($p in $Proxy) { |
|
$outputObj = Build-Object $p |
|
} |
|
$outputAry += $outputObj |
|
} |
|
End { |
|
$outputAry |
|
} |
|
} |
|
|
|
Function Get-VBRRepoInfo { |
|
[CmdletBinding()] |
|
param ( |
|
[Parameter(Position=0, ValueFromPipeline=$true)] |
|
[PSObject[]]$Repository |
|
) |
|
Begin { |
|
$outputAry = @() |
|
Function Build-Object {param($name, $repohost, $path, $free, $total, $maxtasks, $rtype) |
|
$repoObj = New-Object -TypeName PSObject -Property @{ |
|
Target = $name |
|
RepoHost = $repohost |
|
Storepath = $path |
|
StorageFree = [Math]::Round([Decimal]$free/1GB,2) |
|
StorageTotal = [Math]::Round([Decimal]$total/1GB,2) |
|
FreePercentage = [Math]::Round(($free/$total)*100) |
|
MaxTasks = $maxtasks |
|
rType = $rtype |
|
} |
|
Return $repoObj |
|
} |
|
} |
|
Process { |
|
Foreach ($r in $Repository) { |
|
# Refresh Repository Size Info |
|
[Veeam.Backup.Core.CBackupRepositoryEx]::SyncSpaceInfoToDb($r, $true) |
|
$rType = switch ($r.Type) { |
|
"WinLocal" {"Windows Local"} |
|
"LinuxLocal" {"Linux Local"} |
|
"CifsShare" {"CIFS Share"} |
|
"DataDomain" {"Data Domain"} |
|
"ExaGrid" {"ExaGrid"} |
|
"HPStoreOnce" {"HP StoreOnce"} |
|
default {"Unknown"} |
|
} |
|
$outputObj = Build-Object $r.Name $($r.GetHost()).Name.ToLower() $r.Path $r.info.CachedFreeSpace $r.Info.CachedTotalSpace $r.Options.MaxTaskCount $rType |
|
} |
|
$outputAry += $outputObj |
|
} |
|
End { |
|
$outputAry |
|
} |
|
} |
|
|
|
Function Get-VBRSORepoInfo { |
|
[CmdletBinding()] |
|
param ( |
|
[Parameter(Position=0, ValueFromPipeline=$true)] |
|
[PSObject[]]$Repository |
|
) |
|
Begin { |
|
$outputAry = @() |
|
Function Build-Object {param($name, $rname, $repohost, $path, $free, $total, $maxtasks, $rtype) |
|
$repoObj = New-Object -TypeName PSObject -Property @{ |
|
SoTarget = $name |
|
Target = $rname |
|
RepoHost = $repohost |
|
Storepath = $path |
|
StorageFree = [Math]::Round([Decimal]$free/1GB,2) |
|
StorageTotal = [Math]::Round([Decimal]$total/1GB,2) |
|
FreePercentage = [Math]::Round(($free/$total)*100) |
|
MaxTasks = $maxtasks |
|
rType = $rtype |
|
} |
|
Return $repoObj |
|
} |
|
} |
|
Process { |
|
Foreach ($rs in $Repository) { |
|
ForEach ($rp in $rs.Extent) { |
|
$r = $rp.Repository |
|
# Refresh Repository Size Info |
|
[Veeam.Backup.Core.CBackupRepositoryEx]::SyncSpaceInfoToDb($r, $true) |
|
$rType = switch ($r.Type) { |
|
"WinLocal" {"Windows Local"} |
|
"LinuxLocal" {"Linux Local"} |
|
"CifsShare" {"CIFS Share"} |
|
"DataDomain" {"Data Domain"} |
|
"ExaGrid" {"ExaGrid"} |
|
"HPStoreOnce" {"HP StoreOnce"} |
|
default {"Unknown"} |
|
} |
|
$outputObj = Build-Object $rs.Name $r.Name $($r.GetHost()).Name.ToLower() $r.Path $r.info.CachedFreeSpace $r.Info.CachedTotalSpace $r.Options.MaxTaskCount $rType |
|
$outputAry += $outputObj |
|
} |
|
} |
|
} |
|
End { |
|
$outputAry |
|
} |
|
} |
|
|
|
Function Get-VBRReplicaTarget { |
|
[CmdletBinding()] |
|
param( |
|
[Parameter(ValueFromPipeline=$true)] |
|
[PSObject[]]$InputObj |
|
) |
|
BEGIN { |
|
$outputAry = @() |
|
$dsAry = @() |
|
If (($Name -ne $null) -and ($InputObj -eq $null)) { |
|
$InputObj = Get-VBRJob -Name $Name |
|
} |
|
} |
|
PROCESS { |
|
Foreach ($obj in $InputObj) { |
|
If (($dsAry -contains $obj.ViReplicaTargetOptions.DatastoreName) -eq $false) { |
|
$esxi = $obj.GetTargetHost() |
|
$dtstr = $esxi | Find-VBRViDatastore -Name $obj.ViReplicaTargetOptions.DatastoreName |
|
$objoutput = New-Object -TypeName PSObject -Property @{ |
|
Target = $esxi.Name |
|
Datastore = $obj.ViReplicaTargetOptions.DatastoreName |
|
StorageFree = [Math]::Round([Decimal]$dtstr.FreeSpace/1GB,2) |
|
StorageTotal = [Math]::Round([Decimal]$dtstr.Capacity/1GB,2) |
|
FreePercentage = [Math]::Round(($dtstr.FreeSpace/$dtstr.Capacity)*100) |
|
} |
|
$dsAry = $dsAry + $obj.ViReplicaTargetOptions.DatastoreName |
|
$outputAry = $outputAry + $objoutput |
|
} Else { |
|
return |
|
} |
|
} |
|
} |
|
END { |
|
$outputAry | Select Target, Datastore, StorageFree, StorageTotal, FreePercentage |
|
} |
|
} |
|
|
|
Function Get-VeeamVersion { |
|
Try { |
|
$veeamExe = Get-Item $veeamExePath |
|
$VeeamVersion = $veeamExe.VersionInfo.ProductVersion |
|
Return $VeeamVersion |
|
} Catch { |
|
Write-Host "Unable to Locate Veeam executable, check path - $veeamExePath" -ForegroundColor Red |
|
exit |
|
} |
|
} |
|
|
|
Function Get-VeeamSupportDate { |
|
param ( |
|
[string]$vbrServer |
|
) |
|
# Query (remote) registry with WMI for license info |
|
Try{ |
|
$wmi = get-wmiobject -list "StdRegProv" -namespace root\default -computername $vbrServer -ErrorAction Stop |
|
$hklm = 2147483650 |
|
$bKey = "SOFTWARE\Veeam\Veeam Backup and Replication\license" |
|
$bValue = "Lic1" |
|
$regBinary = ($wmi.GetBinaryValue($hklm, $bKey, $bValue)).uValue |
|
$veeamLicInfo = [string]::Join($null, ($regBinary | % { [char][int]$_; })) |
|
# Convert Binary key |
|
$pattern = "expiration date\=\d{1,2}\/\d{1,2}\/\d{1,4}" |
|
$expirationDate = [regex]::matches($VeeamLicInfo, $pattern)[0].Value.Split("=")[1] |
|
$datearray = $expirationDate -split '/' |
|
$expirationDate = Get-Date -Day $datearray[0] -Month $datearray[1] -Year $datearray[2] |
|
$totalDaysLeft = ($expirationDate - (get-date)).Totaldays.toString().split(",")[0] |
|
$totalDaysLeft = [int]$totalDaysLeft |
|
$objoutput = New-Object -TypeName PSObject -Property @{ |
|
ExpDate = $expirationDate.ToShortDateString() |
|
DaysRemain = $totalDaysLeft |
|
} |
|
} Catch{ |
|
$objoutput = New-Object -TypeName PSObject -Property @{ |
|
ExpDate = "Failed" |
|
DaysRemain = "Failed" |
|
} |
|
} |
|
$objoutput |
|
} |
|
|
|
Function Get-VeeamWinServers { |
|
$vservers=@{} |
|
$outputAry = @() |
|
$vservers.add($($script:vbrServerObj.Name),"VBRServer") |
|
Foreach ($srv in $script:proxyList) { |
|
If (!$vservers.ContainsKey($srv.Host.Name)) { |
|
$vservers.Add($srv.Host.Name,"ProxyServer") |
|
} |
|
} |
|
Foreach ($srv in $script:repoList) { |
|
If ($srv.Type -ne "LinuxLocal" -and !$vservers.ContainsKey($srv.gethost().Name)) { |
|
$vservers.Add($srv.gethost().Name,"RepoServer") |
|
} |
|
} |
|
Foreach ($rs in $script:repoListSo) { |
|
ForEach ($rp in $rs.Extent) { |
|
$r = $rp.Repository |
|
$rName = $($r.GetHost()).Name |
|
If ($r.Type -ne "LinuxLocal" -and !$vservers.ContainsKey($rName)) { |
|
$vservers.Add($rName,"RepoSoServer") |
|
} |
|
} |
|
} |
|
Foreach ($srv in $script:tapesrvList) { |
|
If (!$vservers.ContainsKey($srv.Name)) { |
|
$vservers.Add($srv.Name,"TapeServer") |
|
} |
|
} |
|
$vservers = $vservers.GetEnumerator() | Sort-Object Name |
|
Foreach ($vserver in $vservers) { |
|
$outputAry += $vserver.Name |
|
} |
|
return $outputAry |
|
} |
|
|
|
Function Get-VeeamServices { |
|
param ( |
|
[PSObject]$inputObj |
|
) |
|
$outputAry = @() |
|
Foreach ($obj in $InputObj) { |
|
$output = @() |
|
Try { |
|
$output = Get-Service -computername $obj -Name "*Veeam*" -exclude "SQLAgent*" | |
|
Select @{Name="Server Name"; Expression = {$obj.ToLower()}}, @{Name="Service Name"; Expression = {$_.DisplayName}}, Status |
|
} Catch { |
|
$output = New-Object PSObject -Property @{ |
|
"Server Name" = $obj.ToLower() |
|
"Service Name" = "Unable to connect" |
|
Status = "Unknown" |
|
} |
|
} |
|
$outputAry += $output |
|
} |
|
$outputAry |
|
} |
|
|
|
Function Get-VMsBackupStatus { |
|
$outputary = @() |
|
# Convert exclusion list to simple regular expression |
|
$excludevms_regex = ('(?i)^(' + (($script:excludeVMs | ForEach {[regex]::escape($_)}) -join "|") + ')$') -replace "\\\*", ".*" |
|
$excludefolder_regex = ('(?i)^(' + (($script:excludeFolder | ForEach {[regex]::escape($_)}) -join "|") + ')$') -replace "\\\*", ".*" |
|
$excludedc_regex = ('(?i)^(' + (($script:excludeDC | ForEach {[regex]::escape($_)}) -join "|") + ')$') -replace "\\\*", ".*" |
|
$vms=@{} |
|
# Build a hash table of all VMs. Key is either Job Object Id (for any VM ever in a Veeam job) or vCenter ID+MoRef |
|
# Assume unprotected (!), and populate Cluster, DataCenter, and Name fields for hash key value |
|
Find-VBRViEntity | |
|
Where-Object {$_.Type -eq "Vm" -and $_.VmFolderName -notmatch $excludefolder_regex} | |
|
Where-Object {$_.Name -notmatch $excludevms_regex} | |
|
Where-Object {$_.Path.Split("\")[1] -notmatch $excludedc_regex} | |
|
ForEach {$vms.Add(($_.FindObject().Id, $_.Id -ne $null)[0], @("!", $_.Path.Split("\")[0], $_.Path.Split("\")[1], $_.Path.Split("\")[2], $_.Name, "1/11/1911", "1/11/1911",""))} |
|
If (!$script:excludeTemp) { |
|
Find-VBRViEntity -VMsandTemplates | |
|
Where-Object {$_.Type -eq "Vm" -and $_.IsTemplate -eq "True" -and $_.VmFolderName -notmatch $excludefolder_regex} | |
|
Where-Object {$_.Name -notmatch $excludevms_regex} | |
|
Where-Object {$_.Path.Split("\")[1] -notmatch $excludedc_regex} | |
|
ForEach {$vms.Add(($_.FindObject().Id, $_.Id -ne $null)[0], @("!", $_.Path.Split("\")[0], $_.Path.Split("\")[1], $_.VmHostName, "[template] $($_.Name)", "1/11/1911", "1/11/1911",""))} |
|
} |
|
# Find all backup task sessions that have ended in the last x hours and not ending in Failure |
|
$vbrtasksessions = (Get-VBRBackupSession | |
|
Where-Object {($_.JobType -eq "Backup") -and ($_.EndTime -ge (Get-Date).addhours(-$script:HourstoCheck) -or $_.State -eq "Working")}) | |
|
Get-VBRTaskSession | Where-Object {$_.Status -notmatch "Failed|InProgress|Pending"} |
|
# Compare VM list to session list and update found VMs status |
|
If ($vbrtasksessions) { |
|
Foreach ($vmtask in $vbrtasksessions) { |
|
If($vms.ContainsKey($vmtask.Info.ObjectId)) { |
|
If ((Get-Date $vmtask.Progress.StartTime) -ge (Get-Date $vms[$vmtask.Info.ObjectId][5])) { |
|
If ($vmtask.Status -eq "Success") { |
|
$vms[$vmtask.Info.ObjectId][0]=$vmtask.Status |
|
$vms[$vmtask.Info.ObjectId][5]=$vmtask.Progress.StartTime |
|
$vms[$vmtask.Info.ObjectId][6]=$vmtask.Progress.StopTime |
|
$vms[$vmtask.Info.ObjectId][7]="" |
|
} ElseIf ($vms[$vmtask.Info.ObjectId][0] -ne "Success") { |
|
$vms[$vmtask.Info.ObjectId][0]=$vmtask.Status |
|
$vms[$vmtask.Info.ObjectId][5]=$vmtask.Progress.StartTime |
|
$vms[$vmtask.Info.ObjectId][6]=$vmtask.Progress.StopTime |
|
$vms[$vmtask.Info.ObjectId][7]=($vmtask.GetDetails()).Replace("<br />","$B$R$") |
|
} |
|
} ElseIf ($vms[$vmtask.Info.ObjectId][0] -eq "Warning" -and $vmtask.Status -eq "Success") { |
|
$vms[$vmtask.Info.ObjectId][0]=$vmtask.Status |
|
$vms[$vmtask.Info.ObjectId][5]=$vmtask.Progress.StartTime |
|
$vms[$vmtask.Info.ObjectId][6]=$vmtask.Progress.StopTime |
|
$vms[$vmtask.Info.ObjectId][7]="" |
|
} |
|
} |
|
} |
|
} |
|
Foreach ($vm in $vms.GetEnumerator()) { |
|
$objoutput = New-Object -TypeName PSObject -Property @{ |
|
Status = $vm.Value[0] |
|
Name = $vm.Value[4] |
|
vCenter = $vm.Value[1] |
|
Datacenter = $vm.Value[2] |
|
Cluster = $vm.Value[3] |
|
StartTime = $vm.Value[5] |
|
StopTime = $vm.Value[6] |
|
Details = $vm.Value[7] |
|
} |
|
$outputAry += $objoutput |
|
} |
|
$outputAry |
|
} |
|
|
|
function Get-Duration { |
|
param ($ts) |
|
$days = "" |
|
If ($ts.Days -gt 0) { |
|
$days = "{0}:" -f $ts.Days |
|
} |
|
"{0}{1}:{2,2:D2}:{3,2:D2}" -f $days,$ts.Hours,$ts.Minutes,$ts.Seconds |
|
} |
|
|
|
function Get-BackupSize { |
|
param ($backups) |
|
$outputObj = @() |
|
Foreach ($backup in $backups) { |
|
$backupSize = 0 |
|
$dataSize = 0 |
|
$files = $backup.GetAllStorages() |
|
Foreach ($file in $Files) { |
|
$backupSize += [math]::Round([long]$file.Stats.BackupSize/1GB, 2) |
|
$dataSize += [math]::Round([long]$file.Stats.DataSize/1GB, 2) |
|
} |
|
$repo = If ($($script:repoList | Where {$_.Id -eq $backup.RepositoryId}).Name) { |
|
$($script:repoList | Where {$_.Id -eq $backup.RepositoryId}).Name |
|
} Else { |
|
$($script:repoListSo | Where {$_.Id -eq $backup.RepositoryId}).Name |
|
} |
|
$vbrMasterHash = @{ |
|
JobName = $backup.JobName |
|
VMCount = $backup.VmCount |
|
Repo = $repo |
|
DataSize = $dataSize |
|
BackupSize = $backupSize |
|
} |
|
$vbrMasterObj = New-Object -TypeName PSObject -Property $vbrMasterHash |
|
$outputObj += $vbrMasterObj |
|
} |
|
$outputObj |
|
} |
|
#endregion |
|
|
|
#region Report |
|
# Get Veeam Version |
|
$VeeamVersion = Get-VeeamVersion |
|
|
|
If ($VeeamVersion -lt 9) { |
|
Write-Host "Script requires VBR v9" -ForegroundColor Red |
|
exit |
|
} |
|
|
|
# HTML Stuff |
|
$headerObj = @" |
|
<html> |
|
<head> |
|
<title>$rptTitle</title> |
|
<style> |
|
body {font-family: Tahoma; background-color:#fff;} |
|
table {font-family: Tahoma;width: $($rptWidth)px;font-size: 12px;border-collapse:collapse;} |
|
<!-- table tr:nth-child(odd) td {background: #e2e2e2;} --> |
|
th {background-color: #cccc99;border: 1px solid #a7a9ac;border-bottom: none;} |
|
td {background-color: #ffffff;border: 1px solid #a7a9ac;padding: 2px 3px 2px 3px;vertical-align: middle;text-align:center;} |
|
</style> |
|
</head> |
|
"@ |
|
|
|
$bodyTop = @" |
|
<body> |
|
<center> |
|
<table cellspacing="0" cellpadding="0"> |
|
<tr> |
|
<td style="width: 80%;height: 45px;border: none;background-color: #003366;color: White;font-size: 24px;vertical-align: bottom;text-align:left;padding: 0px 0px 0px 15px;">$rptTitle</td> |
|
<td style="width: 20%;height: 45px;border: none;background-color: #003366;color: White;font-size: 12px;vertical-align:text-top;text-align:right;padding: 2px 3px 2px 3px;">MVR v$MVRversion</td> |
|
</tr> |
|
<tr> |
|
<td style="width: 80%;height: 35px;border: none;background-color: #003366;color: White;font-size: 10px;vertical-align: bottom;text-align:left;padding: 0px 0px 2px 3px;">Report generated at $(Get-Date -format g) on $((gc env:computername).ToLower())</td> |
|
<td style="width: 20%;height: 35px;border: none;background-color: #003366;color: White;font-size: 10px;vertical-align:bottom;text-align:right;padding: 2px 3px 2px 3px;">Veeam v$VeeamVersion</td> |
|
</tr> |
|
</table> |
|
"@ |
|
|
|
$subHead01 = @" |
|
<table> |
|
<tr> |
|
<td style="height: 35px;background-color: #eeeeee;color: #003366;font-size: 16px;font-weight: bold;vertical-align: middle;padding: 5px 0 0 15px;border-top: 1px solid #cccc99;border-bottom: none;text-align:left;"> |
|
"@ |
|
|
|
$subHead01err = @" |
|
<table> |
|
<tr> |
|
<td style="height: 35px;background-color: #FF0000;color: #003366;font-size: 16px;font-weight: bold;vertical-align: middle;padding: 5px 0 0 15px;border-top: 1px solid #cccc99;border-bottom: none;text-align:left;"> |
|
"@ |
|
|
|
$subHead02 = @" |
|
</td> |
|
</tr> |
|
</table> |
|
"@ |
|
|
|
$footerObj = @" |
|
<table cellspacing="0" cellpadding="0"> |
|
<tr> |
|
<td style="height: 15px;border: none;background-color: #ffffff;color: #003366;font-size: 10px;">My Veeam Report maintained by http://blog.smasterson.com</td> |
|
</tr> |
|
</table> |
|
</center> |
|
</body> |
|
</html> |
|
"@ |
|
|
|
#Get VM Backup Status |
|
$vmStatus = @() |
|
If ($showSummaryProtect + $showUnprotectedVMs + $showProtectedVMs) { |
|
$vmStatus = Get-VMsBackupStatus |
|
} |
|
# VMs Missing Backups |
|
$missingVMs = @($vmStatus | ?{$_.Status -eq "!"}) |
|
# VMs Successfuly Backed Up |
|
$successVMs = @($vmStatus | ?{$_.Status -eq "Success"}) |
|
# VMs Backed Up w/Warning |
|
$warnVMs = @($vmStatus | ?{$_.Status -eq "Warning"}) |
|
|
|
# Get VM Backup Protection Summary |
|
$bodySummaryProtect = $null |
|
If ($showSummaryProtect) { |
|
If (@($missingVMs).Count -ge 1) { |
|
$percentProt = (@($warnVMs).Count + @($successVMs).Count) / (@($warnVMs).Count + @($successVMs).Count + @($missingVMs).Count) |
|
} Else { |
|
$percentProt = 1 |
|
} |
|
If (@($warnVMs).Count -ge 1) { |
|
$percentWarn = "*" |
|
} Else { |
|
$percentWarn = "" |
|
} |
|
$vbrMasterHash = @{ |
|
WarningVM = @($warnVMs).Count |
|
ProtectedVM = @($successVMs).Count |
|
FailedVM = @($missingVMs).Count |
|
PercentProt = "{0:P0}{1}" -f $percentProt,$percentWarn |
|
|
|
} |
|
$vbrMasterObj = New-Object -TypeName PSObject -Property $vbrMasterHash |
|
$bodySummaryProtect = $vbrMasterObj | Select @{Name="% Protected"; Expression = {$_.PercentProt}}, |
|
@{Name="Fully Protected VMs"; Expression = {$_.ProtectedVM}}, |
|
@{Name="Protected VMs w/Only Warnings"; Expression = {$_.WarningVM}}, |
|
@{Name="Unprotected VMs"; Expression = {$_.FailedVM}} | ConvertTo-HTML -Fragment |
|
$bodySummaryProtect = $subHead01 + "VM Backup Protection Summary" + $subHead02 + $bodySummaryProtect |
|
} |
|
|
|
# Get VMs Missing Backups |
|
$bodyMissing = $null |
|
If ($showUnprotectedVMs) { |
|
If ($missingVMs -ne $null) { |
|
$missingVMs = $missingVMs | Sort vCenter, Datacenter, Cluster, Name | Select Name, vCenter, Datacenter, Cluster | ConvertTo-HTML -Fragment |
|
$bodyMissing = $subHead01err + "VMs with No Successful Backups within RPO" + $subHead02 + $missingVMs |
|
} |
|
} |
|
|
|
# Get VMs Successfuly Backed Up |
|
$bodySuccess = $null |
|
If ($showProtectedVMs) { |
|
If ($successVMs -ne $null) { |
|
$successVMs = $successVMs | Sort vCenter, Datacenter, Cluster, Name | Select Name, vCenter, Datacenter, Cluster, |
|
@{Name="Last Start Time"; Expression = {$_.StartTime}}, @{Name="Last End Time"; Expression = {$_.StopTime}} | ConvertTo-HTML -Fragment |
|
$bodySuccess = $subHead01 + "VMs with Successful Backups within RPO" + $subHead02 + $successVMs |
|
} |
|
} |
|
|
|
# Get VMs Backed Up w/Warnings |
|
$bodyWarning = $null |
|
If ($showProtectedVMs) { |
|
If ($warnVMs -ne $null) { |
|
$warnVMs = $warnVMs | Sort vCenter, Datacenter, Cluster, Name | Select Name, vCenter, Datacenter, Cluster, |
|
@{Name="Last Start Time"; Expression = {$_.StartTime}}, @{Name="Last End Time"; Expression = {$_.StopTime}}, Details | ConvertTo-HTML -Fragment |
|
$bodyWarning = $subHead01 + "VMs with only Backups with Warnings within RPO" + $subHead02 + $warnVMs |
|
} |
|
} |
|
|
|
# Get Backup Summary Info |
|
$bodySummaryBk = $null |
|
If ($showSummaryBk) { |
|
$vbrMasterHash = @{ |
|
"Failed" = @($failedSessionsBk).Count |
|
"Sessions" = If ($sessListBk) {@($sessListBk).Count} Else {0} |
|
"Read" = $totalReadBk |
|
"Transferred" = $totalXferBk |
|
"Successful" = @($successSessionsBk).Count |
|
"Warning" = @($warningSessionsBk).Count |
|
"Fails" = @($failsSessionsBk).Count |
|
"Running" = @($runningSessionsBk).Count |
|
} |
|
$vbrMasterObj = New-Object -TypeName PSObject -Property $vbrMasterHash |
|
If ($onlyLastBk) { |
|
$total = "Jobs Run" |
|
} Else { |
|
$total = "Total Sessions" |
|
} |
|
$bodySummaryBk = $vbrMasterObj | Select @{Name=$total; Expression = {$_.Sessions}}, |
|
@{Name="Read (GB)"; Expression = {$_.Read}}, @{Name="Transferred (GB)"; Expression = {$_.Transferred}}, |
|
@{Name="Running"; Expression = {$_.Running}}, @{Name="Successful"; Expression = {$_.Successful}}, |
|
@{Name="Warnings"; Expression = {$_.Warning}}, @{Name="Failures"; Expression = {$_.Fails}}, |
|
@{Name="Failed"; Expression = {$_.Failed}} | ConvertTo-HTML -Fragment |
|
$bodySummaryBk = $subHead01 + "Backup Results Summary" + $subHead02 + $bodySummaryBk |
|
} |
|
|
|
# Get Backup Job Status |
|
$bodyJobsBk = @() |
|
If ($showJobsBk) { |
|
If ($allJobsBk.count -gt 0) { |
|
Foreach($bkJob in $allJobsBk) { |
|
$bodyJobsBk += $bkJob | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Enabled"; Expression = {$_.IsScheduleEnabled}}, |
|
@{Name="Status"; Expression = { |
|
If ($bkJob.IsRunning) { |
|
$currentSess = $runningSessionsBk | ?{$_.JobName -eq $bkJob.Name} |
|
$csessPercent = $currentSess.Progress.Percents |
|
$csessSpeed = [Math]::Round($currentSess.Progress.AvgSpeed/1MB,2) |
|
$cStatus = "$($csessPercent)% completed at $($csessSpeed) MB/s" |
|
$cStatus |
|
} Else { |
|
"Stopped" |
|
} |
|
}}, |
|
@{Name="Target Repo"; Expression = { |
|
If ($($repoList | Where {$_.Id -eq $BkJob.Info.TargetRepositoryId}).Name) { |
|
$($repoList | Where {$_.Id -eq $BkJob.Info.TargetRepositoryId}).Name |
|
} Else { |
|
$($repoListSo | Where {$_.Id -eq $BkJob.Info.TargetRepositoryId}).Name |
|
} |
|
}}, |
|
@{Name="Next Run"; Expression = { |
|
If ($_.IsScheduleEnabled -eq $false) {"<Disabled>"} |
|
ElseIf ($_.Options.JobOptions.RunManually) {"<not scheduled>"} |
|
ElseIf ($_.ScheduleOptions.IsContinious) {"<Continious>"} |
|
ElseIf ($_.ScheduleOptions.OptionsScheduleAfterJob.IsEnabled) {"After [" + $(($allJobs + $allJobsTp) | Where {$_.Id -eq $bkJob.Info.ParentScheduleId}).Name + "]"} |
|
Else {$_.ScheduleOptions.NextRun} |
|
}}, |
|
@{Name="Last Result"; Expression = {If ($_.Info.LatestStatus -eq "None"){"Unknown"}Else{$_.Info.LatestStatus}}} |
|
} |
|
$bodyJobsBk = $bodyJobsBk | Sort "Next Run" | ConvertTo-HTML -Fragment |
|
$bodyJobsBk = $subHead01 + "Backup Job Status" + $subHead02 + $bodyJobsBk |
|
} |
|
} |
|
|
|
# Get Backup Job Size |
|
$bodyJobSizeBk = $null |
|
If ($showBackupSizeBk) { |
|
If ($backupsBk.count -gt 0) { |
|
$bodyJobSizeBk = Get-BackupSize -backups $backupsBk | Sort JobName | Select @{Name="Job Name"; Expression = {$_.JobName}}, |
|
@{Name="VM Count"; Expression = {$_.VMCount}}, |
|
@{Name="Repository"; Expression = {$_.Repo}}, |
|
@{Name="Data Size (GB)"; Expression = {$_.DataSize}}, |
|
@{Name="Backup Size (GB)"; Expression = {$_.BackupSize}} | ConvertTo-HTML -Fragment |
|
$bodyJobSizeBk = $subHead01 + "Backup Job Size" + $subHead02 + $bodyJobSizeBk |
|
} |
|
} |
|
|
|
# Get all Backup Sessions |
|
$bodyAllSessBk = $null |
|
If ($showAllSessBk) { |
|
If ($sessListBk.count -gt 0) { |
|
If ($showDetailedBk) { |
|
$bodyAllSessBk = $sessListBk | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="State"; Expression = {$_.State}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.EndTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.EndTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodyAllSessBk = $subHead01 + "Backup Sessions" + $subHead02 + $bodyAllSessBk |
|
} Else { |
|
$bodyAllSessBk = $sessListBk | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="State"; Expression = {$_.State}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.EndTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.EndTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodyAllSessBk = $subHead01 + "Backup Sessions" + $subHead02 + $bodyAllSessBk |
|
} |
|
} |
|
} |
|
|
|
# Get Running Backup Jobs |
|
$bodyRunningBk = $null |
|
If ($showRunningBk) { |
|
If ($runningSessionsBk.count -gt 0) { |
|
$bodyRunningBk = $runningSessionsBk | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Read (GB)"; Expression = {[Math]::Round([Decimal]$_.Progress.ReadSize/1GB, 2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round([Decimal]$_.Progress.TransferedSize/1GB, 2)}}, |
|
@{Name="% Complete"; Expression = {$_.Progress.Percents}} | ConvertTo-HTML -Fragment |
|
$bodyRunningBk = $subHead01 + "Running Backup Jobs" + $subHead02 + $bodyRunningBk |
|
} |
|
} |
|
|
|
# Get Backup Sessions with Warnings or Failures |
|
$bodySessWFBk = $null |
|
If ($showWarnFailBk) { |
|
$sessWF = @($warningSessionsBk + $failsSessionsBk) |
|
If ($sessWF.count -gt 0) { |
|
If ($onlyLastBk) { |
|
$headerWF = "Backup Jobs with Warnings or Failures" |
|
} Else { |
|
$headerWF = "Backup Sessions with Warnings or Failures" |
|
} |
|
If ($showDetailedBk) { |
|
$bodySessWFBk = $sessWF | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
@{Name="Details"; Expression = { |
|
If ($_.GetDetails() -eq ""){$_ | Get-VBRTaskSession | %{If ($_.GetDetails()){$_.Name + ": " + ($_.GetDetails()).Replace("<br />","$B$R$")}}} |
|
Else {($_.GetDetails()).Replace("<br />","$B$R$")}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessWFBk = $subHead01 + $headerWF + $subHead02 + $bodySessWFBk |
|
} Else { |
|
$bodySessWFBk = $sessWF | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = { |
|
If ($_.GetDetails() -eq ""){$_ | Get-VBRTaskSession | %{If ($_.GetDetails()){$_.Name + ": " + ($_.GetDetails()).Replace("<br />","$B$R$")}}} |
|
Else {($_.GetDetails()).Replace("<br />","$B$R$")}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessWFBk = $subHead01 + $headerWF + $subHead02 + $bodySessWFBk |
|
} |
|
} |
|
} |
|
|
|
# Get Successful Backup Sessions |
|
$bodySessSuccBk = $null |
|
If ($showSuccessBk) { |
|
If ($successSessionsBk.count -gt 0) { |
|
If ($onlyLastBk) { |
|
$headerSucc = "Successful Backup Jobs" |
|
} Else { |
|
$headerSucc = "Successful Backup Sessions" |
|
} |
|
If ($showDetailedBk) { |
|
$bodySessSuccBk = $successSessionsBk | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessSuccBk = $subHead01 + $headerSucc + $subHead02 + $bodySessSuccBk |
|
} Else { |
|
$bodySessSuccBk = $successSessionsBk | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessSuccBk = $subHead01 + $headerSucc + $subHead02 + $bodySessSuccBk |
|
} |
|
} |
|
} |
|
|
|
## Gathering tasks after session info has been recorded due to Veeam issue |
|
# Gather all Backup Tasks from Sessions within time frame |
|
$taskListBk = @() |
|
$taskListBk += $sessListBk | Get-VBRTaskSession |
|
$successTasksBk = @($taskListBk | ?{$_.Status -eq "Success"}) |
|
$wfTasksBk = @($taskListBk | ?{$_.Status -match "Warning|Failed"}) |
|
$runningTasksBk = @() |
|
$runningTasksBk += $runningSessionsBk | Get-VBRTaskSession | ?{$_.Status -match "Pending|InProgress"} |
|
|
|
# Get all Backup Tasks |
|
$bodyAllTasksBk = $null |
|
If ($showAllTasksBk) { |
|
If ($taskListBk.count -gt 0) { |
|
If ($showDetailedBk) { |
|
$bodyAllTasksBk = $taskListBk | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.Progress.StopTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.Progress.StopTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyAllTasksBk = $subHead01 + "Backup Tasks" + $subHead02 + $bodyAllTasksBk |
|
} Else { |
|
$bodyAllTasksBk = $taskListBk | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.Progress.StopTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.Progress.StopTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyAllTasksBk = $subHead01 + "Backup Tasks" + $subHead02 + $bodyAllTasksBk |
|
} |
|
} |
|
} |
|
|
|
# Get Running Backup Tasks |
|
$bodyTasksRunningBk = $null |
|
If ($showRunningTasksBk) { |
|
If ($runningTasksBk.count -gt 0) { |
|
$bodyTasksRunningBk = $runningTasksBk | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Info.Progress.StartTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTasksRunningBk = $subHead01 + "Running Backup Tasks" + $subHead02 + $bodyTasksRunningBk |
|
} |
|
} |
|
|
|
# Get Backup Tasks with Warnings or Failures |
|
$bodyTaskWFBk = $null |
|
If ($showTaskWFBk) { |
|
If ($wfTasksBk.count -gt 0) { |
|
If ($showDetailedBk) { |
|
$bodyTaskWFBk = $wfTasksBk | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskWFBk = $subHead01 + "Backup Tasks with Warnings or Failures" + $subHead02 + $bodyTaskWFBk |
|
} Else { |
|
$bodyTaskWFBk = $wfTasksBk | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskWFBk = $subHead01 + "Backup Tasks with Warnings or Failures" + $subHead02 + $bodyTaskWFBk |
|
} |
|
} |
|
} |
|
|
|
# Get Successful Backup Tasks |
|
$bodyTaskSuccBk = $null |
|
If ($showTaskSuccessBk) { |
|
If ($successTasksBk.count -gt 0) { |
|
If ($showDetailedBk) { |
|
$bodyTaskSuccBk = $successTasksBk | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskSuccBk = $subHead01 + "Successful Backup Tasks" + $subHead02 + $bodyTaskSuccBk |
|
} Else { |
|
$bodyTaskSuccBk = $successTasksBk | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskSuccBk = $subHead01 + "Successful Backup Tasks" + $subHead02 + $bodyTaskSuccBk |
|
} |
|
} |
|
} |
|
|
|
# Get Running VM Restore Sessions |
|
$bodyRestoRunVM = $null |
|
If ($showRestoRunVM) { |
|
If ($($runningResto).count -gt 0) { |
|
$bodyRestoRunVM = $runningResto | Sort CreationTime | Select @{Name="VM Name"; Expression = {$_.Info.VmDisplayName}}, |
|
@{Name="Restore Type"; Expression = {$_.JobTypeString}}, @{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Initiator"; Expression = {$_.Info.Initiator.Name}}, |
|
@{Name="Reason"; Expression = {$_.Info.Reason}} | ConvertTo-HTML -Fragment |
|
$bodyRestoRunVM = $subHead01 + "Running VM Restore Sessions" + $subHead02 + $bodyRestoRunVM |
|
} |
|
} |
|
|
|
# Get Completed VM Restore Sessions |
|
$bodyRestoreVM = $null |
|
If ($showRestoreVM) { |
|
If ($($completeResto).count -gt 0) { |
|
$bodyRestoreVM = $completeResto | Sort CreationTime | Select @{Name="VM Name"; Expression = {$_.Info.VmDisplayName}}, |
|
@{Name="Restore Type"; Expression = {$_.JobTypeString}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, @{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $(New-TimeSpan $_.CreationTime $_.EndTime)}}, |
|
@{Name="Initiator"; Expression = {$_.Info.Initiator.Name}}, @{Name="Reason"; Expression = {$_.Info.Reason}}, |
|
@{Name="Result"; Expression = {$_.Info.Result}} | ConvertTo-HTML -Fragment |
|
$bodyRestoreVM = $subHead01 + "Completed VM Restore Sessions" + $subHead02 + $bodyRestoreVM |
|
} |
|
} |
|
|
|
# Get Replication Summary Info |
|
$bodySummaryRp = $null |
|
If ($showSummaryRp) { |
|
$vbrMasterHash = @{ |
|
"Failed" = @($failedSessionsRp).Count |
|
"Sessions" = If ($sessListRp) {@($sessListRp).Count} Else {0} |
|
"Read" = $totalReadRp |
|
"Transferred" = $totalXferRp |
|
"Successful" = @($successSessionsRp).Count |
|
"Warning" = @($warningSessionsRp).Count |
|
"Fails" = @($failsSessionsRp).Count |
|
"Running" = @($runningSessionsRp).Count |
|
} |
|
$vbrMasterObj = New-Object -TypeName PSObject -Property $vbrMasterHash |
|
If ($onlyLastRp) { |
|
$total = "Jobs Run" |
|
} Else { |
|
$total = "Total Sessions" |
|
} |
|
$bodySummaryRp = $vbrMasterObj | Select @{Name=$total; Expression = {$_.Sessions}}, |
|
@{Name="Read (GB)"; Expression = {$_.Read}}, @{Name="Transferred (GB)"; Expression = {$_.Transferred}}, |
|
@{Name="Running"; Expression = {$_.Running}}, @{Name="Successful"; Expression = {$_.Successful}}, |
|
@{Name="Warnings"; Expression = {$_.Warning}}, |
|
@{Name="Failed"; Expression = {$_.Failed}} | ConvertTo-HTML -Fragment |
|
$bodySummaryRp = $subHead01 + "Replication Results Summary" + $subHead02 + $bodySummaryRp |
|
} |
|
|
|
# Get Replication Job Status |
|
$bodyJobsRp = @() |
|
If ($showJobsRp) { |
|
If ($allJobsRp.count -gt 0) { |
|
Foreach($rpJob in $allJobsRp) { |
|
$bodyJobsRp += $rpJob | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Enabled"; Expression = {$_.Info.IsScheduleEnabled}}, |
|
@{Name="Status"; Expression = { |
|
If ($rpJob.IsRunning) { |
|
$currentSess = $runningSessionsRp | ?{$_.JobName -eq $rpJob.Name} |
|
$csessPercent = $currentSess.Progress.Percents |
|
$csessSpeed = [Math]::Round($currentSess.Info.Progress.AvgSpeed/1MB,2) |
|
$cStatus = "$($csessPercent)% completed at $($csessSpeed) MB/s" |
|
$cStatus |
|
} Else { |
|
"Stopped" |
|
} |
|
}}, |
|
@{Name="Target"; Expression = {$(Get-VBRServer | Where {$_.Id -eq $rpJob.Info.TargetHostId}).Name}}, |
|
@{Name="Target Repo"; Expression = { |
|
If ($($repoList | Where {$_.Id -eq $rpJob.Info.TargetRepositoryId}).Name) {$($repoList | Where {$_.Id -eq $rpJob.Info.TargetRepositoryId}).Name} |
|
Else {$($repoListSo | Where {$_.Id -eq $rpJob.Info.TargetRepositoryId}).Name}}}, |
|
@{Name="Next Run"; Expression = { |
|
If ($_.IsScheduleEnabled -eq $false) {"<Disabled>"} |
|
ElseIf ($_.Options.JobOptions.RunManually) {"<not scheduled>"} |
|
ElseIf ($_.ScheduleOptions.IsContinious) {"<Continious>"} |
|
ElseIf ($_.ScheduleOptions.OptionsScheduleAfterJob.IsEnabled) {"After [" + $(($allJobs + $allJobsTp) | Where {$_.Id -eq $rpJob.Info.ParentScheduleId}).Name + "]"} |
|
Else {$_.ScheduleOptions.NextRun}}}, |
|
@{Name="Last Result"; Expression = {If ($_.Info.LatestStatus -eq "None"){""}Else{$_.Info.LatestStatus}}} |
|
} |
|
$bodyJobsRp = $bodyJobsRp | Sort "Next Run" | ConvertTo-HTML -Fragment |
|
$bodyJobsRp = $subHead01 + "Replication Job Status" + $subHead02 + $bodyJobsRp |
|
} |
|
} |
|
|
|
# Get Replication Sessions |
|
$bodyAllSessRp = $null |
|
If ($showAllSessRp) { |
|
If ($sessListRp.count -gt 0) { |
|
If ($showDetailedRp) { |
|
$bodyAllSessRp = $sessListRp | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="State"; Expression = {$_.State}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.EndTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.EndTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Info.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Info.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodyAllSessRp = $subHead01 + "Replication Sessions" + $subHead02 + $bodyAllSessRp |
|
} Else { |
|
$bodySessWFRp = $sessListRp | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="State"; Expression = {$_.State}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.EndTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.EndTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodyAllSessRp = $subHead01 + "Replication Sessions" + $subHead02 + $bodyAllSessRp |
|
} |
|
} |
|
} |
|
|
|
# Get Running Replication Jobs |
|
$bodyRunningRp = $null |
|
If ($showRunningRp) { |
|
If ($runningSessionsRp.count -gt 0) { |
|
$bodyRunningRp = $runningSessionsRp | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Read (GB)"; Expression = {[Math]::Round([Decimal]$_.Progress.ReadSize/1GB, 2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round([Decimal]$_.Progress.TransferedSize/1GB, 2)}}, |
|
@{Name="% Complete"; Expression = {$_.Progress.Percents}} | ConvertTo-HTML -Fragment |
|
$bodyRunningRp = $subHead01 + "Running Replication Jobs" + $subHead02 + $bodyRunningRp |
|
} |
|
} |
|
|
|
# Get Replication Sessions with Warnings or Failures |
|
$bodySessWFRp = $null |
|
If ($showWarnFailRp) { |
|
$sessWF = @($warningSessionsRp + $failsSessionsRp) |
|
If ($sessWF.count -gt 0) { |
|
If ($onlyLastRp) { |
|
$headerWF = "Replication Jobs with Warnings or Failures" |
|
} Else { |
|
$headerWF = "Replication Sessions with Warnings or Failures" |
|
} |
|
If ($showDetailedRp) { |
|
$bodySessWFRp = $sessWF | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Info.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Info.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
@{Name="Details"; Expression = { |
|
If ($_.GetDetails() -eq ""){$_ | Get-VBRTaskSession | %{If ($_.GetDetails()){$_.Name + ": " + ($_.GetDetails()).Replace("<br />","$B$R$")}}} |
|
Else {($_.GetDetails()).Replace("<br />","$B$R$")}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessWFRp = $subHead01 + $headerWF + $subHead02 + $bodySessWFRp |
|
} Else { |
|
$bodySessWFRp = $sessWF | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = { |
|
If ($_.GetDetails() -eq ""){$_ | Get-VBRTaskSession | %{If ($_.GetDetails()){$_.Name + ": " + ($_.GetDetails()).Replace("<br />","$B$R$")}}} |
|
Else {($_.GetDetails()).Replace("<br />","$B$R$")}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessWFRp = $subHead01 + $headerWF + $subHead02 + $bodySessWFRp |
|
} |
|
} |
|
} |
|
|
|
# Get Successful Replication Sessions |
|
$bodySessSuccRp = $null |
|
If ($showSuccessRp) { |
|
If ($successSessionsRp.count -gt 0) { |
|
If ($onlyLastRp) { |
|
$headerSucc = "Successful Replication Jobs" |
|
} Else { |
|
$headerSucc = "Successful Replication Sessions" |
|
} |
|
If ($showDetailedRp) { |
|
$bodySessSuccRp = $successSessionsRp | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Info.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Info.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessSuccRp = $subHead01 + $headerSucc + $subHead02 + $bodySessSuccRp |
|
} Else { |
|
$bodySessSuccRp = $successSessionsRp | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessSuccRp = $subHead01 + $headerSucc + $subHead02 + $bodySessSuccRp |
|
} |
|
} |
|
} |
|
|
|
## Gathering tasks after session info has been recorded due to Veeam issue |
|
# Gather all Replication Tasks from Sessions within time frame |
|
$taskListRp = @() |
|
$taskListRp += $sessListRp | Get-VBRTaskSession |
|
$successTasksRp = @($taskListRp | ?{$_.Status -eq "Success"}) |
|
$wfTasksRp = @($taskListRp | ?{$_.Status -match "Warning|Failed"}) |
|
$runningTasksRp = @() |
|
$runningTasksRp += $runningSessionsRp | Get-VBRTaskSession | ?{$_.Status -match "Pending|InProgress"} |
|
|
|
# Get Replication Tasks |
|
$bodyAllTasksRp = $null |
|
If ($showAllTasksRp) { |
|
If ($taskListRp.count -gt 0) { |
|
If ($showDetailedRp) { |
|
$bodyAllTasksRp = $taskListRp | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.Progress.StopTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.Progress.StopTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyAllTasksRp = $subHead01 + "Replication Tasks" + $subHead02 + $bodyAllTasksRp |
|
} Else { |
|
$bodyAllTasksRp = $taskListRp | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.Progress.StopTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.Progress.StopTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyAllTasksRp = $subHead01 + "Replication Tasks" + $subHead02 + $bodyAllTasksRp |
|
} |
|
} |
|
} |
|
|
|
# Get Running Replication Tasks |
|
$bodyTasksRunningRp = $null |
|
If ($showRunningTasksRp) { |
|
If ($runningTasksRp.count -gt 0) { |
|
$bodyTasksRunningRp = $runningTasksRp | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Info.Progress.StartTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTasksRunningRp = $subHead01 + "Running Replication Tasks" + $subHead02 + $bodyTasksRunningRp |
|
} |
|
} |
|
|
|
# Get Replication Tasks with Warnings or Failures |
|
$bodyTaskWFRp = $null |
|
If ($showTaskWFRp) { |
|
If ($wfTasksRp.count -gt 0) { |
|
If ($showDetailedRp) { |
|
$bodyTaskWFRp = $wfTasksRp | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskWFRp = $subHead01 + "Replication Tasks with Warnings or Failures" + $subHead02 + $bodyTaskWFRp |
|
} Else { |
|
$bodyTaskWFRp = $wfTasksRp | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskWFRp = $subHead01 + "Replication Tasks with Warnings or Failures" + $subHead02 + $bodyTaskWFRp |
|
} |
|
} |
|
} |
|
|
|
# Get Successful Replication Tasks |
|
$bodyTaskSuccRp = $null |
|
If ($showTaskSuccessRp) { |
|
If ($successTasksRp.count -gt 0) { |
|
If ($showDetailedRp) { |
|
$bodyTaskSuccRp = $successTasksRp | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Progress.TransferedSize/1GB,2)}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskSuccRp = $subHead01 + "Successful Replication Tasks" + $subHead02 + $bodyTaskSuccRp |
|
} Else { |
|
$bodyTaskSuccRp = $successTasksRp | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {$_.Progress.StopTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
Status | Sort "Start Time" | ConvertTo-HTML -Fragment |
|
$bodyTaskSuccRp = $subHead01 + "Successful Replication Tasks" + $subHead02 + $bodyTaskSuccRp |
|
} |
|
} |
|
} |
|
|
|
# Get Backup Copy Summary Info |
|
$bodySummaryBc = $null |
|
If ($showSummaryBc) { |
|
$vbrMasterHash = @{ |
|
"Sessions" = If ($sessListBc) {@($sessListBc).Count} Else {0} |
|
"Read" = $totalReadBc |
|
"Transferred" = $totalXferBc |
|
"Successful" = @($successSessionsBc).Count |
|
"Warning" = @($warningSessionsBc).Count |
|
"Fails" = @($failsSessionsBc).Count |
|
"Working" = @($workingSessionsBc).Count |
|
"Idle" = @($idleSessionsBc).Count |
|
} |
|
$vbrMasterObj = New-Object -TypeName PSObject -Property $vbrMasterHash |
|
If ($onlyLastBc) { |
|
$total = "Jobs Run" |
|
} Else { |
|
$total = "Total Sessions" |
|
} |
|
$bodySummaryBc = $vbrMasterObj | Select @{Name=$total; Expression = {$_.Sessions}}, |
|
@{Name="Read (GB)"; Expression = {$_.Read}}, @{Name="Transferred (GB)"; Expression = {$_.Transferred}}, |
|
@{Name="Idle"; Expression = {$_.Idle}}, |
|
@{Name="Working"; Expression = {$_.Working}}, @{Name="Successful"; Expression = {$_.Successful}}, |
|
@{Name="Warnings"; Expression = {$_.Warning}}, @{Name="Failures"; Expression = {$_.Fails}} | ConvertTo-HTML -Fragment |
|
$bodySummaryBc = $subHead01 + "Backup Copy Results Summary" + $subHead02 + $bodySummaryBc |
|
} |
|
|
|
# Get Backup Copy Job Status |
|
$bodyJobsBc = @() |
|
If ($showJobsBc) { |
|
If ($allJobsBc.count -gt 0) { |
|
Foreach($BcJob in $allJobsBc) { |
|
$bodyJobsBc += $BcJob | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Enabled"; Expression = {$_.Info.IsScheduleEnabled}}, |
|
@{Name="Type"; Expression = {$_.TypeToString}}, |
|
@{Name="Status"; Expression = { |
|
If ($BcJob.IsRunning) { |
|
$currentSess = $BcJob.FindLastSession() |
|
If ($currentSess.State -eq "Working") { |
|
$csessPercent = $currentSess.Progress.Percents |
|
$csessSpeed = [Math]::Round($currentSess.Progress.AvgSpeed/1MB,2) |
|
$cStatus = "$($csessPercent)% completed at $($csessSpeed) MB/s" |
|
$cStatus |
|
} Else { |
|
$currentSess.State |
|
} |
|
} Else { |
|
"Stopped" |
|
} |
|
}}, |
|
@{Name="Target Repo"; Expression = { |
|
If ($($repoList | Where {$_.Id -eq $BcJob.Info.TargetRepositoryId}).Name) {$($repoList | Where {$_.Id -eq $BcJob.Info.TargetRepositoryId}).Name} |
|
Else {$($repoListSo | Where {$_.Id -eq $BcJob.Info.TargetRepositoryId}).Name}}}, |
|
@{Name="Next Run"; Expression = { |
|
If ($_.IsScheduleEnabled -eq $false) {"<Disabled>"} |
|
ElseIf ($_.Options.JobOptions.RunManually) {"<not scheduled>"} |
|
ElseIf ($_.ScheduleOptions.IsContinious) {"<Continious>"} |
|
ElseIf ($_.ScheduleOptions.OptionsScheduleAfterJob.IsEnabled) {"After [" + $(($allJobs + $allJobsTp) | Where {$_.Id -eq $BcJob.Info.ParentScheduleId}).Name + "]"} |
|
Else {$_.ScheduleOptions.NextRun}}}, |
|
@{Name="Last Result"; Expression = {If ($_.Info.LatestStatus -eq "None"){""}Else{$_.Info.LatestStatus}}} |
|
} |
|
$bodyJobsBc = $bodyJobsBc | Sort "Next Run", "Job Name" | ConvertTo-HTML -Fragment |
|
$bodyJobsBc = $subHead01 + "Backup Copy Job Status" + $subHead02 + $bodyJobsBc |
|
} |
|
} |
|
|
|
# Get Backup Copy Job Size |
|
$bodyJobSizeBc = $null |
|
If ($showBackupSizeBc) { |
|
If ($backupsBc.count -gt 0) { |
|
$bodyJobSizeBc = Get-BackupSize -backups $backupsBc | Sort JobName | Select @{Name="Job Name"; Expression = {$_.JobName}}, |
|
@{Name="VM Count"; Expression = {$_.VMCount}}, |
|
@{Name="Repository"; Expression = {$_.Repo}}, |
|
@{Name="Data Size (GB)"; Expression = {$_.DataSize}}, |
|
@{Name="Backup Size (GB)"; Expression = {$_.BackupSize}} | ConvertTo-HTML -Fragment |
|
$bodyJobSizeBc = $subHead01 + "Backup Copy Job Size" + $subHead02 + $bodyJobSizeBc |
|
} |
|
} |
|
|
|
# Get All Backup Copy Sessions |
|
$bodyAllSessBc = $null |
|
If ($showAllSessBc) { |
|
If ($sessListBc.count -gt 0) { |
|
If ($showDetailedBc) { |
|
$bodyAllSessBc = $sessListBc | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="State"; Expression = {$_.State}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.EndTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.EndTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Info.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Info.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodyAllSessBc = $subHead01 + "Backup Copy Sessions" + $subHead02 + $bodyAllSessBc |
|
} Else { |
|
$bodyAllSessBc = $sessListBc | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="State"; Expression = {$_.State}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.EndTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.EndTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = {($_.GetDetails()).Replace("<br />","$B$R$")}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodyAllSessBc = $subHead01 + "Backup Copy Sessions" + $subHead02 + $bodyAllSessBc |
|
} |
|
} |
|
} |
|
|
|
# Get Idle Backup Copy Sessions |
|
$bodySessIdleBc = $null |
|
If ($showIdleBc) { |
|
If ($idleSessionsBc.count -gt 0) { |
|
If ($onlyLastBc) { |
|
$headerIdle = "Idle Backup Copy Jobs" |
|
} Else { |
|
$headerIdle = "Idle Backup Copy Sessions" |
|
} |
|
If ($showDetailedBc) { |
|
$bodySessIdleBc = $idleSessionsBc | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $(New-TimeSpan $_.CreationTime $(Get-Date))}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Info.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Info.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}} | ConvertTo-HTML -Fragment |
|
$bodySessIdleBc = $subHead01 + $headerIdle + $subHead02 + $bodySessIdleBc |
|
} Else { |
|
$bodySessIdleBc = $idleSessionsBc | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $(New-TimeSpan $_.CreationTime $(Get-Date))}} | ConvertTo-HTML -Fragment |
|
$bodySessIdleBc = $subHead01 + $headerIdle + $subHead02 + $bodySessIdleBc |
|
} |
|
} |
|
} |
|
|
|
# Get Working Backup Copy Jobs |
|
$bodyRunningBc = $null |
|
If ($showRunningBc) { |
|
If ($workingSessionsBc.count -gt 0) { |
|
$bodyRunningBc = $workingSessionsBc | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $(New-TimeSpan $_.Progress.StartTime $(Get-Date))}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Read (GB)"; Expression = {[Math]::Round([Decimal]$_.Progress.ReadSize/1GB, 2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round([Decimal]$_.Progress.TransferedSize/1GB, 2)}}, |
|
@{Name="% Complete"; Expression = {$_.Progress.Percents}} | ConvertTo-HTML -Fragment |
|
$bodyRunningBc = $subHead01 + "Working Backup Copy Sessions" + $subHead02 + $bodyRunningBc |
|
} |
|
} |
|
|
|
# Get Backup Copy Sessions with Warnings or Failures |
|
$bodySessWFBc = $null |
|
If ($showWarnFailBc) { |
|
$sessWF = @($warningSessionsBc + $failsSessionsBc) |
|
If ($sessWF.count -gt 0) { |
|
If ($onlyLastBc) { |
|
$headerWF = "Backup Copy Jobs with Warnings or Failures" |
|
} Else { |
|
$headerWF = "Backup Copy Sessions with Warnings or Failures" |
|
} |
|
If ($showDetailedBc) { |
|
$bodySessWFBc = $sessWF | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Info.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Info.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
@{Name="Details"; Expression = { |
|
If ($_.GetDetails() -eq ""){$_ | Get-VBRTaskSession | %{If ($_.GetDetails()){$_.Name + ": " + ($_.GetDetails()).Replace("<br />","$B$R$")}}} |
|
Else {($_.GetDetails()).Replace("<br />","$B$R$")}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessWFBc = $subHead01 + $headerWF + $subHead02 + $bodySessWFBc |
|
} Else { |
|
$bodySessWFBc = $sessWF | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Details"; Expression = { |
|
If ($_.GetDetails() -eq ""){$_ | Get-VBRTaskSession | %{If ($_.GetDetails()){$_.Name + ": " + ($_.GetDetails()).Replace("<br />","$B$R$")}}} |
|
Else {($_.GetDetails()).Replace("<br />","$B$R$")}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessWFBc = $subHead01 + $headerWF + $subHead02 + $bodySessWFBc |
|
} |
|
} |
|
} |
|
|
|
# Get Successful Backup Copy Sessions |
|
$bodySessSuccBc = $null |
|
If ($showSuccessBc) { |
|
If ($successSessionsBc.count -gt 0) { |
|
If ($onlyLastBc) { |
|
$headerSucc = "Successful Backup Copy Jobs" |
|
} Else { |
|
$headerSucc = "Successful Backup Copy Sessions" |
|
} |
|
If ($showDetailedBc) { |
|
$bodySessSuccBc = $successSessionsBc | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Info.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Info.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB)"; Expression = {[Math]::Round($_.Info.Progress.ReadSize/1GB,2)}}, |
|
@{Name="Transferred (GB)"; Expression = {[Math]::Round($_.Info.Progress.TransferedSize/1GB,2)}}, |
|
@{Name="Dedupe"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetDedupeX(),1)) +"x"}}}, |
|
@{Name="Compression"; Expression = { |
|
If ($_.Progress.ReadSize -eq 0) {0} |
|
Else {([string][Math]::Round($_.BackupStats.GetCompressX(),1)) +"x"}}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessSuccBc = $subHead01 + $headerSucc + $subHead02 + $bodySessSuccBc |
|
} Else { |
|
$bodySessSuccBc = $successSessionsBc | Sort Creationtime | Select @{Name="Job Name"; Expression = {$_.Name}}, |
|
@{Name="Start Time"; Expression = {$_.CreationTime}}, |
|
@{Name="Stop Time"; Expression = {$_.EndTime}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
Result | ConvertTo-HTML -Fragment |
|
$bodySessSuccBc = $subHead01 + $headerSucc + $subHead02 + $bodySessSuccBc |
|
} |
|
} |
|
} |
|
|
|
## Gathering tasks after session info has been recorded due to Veeam issue |
|
# Gather all Backup Copy Tasks from Sessions within time frame |
|
$taskListBc = @() |
|
$taskListBc += $sessListBc | Get-VBRTaskSession |
|
$successTasksBc = @($taskListBc | ?{$_.Status -eq "Success"}) |
|
$wfTasksBc = @($taskListBc | ?{$_.Status -match "Warning|Failed"}) |
|
$pendingTasksBc = @($taskListBc | ?{$_.Status -eq "Pending"}) |
|
$runningTasksBc = @($taskListBc | ?{$_.Status -eq "InProgress"}) |
|
|
|
# Get All Backup Copy Tasks |
|
$bodyAllTasksBc = $null |
|
If ($showAllTasksBc) { |
|
If ($taskListBc.count -gt 0) { |
|
If ($showDetailedBc) { |
|
$bodyAllTasksBc = $taskListBc | Select @{Name="VM Name"; Expression = {$_.Name}}, |
|
@{Name="Job Name"; Expression = {$_.JobSess.Name}}, |
|
@{Name="Start Time"; Expression = {$_.Progress.StartTime}}, |
|
@{Name="Stop Time"; Expression = {If ($_.Progress.StopTime -eq "1/1/1900 12:00:00 AM"){"-"} Else {$_.Progress.StopTime}}}, |
|
@{Name="Duration (HH:MM:SS)"; Expression = {Get-Duration -ts $_.Progress.Duration}}, |
|
@{Name="Avg Speed (MB/s)"; Expression = {[Math]::Round($_.Progress.AvgSpeed/1MB,2)}}, |
|
@{Name="Total (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedSize/1GB,2)}}, |
|
@{Name="Processed (GB)"; Expression = {[Math]::Round($_.Progress.ProcessedUsedSize/1GB,2)}}, |
|
@{Name="Data Read (GB) |
/MyVeeamReport.ps1
Last active