get-zerto-completed-vpgs.ps1

<#
.SYNOPSIS
  This script figures out which initializations have completed in a zvm based on a source report.
.DESCRIPTION
  The script loads the source report which contains a protection status for replicated VMs, then retrieves current status from a ZVM and compares both.  For all VMs which have changed from Initializing to MeetingSLA, a report is created and sent to a list of email recipients.  The script then archives the source report and renames the updated report as source.  If a source report does not exist, the script will simply create one and do nothing else.
.PARAMETER help
  Displays a help message (seriously, what did you think this was?)
.PARAMETER history
  Displays a release history for this script (provided the editors were smart enough to document this...)
.PARAMETER log
  Specifies that you want the output messages to be written in a log file as well as on the screen.
.PARAMETER debugme
  Turns off SilentlyContinue on unexpected error messages.
.PARAMETER zvm
  ZVM fully qualified domain name or IP address.
.PARAMETER zvmport
  TCP port number used to connect to the ZVM (default if not specified is 9669).
.PARAMETER username
  Username used to connect to the ZVM.
.PARAMETER password
  Password used to connect to the ZVM.
.PARAMETER authInfo
  Pass on an authentication hash instead of a username and password.
.PARAMETER printonly
  Specify this parameter if you only want to display results on the screen as opposed to sending an email.
.EXAMPLE
  Connect to a ZVM of your choice:
  PS> .\get-zerto-completed-vpgs.ps1 -zvm zvm01.local -username admin -password admin
.LINK
  http://www.nutanix.com/services
.NOTES
  Author: Stephane Bourdeaud (sbourdeaud@nutanix.com)
  Revision: March 2nd 2016
#>

######################################
##   parameters and initial setup   ##
######################################
#let's start with some command line parsing
Param
(
    #[parameter(valuefrompipeline = $true, mandatory = $true)] [PSObject]$myParam1,
    [parameter(mandatory = $false)] [switch]$help,
    [parameter(mandatory = $false)] [switch]$history,
    [parameter(mandatory = $false)] [switch]$log,
    [parameter(mandatory = $false)] [switch]$debugme,
    [parameter(mandatory = $false)] [string]$zvm,
	[parameter(mandatory = $false)] [string]$zvmport,
	[parameter(mandatory = $false)] [string]$username,
	[parameter(mandatory = $false)] [string]$password,
    [parameter(mandatory = $false)] [string]$authInfo,
    [parameter(mandatory = $false)] [switch]$printonly
)

# get rid of annoying error messages
if (!$debugme) {$ErrorActionPreference = "SilentlyContinue"}

# Allow the use of self-signed SSL certificates.
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = { $true }

########################
##   main functions   ##
########################

#this function is used to output log data
Function OutputLogData 
{
	#input: log category, log message
	#output: text to standard output
<#
.SYNOPSIS
  Outputs messages to the screen and/or log file.
.DESCRIPTION
  This function is used to produce screen and log output which is categorized, time stamped and color coded.
.NOTES
  Author: Stephane Bourdeaud
.PARAMETER myCategory
  This the category of message being outputed. If you want color coding, use either "INFO", "WARNING", "ERROR" or "SUM".
.PARAMETER myMessage
  This is the actual message you want to display.
.EXAMPLE
  PS> OutputLogData -mycategory "ERROR" -mymessage "You must specify a cluster name!"
#>
	param
	(
		[string] $category,
		[string] $message
	)

    begin
    {
	    $myvarDate = get-date
	    $myvarFgColor = "Gray"
	    switch ($category)
	    {
		    "INFO" {$myvarFgColor = "Green"}
		    "WARNING" {$myvarFgColor = "Yellow"}
		    "ERROR" {$myvarFgColor = "Red"}
		    "SUM" {$myvarFgColor = "Magenta"}
	    }
    }

    process
    {
	    Write-Host -ForegroundColor $myvarFgColor "$myvarDate [$category] $message"
	    if ($log) {Write-Output "$myvarDate [$category] $message" >>$myvarOutputLogFile}
    }

    end
    {
        Remove-variable category
        Remove-variable message
        Remove-variable myvarDate
        Remove-variable myvarFgColor
    }
}#end function OutputLogData

##Function Definitions
#Get a site identifier by invoking Zerto APIs, given a Zerto API session and a site name:
function ZertogetSiteIdentifierByName ($zertoSessionHeader, $siteName, $BASEURL){
  $url = $BASEURL + "virtualizationsites"
  $response = Invoke-RestMethod -Uri $url -Headers $zertoSessionHeader -ContentType "application/xml"
  ForEach ($site in $response.ArrayOfVirtualizationSiteApi.VirtualizationSiteApi) {
    if ($site.VirtualizationSiteName -eq $siteName){
      return $site.SiteIdentifier
    }
  }
}

#Get a storage identifier by invoking Zerto APIs, given a Zerto Virtual Replication API session and a storage name:
function ZertogetDatastoreIdentifierByName ($zertoSessionHeader, $siteIdentfier, $datastoreName, $BASEURL){
  $url = $BASEURL + "virtualizationsites/"+$siteIdentfier + "/datastores"
  $response = Invoke-RestMethod -Uri $url -Headers $zertoSessionHeader -ContentType "application/xml"
  ForEach ($datastore in $response.ArrayOfDatastoreNativeApi.DatastoreNativeApi) {
    if ($datastore.DatastoreName -eq $datastoreName){
      return $datastore.DatastoreIdentifier
    }
  }
}

#Get unprotected VM identifiers by invoking Zerto APIs, given a Zerto API session, a site identifier, and a list of VMs to add to the VPG:
function ZertogetUnprotectedVMsIdentifiers($zertoSessionHeader, $siteIdentfier, $VMNames, $BASEURL){
  $url = $BASEURL + "virtualizationsites/"+$siteIdentfier + "/vms"
  $unprotectedVMsIdentifiers = @()
  $response = Invoke-RestMethod -Uri $url -Headers $zertoSessionHeader -ContentType "application/xml"
  ForEach ($vm in $response.ArrayOfVmNativeApi.VmNativeApi) {
    if ($VMNames.IndexOf($vm.VmName) -gt -1){
      $unprotectedVMsIdentifiers+=($vm.VmIdentifier)
    }
  }
  return $unprotectedVMsIdentifiers
}

#Authenticate with Zerto APIs: create a Zerto API session and return it, to be used in other APIs
function ZertogetZertoXSession ($myvarZvm, $myvarZvmPort, $myvarUsername, $myvarPassword){
  #Authenticate with Zerto APIs:
  $xZertoSessionURI = "https://" + $myvarZvm + ":"+$myvarZvmPort+"/v1/session/Add"
  $authInfo = ("{0}:{1}" -f $myvarUsername,$myvarPassword)
  $authInfo = [System.Text.Encoding]::UTF8.GetBytes($authInfo)
  $authInfo = [System.Convert]::ToBase64String($authInfo)
  $headers = @{Authorization=("Basic {0}" -f $authInfo)}
  $body = '{"AuthenticationMethod": "1"}'
  $contentType = "application/json"
  $xZertoSessionResponse = Invoke-WebRequest -Uri $xZertoSessionURI -Headers $headers -Method POST -Body $body -ContentType $contentType
  #Extract x-zerto-session from the response and add it to the actual API:
  $xZertoSession = $xZertoSessionResponse.headers.get_item("x-zerto-session")
  return $xZertoSession
}

#Authenticate with Zerto APIs: create a Zerto API session and return it, to be used in other APIs
function ZertogetZertoXSessionHash ($myvarZvm, $myvarZvmPort, $myvarAuthInfo){
  #Authenticate with Zerto APIs:
  $xZertoSessionURI = "https://" + $myvarZvm + ":"+$myvarZvmPort+"/v1/session/Add"
  $myvarAuthInfo = [System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String($myvarAuthInfo))
  $myvarAuthInfo = [System.Text.Encoding]::UTF8.GetBytes($myvarAuthInfo)
  $myvarAuthInfo = [System.Convert]::ToBase64String($myvarAuthInfo)
  $headers = @{Authorization=("Basic {0}" -f $myvarAuthInfo)}
  $body = '{"AuthenticationMethod": "1"}'
  $contentType = "application/json"
  $xZertoSessionResponse = Invoke-WebRequest -Uri $xZertoSessionURI -Headers $headers -Method POST -Body $body -ContentType $contentType
  #Extract x-zerto-session from the response and add it to the actual API:
  $xZertoSession = $xZertoSessionResponse.headers.get_item("x-zerto-session")
  return $xZertoSession
}

#Build VM elements to be added to the VPGs API, based on a list of VM identifiers
function ZertobuildVMsElement ($VMs, $BASEURL) {
$response = "<VmsIdentifiers>"
 
  ForEach ($vm in $VMs) {
    $response+="<string xmlns="+'"http://schemas.microsoft.com/2003/10/Serialization/Arrays"'+">"+$vm+"</string>"
  }
  $response += "</VmsIdentifiers>"
  return $response
}

#Get a list of VPGs and their status by invoking Zerto APIs, given a Zerto API session:
function ZertogetVPGs ($zertoSessionHeader, $BASEURL){
  $url = $BASEURL + "vpgs"
  $response = Invoke-RestMethod -Uri $url -Headers $zertoSessionHeader -ContentType "application/json"
  return $response
}

#Get a list of protected VMs and their status by invoking Zerto APIs, given a Zerto API session:
function ZertogetVMs ($zertoSessionHeader, $BASEURL){
  $url = $BASEURL + "vms"
  $response = Invoke-RestMethod -Uri $url -Headers $zertoSessionHeader -ContentType "application/json"
  return $response
}

#Get a list of VRAs and their status by invoking Zerto APIs, given a Zerto API session:
function ZertogetVRAs ($zertoSessionHeader, $BASEURL){
  $url = $BASEURL + "vras"
  $response = Invoke-RestMethod -Uri $url -Headers $zertoSessionHeader -ContentType "application/json"
  return $response
}


#########################
##   main processing   ##
#########################

#check if we need to display help and/or history
$HistoryText = @'
 Maintenance Log
 Date       By   Updates (newest updates at the top)
 ---------- ---- ---------------------------------------------------------------
 02/10/2016 sb   Initial release.
 03/02/2016 sb   Added printonly switch and revised logic for comparison.
################################################################################
'@
$myvarScriptName = ".\get-zerto-completed-vpgs.ps1"
 
if ($help) {get-help $myvarScriptName; exit}
if ($History) {$HistoryText; exit}


#let's load the Nutanix cmdlets
#if ((Get-PSSnapin -Name NutanixCmdletsPSSnapin -ErrorAction SilentlyContinue) -eq $null)#is it already there?
#{
#	Add-PSSnapin NutanixCmdletsPSSnapin #no? let's add it
#	if (!$?) #have we been able to add it successfully?
#	{
#		OutputLogData -category "ERROR" -message "Unable to load the Nutanix snapin.  Please make sure the Nutanix Cmdlets are installed on this server."
#		return
#	}
#}

#initialize variables
	#misc variables
	$myvarElapsedTime = [System.Diagnostics.Stopwatch]::StartNew() #used to store script begin timestamp
	$myvarvCenterServers = @() #used to store the list of all the vCenter servers we must connect to
	$myvarOutputLogFile = (Get-Date -UFormat "%Y_%m_%d_%H_%M_")
	$myvarOutputLogFile += "OutputLog.log"
	
	############################################################################
	# command line arguments initialization
	############################################################################	
	#let's initialize parameters if they haven't been specified
	[System.Collections.ArrayList]$myvarResults = New-Object System.Collections.ArrayList($null) #used for storing all protected vm entries.  This is what will be exported to csv
	
	$myvarSourceReport = "zerto-report-source-vpgs.csv"
	$myvarUpdatedReport = "zerto-report-updated-vpgs.csv"
	$myvarReplication = @{}
    $myvarReplication.CompletedReplications = @()
    $myvarReplication.Replications = @()
    $myvarReplication.NewReplications = @()
    $myvarReplication.NewCompletedReplications = @()

	
    # variables that you need to customize
	$myvarEmailFrom = "stephane.bourdeaud@krollontrack.com"
	$myvarSmtpServer = "koltsmtpr.ccp.edp.local"
	
	if (!$zvmport) {$zvmport = "9669"}
	if (!$zvm) {$zvm = read-host "Enter the FQDN or IP address of the ZVM"} #prompt for ZVM
	if (!$username -and !$authInfo) {$username = read-host "Enter the ZVM username"} #prompt for username
	if (!$password -and !$authInfo) {$password = read-host "Enter the ZVM password"} #prompt for username

    $myvarBASEURL = "https://" + $zvm + ":"+$zvmport+"/v1/" #base URL for all APIs
	
	################################
	##  Main execution here       ##
	################################
	
	#Initialize REST API session with the Zerto ZVM
	OutputLogData -category "INFO" -message "Connecting to ZVM $zvm..."
	if ($authInfo)
    {
        $myvarxZertoSession = ZertogetZertoXSessionHash $zvm $zvmport $authInfo
    }
    else
    {
        $myvarxZertoSession = ZertogetZertoXSession $zvm $zvmport $username $password
	}
    $myvarzertoSessionHeader = @{"x-zerto-session"=$myvarxZertoSession}
	
	#check to see if we have a valid session
	if ($myvarxZertoSession) 
	{#do we have a valid zerto session?	
		if (Test-Path ".\zerto-report-source-vpgs.csv") #check if source report exists
		{ #source report exists, so let's continue processing
			
			#load the source report in a reference variable
			$myvarSourceList = @(Import-Csv -Path ".\zerto-report-source-vpgs.csv")
			
			#retrieve updated report
			#Iterate protected VMs with JSON:
			OutputLogData -category "INFO" -message "Retrieving list of protected VMs from $zvm for the source report..."
			$myvarVMListJSON = ZertogetVMs $myvarzertoSessionHeader $myvarBASEURL
			
			#process each returned entry/protected vm
			if ($myvarVMListJSON) 
			{#we have protected vms, let's process
				OutputLogData -category "INFO" -message "Processing retrieved list of protected VMs for the source report..."
				foreach ($myvarVM in $myvarVMListJSON)
				{  
					#Figure out the status message
				    $myvarStatus = switch($myvarVM.Status) 
					{
				        0 {"Initializing"} #– The VPG is being initialized. This includes when a VPG is created, and during the initial sync between sites.
				        1 {"MeetingSLA"} #– The VPG is meeting the SLA specification.
				        2 {"NotMeetingSLA"} #– The VPG is not meeting the SLA specification for both the journal history and RPO SLA settings.
				        3 {"HistoryNotMeetingSLA"} #– The VPG is not meeting the SLA specification for the journal history.
				        4 {"RpoNotMeetingSLA"} #– The VPG is not meeting the SLA specification for the RPO SLA setting.
				        5 {"FailingOver"} #– The VPG is in a Failover operation.
				        6 {"Moving"} #– The VPG is in a Move operation.
				        7 {"Deleting"} #– The VPG is being deleted.
				        8 {"Recovered"} #– The VPG has been recovered.
				    }
				 	
					#Figure out the sub-status message
				    $myvarSubStatus = switch($myvarVM.SubStatus) 
					{
				        0 {"None"}
				        1 {"InitialSync"}
				        2 {"Creating"}
				        3 {"VolumeInitialSync"}
				        4 {"Sync"}
				        5 {"RecoveryPossible"}
				        6 {"DeltaSync"}
				        7 {"NeedsConfiguration"}
				        8 {"Error"}
				        9 {"EmptyProtectionGroup"}
				        10 {"DisconnectedFromPeerNoRecoveryPoints"}
				        11 {"FullSync"}
				        12 {"VolumeDeltaSync"}
				        13 {"VolumeFullSync"}
				        14 {"FailingOverCommitting"}
				        15 {"FailingOverBeforeCommit"}
				        16 {"FailingOverRollingBack"}
				        17 {"Promoting"}
				        18 {"MovingCommitting"}
				        19 {"MovingBeforeCommit"}
				        20 {"MovingRollingBack"}
				        21 {"Deleting"}
				        22 {"PendingRemove"}
				        23 {"BitmapSync"}
				        24 {"DisconnectedFromPeer"}
				        25 {"ReplicationPausedUserInitiated"}
				        26 {"ReplicationPausedSystemInitiated"}
				        27 {"RecoveryStorageProfileError"}
				        28 {"Backup"}
				        29 {"RollingBack"}
				        30 {"RecoveryStorageError"}
				        31 {"JournalStorageError"}
				        32 {"VmNotProtectedError"}
				    }
					
					#populate the hash for this protected vm
				    $myvarVMInfo = @{"VmName" = $myvarVM.VmName; `
				                    "VpgName" = $myvarVM.VpgName; `
				                    "ProvisionedStorageInMB" = $myvarVM.ProvisionedStorageInMB; `
				                    "UsedStorageInMB" = $myvarVM.UsedStorageInMB; `
				                    "Status" = $myvarStatus; `
				                    "SubStatus" = $myvarSubStatus; `
				                    "ActualRPO" = $myvarVM.ActualRPO; `
				                    "ThroughputInMB" = $myvarVM.ThroughputInMB}
					
					#populate the array for our final report
				    $myvarResults.Add((New-Object PSObject -Property $myvarVMInfo)) | Out-Null
				}#end foreach vm
				
				#export the results to csv
				OutputLogData -category "INFO" -message "Creating updated report as $myvarUpdatedReport..."
				$myvarResults | export-csv -NoTypeInformation $myvarUpdatedReport
				$myvarUpdatedList = @(Import-Csv -Path ".\zerto-report-updated-vpgs.csv")
			}#endif we have protected vms
			
			#compare source with update
			#find out which vms are newly protected (they are not in the source list) and have already completed
			OutputLogData -category "INFO" -message "Processing results..."
            foreach ($myvarVMsource in $myvarSourceList) #process each entry in the source list
            {
                $myvarVMSourceExists = $false #we use this variable to find out if the entry in source is also in the updated list
                $myvarVMSourceExistsReplicating = $false #we use this variable to keep track of status changes for an entry that is in both lists
                $myvarVMSourceExistsCompleted = $false #we use this variable to keep track of status changes for an entry that is in both lists
                

                foreach ($myvarVMupdated in $myvarUpdatedList) #compare with each entry in the updated list
                {
                    if ($myvarVMsource.VmName -eq $myvarVMupdated.VmName) #we compare the VM names
                    {
                        $myvarVMSourceExists = $true #we found a match so let's make sure we keep track of the fact that this vm is both in source and updated
                        if ($myvarVMupdated.Status -eq "Initializing") #vm is in both lists and is still replicating
                        {
                            $myvarVMSourceExistsReplicating = $true #mark it as such
                            $myvarReplication.Replications += $myvarVMSource
                        }#end if the vm is still replicating
                        else #vm is in both lists and it's not replicating, so let's check if it has completed
                        {
                            if ((($myvarVMupdated.Status -eq "MeetingSLA")  -or ($myvarVMupdated.Status -eq "NotMeetingSLA")) -and ($myvarVMsource.Status -eq "Initializing")) #vm was initializing and has finished replicating
                            {
                                $myvarVMSourceExistsCompleted = $true #mark it as such
                                $myvarReplication.CompletedReplications += $myvarVMUpdated
                            }#end if is replication done?
                        }#end else
                    }#end if vm is in both lists
                }#end process each updated entry comparison
			}#end process each source entry

            #now let's find out which vms are in updated AND not in source and what status they have
            foreach ($myvarVMupdated in $myvarUpdatedList) #process each entry in the updated list
            {
                $myvarVMSourceNew = $true #assume the entry is new until proven otherwise
                $myvarVMSourceNewReplicating = $false #we use this variable to keep track of status changes for an entry that is only in updated
                $myvarVMSourceNewCompleted = $false #we use this variable to keep track of status changes for an entry that is oinly in updated
                
                foreach ($myvarVMsource in $myvarSourceList) #compare with each entry in source
                {
                    if ($myvarVMsource.VmName -eq $myvarVMUpdated.VmName) #we compare the VM names
                    {
                        $myvarVMSourceNew = $false #the vm is in both list, so we'll ignore it as it has been processed elsewhere (in the previous section)
                    }#end if vm is in both lists
                }#end foreach entry in source comparison

                if ($myvarVMsourceNew) #the vm is only in updated
                {
                    if ($myvarVMUpdated.Status -eq "Initializing") #...and it is still replicating
                    {
                        $myvarVMSourceNewReplicating = $true
                        $myvarReplication.NewReplications += $myvarVMUpdated
                    }#endif the vm is still replicating
                    else
                    {
                        if (($myvarVMupdated.Status -eq "MeetingSLA") -or ($myvarVMupdated.Status -eq "NotMeetingSLA")) #it's done replicating
                        {
                            $myvarVMSourceNewCompleted = $true
                            $myvarReplication.NewCompletedReplications += $myvarVMUpdated
                        }#endif the vm is done replicating
                    }#end else
                }#endif the vm is new

            }#end foreach entry in updated
			
            $myvarReportTimeStamp = (Get-Date -UFormat "%Y_%m_%d_%H_%M")

            if (!$printonly)
            {
			    #send mail to recipients if there are any completed replications
			    if (($myvarReplication.CompletedReplications) -or ($myvarReplication.NewCompletedReplications) -or ($myvarReplication.NewReplications))
			    {
				    $myvarEmailRecipients = "stephane.bourdeaud@nutanix.com","artur@nutanix.com","nandaku.pezhery@nutanix.com","Phil_Liou@nutanix.com"
				
				    #send that email
				    OutputLogData -category "INFO" -message "Building the email content..."
				    $myvarEmailSubject = "Zerto Replication Report " + $myvarReportTimeStamp

                    #building tables
                    $myvarTableCompletedReplications = New-Object system.Data.DataTable "CompletedReplications"
                    $myvarTableReplications = New-Object system.Data.DataTable "Replications"
                    $myvarTableNewReplications = New-Object system.Data.DataTable "NewReplications"
                    $myvarTableNewCompletedReplications = New-Object system.Data.DataTable "NewCompletedReplications"

                    $myvarcol1 = New-Object system.Data.DataColumn VM,([string])
                    $myvarcol2 = New-Object system.Data.DataColumn Status,([string])
                    $myvarcol3 = New-Object system.Data.DataColumn VPG,([string])
                    $myvarcol4 = New-Object system.Data.DataColumn ThroughputMB,([string])
                    $myvarcol5 = New-Object system.Data.DataColumn UsedStorageMB,([string])
                    
                    $myvarTableCompletedReplications.columns.add($myvarcol1)
                    $myvarTableCompletedReplications.columns.add($myvarcol2)
                    $myvarTableCompletedReplications.columns.add($myvarcol3)
                    $myvarTableCompletedReplications.columns.add($myvarcol4)
                    $myvarTableCompletedReplications.columns.add($myvarcol5)

                    $myvarcol1 = New-Object system.Data.DataColumn VM,([string])
                    $myvarcol2 = New-Object system.Data.DataColumn Status,([string])
                    $myvarcol3 = New-Object system.Data.DataColumn VPG,([string])
                    $myvarcol4 = New-Object system.Data.DataColumn ThroughputMB,([string])
                    $myvarcol5 = New-Object system.Data.DataColumn UsedStorageMB,([string])

                    $myvarTableReplications.columns.add($myvarcol1)
                    $myvarTableReplications.columns.add($myvarcol2)
                    $myvarTableReplications.columns.add($myvarcol3)
                    $myvarTableReplications.columns.add($myvarcol4)
                    $myvarTableReplications.columns.add($myvarcol5)

                    $myvarcol1 = New-Object system.Data.DataColumn VM,([string])
                    $myvarcol2 = New-Object system.Data.DataColumn Status,([string])
                    $myvarcol3 = New-Object system.Data.DataColumn VPG,([string])
                    $myvarcol4 = New-Object system.Data.DataColumn ThroughputMB,([string])
                    $myvarcol5 = New-Object system.Data.DataColumn UsedStorageMB,([string])

                    $myvarTableNewReplications.columns.add($myvarcol1)
                    $myvarTableNewReplications.columns.add($myvarcol2)
                    $myvarTableNewReplications.columns.add($myvarcol3)
                    $myvarTableNewReplications.columns.add($myvarcol4)
                    $myvarTableNewReplications.columns.add($myvarcol5)

                    $myvarcol1 = New-Object system.Data.DataColumn VM,([string])
                    $myvarcol2 = New-Object system.Data.DataColumn Status,([string])
                    $myvarcol3 = New-Object system.Data.DataColumn VPG,([string])
                    $myvarcol4 = New-Object system.Data.DataColumn ThroughputMB,([string])
                    $myvarcol5 = New-Object system.Data.DataColumn UsedStorageMB,([string])

                    $myvarTableNewCompletedReplications.columns.add($myvarcol1)
                    $myvarTableNewCompletedReplications.columns.add($myvarcol2)
                    $myvarTableNewCompletedReplications.columns.add($myvarcol3)
                    $myvarTableNewCompletedReplications.columns.add($myvarcol4)
                    $myvarTableNewCompletedReplications.columns.add($myvarcol5)

				    
 				    
                    foreach ($myvarVM in $myvarReplication.CompletedReplications)
				    {
                        $myvarrow = $myvarTableCompletedReplications.NewRow()
                        $myvarrow.VM = $myvarVM.VmName
                        $myvarrow.Status = $myvarVM.Status
                        $myvarrow.VPG = $myvarVM.VpgName
                        $myvarrow.ThroughputMB = $myvarVM.ThroughputInMB
                        $myvarrow.UsedStorageMB = $myvarVM.UsedStorageInMB
                        $myvarTableCompletedReplications.Rows.Add($myvarrow)
				    }

 				    
                    foreach ($myvarVM in $myvarReplication.NewCompletedReplications)
				    {
                        $myvarrow = $myvarTableNewCompletedReplications.NewRow()
                        $myvarrow.VM = $myvarVM.VmName
                        $myvarrow.Status = $myvarVM.Status
                        $myvarrow.VPG = $myvarVM.VpgName
                        $myvarrow.ThroughputMB = $myvarVM.ThroughputInMB
                        $myvarrow.UsedStorageMB = $myvarVM.UsedStorageInMB
                        $myvarTableNewCompletedReplications.Rows.Add($myvarrow)
				    }


 				    foreach ($myvarVM in $myvarReplication.Replications)
				    {
                        $myvarrow = $myvarTableReplications.NewRow()
                        $myvarrow.VM = $myvarVM.VmName
                        $myvarrow.Status = $myvarVM.Status
                        $myvarrow.VPG = $myvarVM.VpgName
                        $myvarrow.ThroughputMB = $myvarVM.ThroughputInMB
                        $myvarrow.UsedStorageMB = $myvarVM.UsedStorageInMB
                        $myvarTableReplications.Rows.Add($myvarrow)
				    }


 				    foreach ($myvarVM in $myvarReplication.NewReplications)
				    {
                        $myvarrow = $myvarTableNewReplications.NewRow()
                        $myvarrow.VM = $myvarVM.VmName
                        $myvarrow.Status = $myvarVM.Status
                        $myvarrow.VPG = $myvarVM.VpgName
                        $myvarrow.ThroughputMB = $myvarVM.ThroughputInMB
                        $myvarrow.UsedStorageMB = $myvarVM.UsedStorageInMB
                        $myvarTableNewReplications.Rows.Add($myvarrow)
				    }

                    if ($myvarReplication.CompletedReplications)
                    {
                        $myvarhtml = "The following VMs have finished replicating:<br /><br />"
                        $myvarhtml += "<table><tr><td>VM</td><td>Status</td><td>VPG</td><td>ThroughputMB</td><td>UsedStorageMB</td></tr>"
                        foreach ($myvarrow in $myvarTableCompletedReplications.Rows)
                        { 
                            $myvarhtml += "<tr><td>" + $myvarrow[0] + "</td><td>" + $myvarrow[1] + "</td><td>" + $myvarrow[2] + "</td><td>" + $myvarrow[3] + "</td><td>" + $myvarrow[4] + "</td></tr>"
                        }
                        $myvarhtml += "</table>"
                        $myvarEmailBody += "<br /><br />" + $myvarhtml
                    }

                    if ($myvarReplication.NewCompletedReplications)
                    {
                        $myvarhtml = "The following VMs are new and have finished replicating:<br /><br />"
                        $myvarhtml += "<table><tr><td>VM</td><td>Status</td><td>VPG</td><td>ThroughputMB</td><td>UsedStorageMB</td></tr>"
                        foreach ($myvarrow in $myvarTableNewCompletedReplications.Rows)
                        { 
                            $myvarhtml += "<tr><td>" + $myvarrow[0] + "</td><td>" + $myvarrow[1] + "</td><td>" + $myvarrow[2] + "</td><td>" + $myvarrow[3] + "</td><td>" + $myvarrow[4] + "</td></tr>"
                        }
                        $myvarhtml += "</table>"
                        $myvarEmailBody += "<br /><br />" + $myvarhtml
                    }

                    if ($myvarReplication.NewReplications)
                    {
                        $myvarhtml = "The following VMs are new and still replicating:<br /><br />"
                        $myvarhtml += "<table><tr><td>VM</td><td>Status</td><td>VPG</td><td>ThroughputMB</td><td>UsedStorageMB</td></tr>"
                        foreach ($myvarrow in $myvarTableNewReplications.Rows)
                        { 
                            $myvarhtml += "<tr><td>" + $myvarrow[0] + "</td><td>" + $myvarrow[1] + "</td><td>" + $myvarrow[2] + "</td><td>" + $myvarrow[3] + "</td><td>" + $myvarrow[4] + "</td></tr>"
                        }
                        $myvarhtml += "</table>"
                        $myvarEmailBody += "<br /><br />" + $myvarhtml
                    }

                    if ($myvarReplication.Replications)
                    {
                        $myvarhtml = "The following VMs are still replicating:<br /><br />"
                        $myvarhtml += "<table><tr><td>VM</td><td>Status</td><td>VPG</td><td>ThroughputMB</td><td>UsedStorageMB</td></tr>"
                        foreach ($myvarrow in $myvarTableReplications.Rows)
                        { 
                            $myvarhtml += "<tr><td>" + $myvarrow[0] + "</td><td>" + $myvarrow[1] + "</td><td>" + $myvarrow[2] + "</td><td>" + $myvarrow[3] + "</td><td>" + $myvarrow[4] + "</td></tr>"
                        }
                        $myvarhtml += "</table>"
                        $myvarEmailBody += "<br /><br />" + $myvarhtml
                    }
				
				    OutputLogData -category "INFO" -message "Sending the email..."
				    Send-MailMessage -SmtpServer $myvarSmtpServer -From $myvarEmailFrom -To $myvarEmailRecipients -Subject $myvarEmailSubject -Body $myvarEmailBody -bodyashtml

                    #archive source report
			        $myvarArchivedReportName = "zerto-report-source-vpgs-" + $myvarReportTimeStamp + ".csv"
			        Rename-Item zerto-report-source-vpgs.csv $myvarArchivedReportName
			        OutputLogData -category "INFO" -message "Saved the source report to $myvarArchivedReportName"
			        #rename updated report
			        Rename-Item zerto-report-updated-vpgs.csv zerto-report-source-vpgs.csv
			        OutputLogData -category "INFO" -message "Saved the updated report as the new source report..."
			    }
                else
                {
                    OutputLogData -category "INFO" -message "There are no completed replications so I have nothing to do!"
                }
            } #end if not printonly
            else
            {
                #print only the output (as opposed to sending an email)
                if (($myvarReplication.CompletedReplications) -or ($myvarReplication.NewCompletedReplications) -or ($myvarReplication.NewReplications))
			    {
                    if ($myvarReplication.CompletedReplications)
                    {
                        OutputLogData -category "INFO" -message "The following VMs have been replicated since the last check:"
                        $myvarReplication.CompletedReplications | ft -autosize
                    }
                    if ($myvarReplication.NewCompletedReplications)
                    {
                        OutputLogData -category "INFO" -message "The following VMs are new and have been replicated since the last check:"
                        $myvarReplication.NewCompletedReplications | ft -autosize
                    }
                    if ($myvarReplication.NewReplications)
                    {
                        OutputLogData -category "INFO" -message "The following VMs are new and still replicating:"
                        $myvarReplication.NewReplications | ft -autosize
                    }
                    if ($myvarReplication.Replications)
                    {
                        OutputLogData -category "INFO" -message "The following VMs are still replicating:"
                        $myvarReplication.Replications | ft -autosize
                    }

                    #archive source report
			        $myvarArchivedReportName = "zerto-report-source-vpgs-" + $myvarReportTimeStamp + ".csv"
			        Rename-Item zerto-report-source-vpgs.csv $myvarArchivedReportName
			        OutputLogData -category "INFO" -message "Saved the source report to $myvarArchivedReportName"
			        #rename updated report
			        Rename-Item zerto-report-updated-vpgs.csv zerto-report-source-vpgs.csv
			        OutputLogData -category "INFO" -message "Saved the updated report as the new source report..."

                }
                else
                {
                    OutputLogData -category "INFO" -message "There are no completed replications so I have nothing to do!"
                }

            } #end if printonly
			
		} #endif source report exists
		else #there is no source report, so let's create one
		{	
			#Iterate protected VMs with JSON:
			OutputLogData -category "INFO" -message "Retrieving list of protected VMs from $zvm for the source report..."
			$myvarVMListJSON = ZertogetVMs $myvarzertoSessionHeader $myvarBASEURL
			
			#process each returned entry/protected vm
			if ($myvarVMListJSON) {
				OutputLogData -category "INFO" -message "Processing retrieved list of protected VMs for the source report..."
				foreach ($myvarVM in $myvarVMListJSON){  
					#Figure out the status message
				    $myvarStatus = switch($myvarVM.Status) {
				        0 {"Initializing"} #– The VPG is being initialized. This includes when a VPG is created, and during the initial sync between sites.
				        1 {"MeetingSLA"} #– The VPG is meeting the SLA specification.
				        2 {"NotMeetingSLA"} #– The VPG is not meeting the SLA specification for both the journal history and RPO SLA settings.
				        3 {"HistoryNotMeetingSLA"} #– The VPG is not meeting the SLA specification for the journal history.
				        4 {"RpoNotMeetingSLA"} #– The VPG is not meeting the SLA specification for the RPO SLA setting.
				        5 {"FailingOver"} #– The VPG is in a Failover operation.
				        6 {"Moving"} #– The VPG is in a Move operation.
				        7 {"Deleting"} #– The VPG is being deleted.
				        8 {"Recovered"} #– The VPG has been recovered.
				    }
				 	
					#Figure out the sub-status message
				    $myvarSubStatus = switch($myvarVM.SubStatus) {
				        0 {"None"}
				        1 {"InitialSync"}
				        2 {"Creating"}
				        3 {"VolumeInitialSync"}
				        4 {"Sync"}
				        5 {"RecoveryPossible"}
				        6 {"DeltaSync"}
				        7 {"NeedsConfiguration"}
				        8 {"Error"}
				        9 {"EmptyProtectionGroup"}
				        10 {"DisconnectedFromPeerNoRecoveryPoints"}
				        11 {"FullSync"}
				        12 {"VolumeDeltaSync"}
				        13 {"VolumeFullSync"}
				        14 {"FailingOverCommitting"}
				        15 {"FailingOverBeforeCommit"}
				        16 {"FailingOverRollingBack"}
				        17 {"Promoting"}
				        18 {"MovingCommitting"}
				        19 {"MovingBeforeCommit"}
				        20 {"MovingRollingBack"}
				        21 {"Deleting"}
				        22 {"PendingRemove"}
				        23 {"BitmapSync"}
				        24 {"DisconnectedFromPeer"}
				        25 {"ReplicationPausedUserInitiated"}
				        26 {"ReplicationPausedSystemInitiated"}
				        27 {"RecoveryStorageProfileError"}
				        28 {"Backup"}
				        29 {"RollingBack"}
				        30 {"RecoveryStorageError"}
				        31 {"JournalStorageError"}
				        32 {"VmNotProtectedError"}
				    }
					
					#populate the hash for this protected vm
				    $myvarVMInfo = @{"VmName" = $myvarVM.VmName; `
				                    "VpgName" = $myvarVM.VpgName; `
				                    "ProvisionedStorageInMB" = $myvarVM.ProvisionedStorageInMB; `
				                    "UsedStorageInMB" = $myvarVM.UsedStorageInMB; `
				                    "Status" = $myvarStatus; `
				                    "SubStatus" = $myvarSubStatus; `
				                    "ActualRPO" = $myvarVM.ActualRPO; `
				                    "ThroughputInMB" = $myvarVM.ThroughputInMB}
					
					#populate the array for our final report
				    $myvarResults.Add((New-Object PSObject -Property $myvarVMInfo)) | Out-Null
				}
				
				#export the results to csv
				OutputLogData -category "INFO" -message "Creating source report as $myvarSourceReport..."
				$myvarResults | export-csv -NoTypeInformation $myvarSourceReport
			}#endif VMListJSON
			else #no protected vms were found
			{
				OutputLogData -category "WARN" -message "Did not find any protected VMs on $zvm..."
			}
		}#end else if source report does not exist
	}#endif check if valid session
	else #we didn't get a valid session from the ZVM
	{
		OutputLogData -category "ERROR" -message "Could not connect to $zvm..."
	}
	
#########################
##       cleanup       ##
#########################

	#let's figure out how much time this all took
	OutputLogData -category "SUM" -message "total processing time: $($myvarElapsedTime.Elapsed.ToString())"
	
	#cleanup after ourselves and delete all custom variables
	Remove-Variable myvar*
	Remove-Variable help
    Remove-Variable history
	Remove-Variable log
	Remove-Variable zvm
	Remove-Variable zvmport
	Remove-Variable username
	Remove-Variable password
    Remove-Variable debugme
    Remove-Variable authInfo
    Remove-Variable printonly