AD Operation Validation class

‘Sup PSHomies,

I’m like a dog with a bone… 😛

2016 was all about operation validation for me. I did a series on Active Directory snapshot, report and validation that was well received by the community! Classes will definitely make the user experience more pleasant! I decided to refactor the code to a class 😉 Got a lot of ground to cover so let’s dive in!

Here’s a screenshot of the ADInfrastructure (was what popped in my mind at the time) class properties and methods:

The focus will be on Active Directory’s forest, domain, sites, sitelinks, subnets and domaincontrollers.

These are the methods I’ve worked out so far (work in progress):

GetCurrentConfig() will populate the necessary properties using the right activedirectory cmdlets

ImportADSnapshot() will import a saved XML file to ADSnapshot property.

ExportADSnapshot() saves the class object as a XML file. This will generate a new XML file using the current $exportDate value

RunValidation() deserves it own section… 😉

RunValidation()

This is where the the operation validation will take place. This was a bit of a challenge getting the method right, but I think it worked out just fine… I should explain…

In my first attempt I ran the validation directly from the method. You can invoke the Describe block just like a function. That wasn’t the challenge, have a look at the It block

The test is hard coded to use $this as source and $this.ADSnapshot as target. I blogged about some possible validation gotchas a while back. To remedy this, I decided to use a scriptblock. You can also provide parameters to a scriptblock . In this case I provided ($Source, $Target) as parameters. This will make interchanging  input easier of which I’ll explain the advantages later on.

Ok so the scriptblock was a good idea. One of the things I wanted to do was save the validation results. That’s where I ran into something interesting. The input has to be a *.tests.ps1 file(s). I tried using the scriptblock as input but that didn’t work. I visited the github page to see if scriptblock is supported as a feature, it isn’t. In order to save the results I would first have to save the test to a file. The scriptblock made that part a lot easier. As a workaround, this isn’t an issue.The file is generate every time RunValidation is executed, an inconvenience at most.  A scriptblock feature  would make for a cleaner approach.

Quick side step: There’s a poll on twitter for anyone interested in casting a vote 🙂 Only 5 more days left…

The test results are saved in ValidationResults. That’s RunValidation in a nutshell.

It’s quite a bit of code, so I’ll post that at the end of the blog. Here’s what you can expect if you try it out. First up, a simple verification of the current configuration against a saved snapshot

#region Verify Current Configuration against a snapshot
$snapShotDate = '12012017'
$ADInfra = [ADInfrastructure]::New()
$ADInfra.GetCurrentConfig()
$ADInfra.snapshotDate = $snapShotDate
$ADInfra.ExportADSnapshot()
$ADInfra.ImportADSnapshot()
$ADInfra.ADSnapshot
$ADInfra.RunValidation($ADInfra,$ADInfra.ADSnapshot,@('Forest','Domain'))
$ADInfra.RunValidation($ADInfra.ADSnapshot,$ADInfra,@('Forest','Domain'))
$ADInfra.ActionHistory | Select-Object -Property TimeGenerated,Tags,MessageData
#endregion

Before you get startetd, you need to instantiate the class. GetCurrentConfig() will save the information to the properties. ExportADSnapshot() will create a ADSnapshot-($exportDate).xml file. ImportADSnapshot will import any existing snapshot file of a given $snapshotDate formatted as ‘ddMMyyyy’.

Because I’m verifying the current configuration with a snapshot without any changes all the tests will pass.

No surprises.

For the next example, I wanted to validate against a manual configuration. This is where the scriptblock really made a difference. I added a non-existent DC to  $ADVerifyConfig for testing purposes.

 

	#region verify a manual Configuration a against a snapshot
	$primaryDC = 'DC-DSC-01.pshirwin.local'
	$ADVerifyConfig = @{
	Forest = @{
	Name = 'pshirwin.local'
	ForestMode = 'Windows2012R2Forest'
	DomainNamingMaster = $primaryDC
	SchemaMaster = $primaryDC
	GlobalCatalogs = @(
	$primaryDC
	)
	}
	Domain = @{
	DistinguishedName = 'DC=pshirwin,DC=local'
	InfrastructureMaster = $primaryDC
	PDCEmulator = $primaryDC
	RIDMaster = $primaryDC
	}
	Sites = @(
	[PSCustomObject]@{
	Name = 'Default-First-Site-Name'
	}
	[PSCustomObject]@{
	Name = 'Branch01'
	}
	)
	SiteLinks = @(
	[PSCustomObject]@{
	Name = 'DEFAULTIPSITELINK'
	Cost = 100
	ReplicationFrequencyInMinutes = 180
	}
	)
	Subnets = @(
	[PSCustomObject]@{
	Name = '192.168.0.0/24'
	Site = 'CN=Branch01,CN=Sites,CN=Configuration,DC=pshirwin,DC=local'
	Location = $null
	}
	)
	DomainControllers = @(
	[PSCustomObject]@{
	Name = 'DC-DSC-01'
	Enabled = $true
	IsGlobalCatalog = $true
	IsReadOnly = $false
	IPv4Address = '10.15.75.250'
	}
	[PSCustomObject]@{
	Name = 'DC-DSC-02'
	Enabled = $true
	IsGlobalCatalog = $true
	IsReadOnly = $false
	IPv4Address = '10.15.75.251'
	}
	)
	}
	$ADVerifyInfra = [ADInfrastructure]::New(
	$ADVerifyConfig.Forest,
	$ADVerifyConfig.Domain,
	$ADVerifyConfig.Sites,
	$ADVerifyConfig.Subnets,
	$ADVerifyConfig.SiteLinks,
	$ADVerifyConfig.DomainControllers
	)
	$ADVerifyInfra.snapshotDate = $snapShotDate
	$ADVerifyInfra.ImportADSnapshot()
	$ADVerifyInfra.RunValidation($ADVerifyInfra,$ADVerifyInfra.ADSnapshot,@('Forest','Domain'))
	$ADVerifyInfra.RunValidation($ADVerifyInfra.ADSnapshot,$ADVerifyInfra,@('Forest','Domain'))
	$ADVerifyInfra.RunValidation($ADVerifyInfra.ADSnapshot,$ADVerifyInfra,@('DomainControllers'))
	$ADVerifyInfra.RunValidation($ADVerifyInfra,$ADVerifyInfra.ADSnapshot,@('DomainControllers'))
	$ADVerifyInfra.RunValidation($ADVerifyInfra.ADSnapshot,$ADVerifyInfra,@())
	$ADVerifyInfra.ActionHistory | Select-Object -Property TimeGenerated,Tags,MessageData
	#endregion

view raw ManualClassDemo.ps1 hosted with ❤ by GitHub

The class is instantiated differently this time. The values are added externally. If you run GetCurrentConfig() at any point, it will rewrite the default values. Here are the results of the snapshot vs manual source first.

$ADVerifyInfra.RunValidation($ADVerifyInfra.ADSnapshot,$ADVerifyInfra,@('DomainControllers'))

The snapshot only has one DomainController, we never get to the second DomainController. Now if we switch parameters from positions…

$ADVerifyInfra.RunValidation($ADVerifyInfra,$ADVerifyInfra.ADSnapshot,@('DomainControllers'))

Ah! DC-DSC-02 doesn’t exist in the snapshot so it will fail! There are always two sides to consider. RunValidation() makes it easier to test and verify both sides…

Bonus round

ActionHistory

I recently discovered the Information stream in PowerShell v5. I decided to make use of Write-Information to log activities as I go along. This makes for easier troubleshooting of actions and/or sequences of methods being executed, couldn’t hurt… 😉

ValidationResults

Saving the validation test result enables you to process the results in different ways.

For starters you can use Format-Pester by Erwan Quélin to generate documentation of the results. Now because it’s an object you can just as easily run a query:

$ADVerifyInfra.validationResults.Results.TestResult.Where{$_.Passed -eq $false}

You can even send a high-level overview to Slack (It’s on my to-do list).

Whew! I think I’ve covered all the essentials… Ok as promised the code:

	Class ADInfrastructure{
	[PSObject]$Forest
	[PSObject]$Domain
	[PSObject]$Sites
	[PSObject]$Subnets
	[PSObject]$Sitelinks
	[PSObject]$DomainControllers
	[String]$snapshotDate
	[String]$exportFolder='C:\scripts\export\dsa'
	[PSObject]$ADSnapshot
	[PSObject[]]$validationResults
	[PSObject[]]$ActionHistory
	#Default Constructor
	ADInfrastructure(){}
	#Constructor
	ADInfrastructure($frs,$dom,$sit,$sub,$stl,$dcs){
	$this.Forest = $frs
	$this.Domain = $dom
	$this.Sites = $sit
	$this.Sitelinks = $stl
	$this.Subnets = $sub
	$this.DomainControllers = $dcs
	}
	GetCurrentConfig(){
	$MessageData = "Get current Active Directory configuration"
	$this.ActionHistory += Write-Information -MessageData $MessageData 6>&1 -Tags 'Get','CurrentConfig','AD' | Select-Object *
	$this.Forest = $(Get-ADForest)
	$this.Domain = $(Get-ADDomain)
	$this.DomainControllers = $(Get-ADDomainController -Filter *)
	$this.Sites = $(Get-ADReplicationSite -Filter *)
	$this.Subnets = $(Get-ADReplicationSubnet -Filter *)
	$this.Sitelinks = $(Get-ADReplicationSiteLink -Filter *)
	}
	ImportADSnapshot(){
	if(Test-Path "$($this.exportFolder)\ADSnapshot-$($This.snapshotDate).xml"){
	$this.ADSnapshot = Import-Clixml "$($this.exportFolder)\ADSnapshot-$($This.snapshotDate).xml"
	$MessageData = "Imported ADSnapshot from $($this.SnapshotDate)"
	$this.ActionHistory += Write-Information -MessageData $MessageData 6>&1 -Tags 'Get','ADSnapshot','Found' | Select-Object *
	}
	Else{
	$MessageData = "ADSnapshot from $($this.SnapshotDate) not found"
	Write-Warning -Message $MessageData
	$this.ActionHistory += Write-Information -MessageData $MessageData 6>&1 -Tags 'Get','ADSnapshot','Missing' | Select-Object *
	}
	}
	ExportADSnapshot(){
	$MessageData = "Saving ADSnapshot"
	$this.ActionHistory += Write-Information -MessageData $MessageData 6>&1 -Tags 'Save','ADSnapshot' | Select-Object *
	$exportDate = Get-Date -Format ddMMyyyy
	$this | Export-Clixml "$($this.exportFolder)\ADSnapshot-$($exportDate).xml" -Encoding UTF8
	}
	RunValidation($src,$tgt,$tag){
	#Something with Tags
	$MessageData = "Validating AD Configuration against saved snapshot from $($this.SnapShotDate)"
	$this.ActionHistory += Write-Information -MessageData $MessageData 6>&1 -Tags 'Validation','ADSnapshot','CurrentConfig','AD' | Select-Object *
	$sbValidation = {
	Param($Source,$Target)
	Describe 'AD Forest configuration operational readiness' -Tags Forest {
	Context 'Verifying Forest Configuration'{
	it "Forest Name $($Source.Forest.Name)" {
	$Source.Forest.Name |
	Should be $Target.Forest.Name
	}
	it "Forest Mode $($Source.Forest.ForestMode)" {
	$Source.Forest.ForestMode |
	Should be $Target.Forest.ForestMode
	}
	it "$($Source.Forest.DomainNamingMaster) is DomainNamingMaster" {
	$Source.Forest.DomainNamingMaster|
	Should be $Target.Forest.DomainNamingMaster
	}
	it "$($Source.Forest.DomainNamingMaster) is SchemaMaster"{
	$Source.Forest.SchemaMaster |
	Should be $Target.Forest.SchemaMaster
	}
	}
	}
	Describe 'AD GlobalCatalog configuration operational readiness' -Tags GlobalCatalog {
	Context 'Verifying GlobalCatalogs'{
	$Source.Forest.GlobalCatalogs |
	ForEach-Object{
	it "Server $($_) is a GlobalCatalog"{
	$Target.Forest.GlobalCatalogs.Contains($_) |
	Should be $true
	}
	}
	}
	}
	Describe 'AD Domain configuration operational readiness' -Tags Domain{
	Context 'Verifying Domain Configuration'{
	it "Domain DN is $($Source.Domain.DistinguishedName)" {
	$Source.Domain.DistinguishedName |
	Should be $Target.Domain.DistinguishedName
	}
	it "$($Source.Domain.InfrastructureMaster) is InfrastructureMaster"{
	$Source.Domain.InfrastructureMaster |
	Should be $Target.Domain.InfrastructureMaster
	}
	it "$($Source.Domain.PDCEmulator) is PDCEmulator"{
	$Source.Domain.PDCEmulator |
	Should be $Target.Domain.PDCEmulator
	}
	it "$($Source.Domain.RIDMaster) is RIDMaster"{
	$Source.Domain.RIDMaster |
	Should be $Target.Domain.RIDMaster
	}
	}
	}
	Describe 'AD DomainControllers configuration operational readiness' -Tags DomainControllers {
	$lookupDC = $Target.DomainControllers | Group-Object -AsHashTable -AsString -Property Name
	ForEach($dc in $Source.DomainControllers){
	Context "Verifying DC $($dc.Name) Configuration"{
	it "Is enabled " {
	$dc.Enabled | Should be $lookupDC.$($dc.Name).Enabled
	}
	it "Is GC " {
	$dc.IsGlobalCatalog | Should be $lookupDC.$($dc.Name).IsGlobalCatalog
	}
	it "ReadOnly is $($dc.IsReadOnly) " {
	$dc.IsReadOnly| Should be $lookupDC.$($dc.Name).IsReadOnly
	}
	it "IPv4Address is $($dc.IPv4Address)" {
	$dc.IPv4Address | Should be $lookupDC.$($dc.Name).IPv4Address
	}
	}
	}
	}
	Describe 'AD Sites operational readiness' -Tags Sites {
	Context 'Verifying Sites'{
	$Source.Sites |
	ForEach-Object{
	it "Site $($_.Name)"{
	$Target.Sites.Name.Contains($_.Name) |
	Should be $true
	}
	}
	}
	}
	Describe 'AD Subnets operational readiness' -Tags Subnets{
	$lookupSubnets = $Target.SubNets | Group-Object -AsHashTable -AsString -Property Name
	ForEach($subnet in $Source.Subnets){
	Context "Verifying Subnet $($subnet.Name)"{
	it "Subnet name is $($subnet.Name)"{
	$subnet.Name | Should be $lookupSubnets.$($subnet.Name).Name
	}
	it "Subnet location is $($subnet.Location)"{
	$subnet.Location | Should be $lookupSubnets.$($subnet.Name).Location
	}
	it "Subnet associated site is $($subnet.Site)"{
	$subnet.Site | Should be $lookupSubnets.$($subnet.Name).Site
	}
	}
	}
	}
	Describe 'AD Sitelinks operational readiness' -Tags SiteLinks {
	$lookupSiteLinks = $Target.Sitelinks | Group-Object -AsHashTable -AsString -Property Name
	ForEach($sitelink in $Source.Sitelinks){
	Context "Verifying Sitelink $($sitelink.Name)"{
	it "Sitelink name is $($sitelink.Name)"{
	$sitelink.Name | Should be $lookupSiteLinks.$($sitelink.Name).Name
	}
	it "Sitelink cost is $($sitelink.Cost)"{
	$sitelink.Cost | Should be $lookupSiteLinks.$($sitelink.Name).Cost
	}
	it "Sitelink replication frequency (min) is $($sitelink.ReplicationFrequencyInMinutes)"{
	$sitelink.ReplicationFrequencyInMinutes| Should be $lookupSiteLinks.$($sitelink.Name).ReplicationFrequencyInMinutes
	}
	}
	}
	}
	}
	$pesterFile = "$($this.exportFolder)\ADInfra.tests.ps1"
	$sbValidation.ToString() | out-file -FilePath $pesterFile -Force
	$testADInfra = @(
	@{
	Path = $pesterFile
	Parameters = @{
	Source = $src
	Target = $tgt
	}
	}
	)
	$this.ValidationResults += [PSCustomObject]@{
	ValidationDate = $(Get-Date)
	Results = Invoke-Pester -Path $testADInfra -PassThru -Tag $tag
	}
	}
	}

view raw class-ADInfrastructure.ps1 hosted with ❤ by GitHub

Classes will definitely enhance your end-user’s experience…

Hope it’s worth something to you…

Ttyl,

Urv

RoboCopy class

‘Sup PSHomies,

It all started a year ago… Always wanting to learn anything PowerShell related, classes caught my eye ever since it was introduced in v5.  I wanted to try my hand at classes with a real life application… So I got on twitter for some tips…

Doug was kind enough to reach out and point me in the right direction, for which I owe him a great debt! Appreciate it Doug!!!

Like I said, I wanted to try my hand at classes with a real life application… If you’ve read my blogs then you’ll know that I’m a fan of robocopy, seriously, huge fan! . Did I mention how awesome robocopy is? 😛 I think I found my real life application 😉

When I started out with my Robocopy class, it was just about logging initially, but it could be so much more! Classes are native to v5. Now that v5 is mainstream I decided to finish the class. Richard Siddaway’s article  was just the spark I needed to get me going (again)!

Here’s what the Robocopy class looks like:

Here a quick rundown on the properties:

The source/destination properties of the class are self explanatory (if you’re familiar with robocopy). The property logdir and JobID will be used to define a valid logfile name (with extension .log). Robocopy has quite a bit of options. I wanted to keep it as generic as possible. The property $this.Options is still a work in progress. The property $this.WildCards  is where you’ll define what will be filtered.  I’ll get back to rcCMDs and rcExitCodes later on…

These are the methods I came up with (so far, still a work in progress)

• Mirror(). Mirrors $this.Source to $this.Destination with some default options
• Move(). Moves this.Source to $this.Destination with some default options
• RollBack(). Rollback $this.Destination to $this.Source with some default options
• Sync(). Sync will synchronize the delta’s from $this.Source to $this.Destination using any additional $this.Options defined (at least that’s the idea). I’ve added a few options by default, mostly to exclude files and folders, think recycle.bin “System Volume Information” and the likes.
• VerifyPaths(). This let’s you know if the $this.Source, $this.Destination and $this.LogDir are valid.
• GetlistSource(). This will list the content of the $this.Source
• GetListDestionation(). This will list the content of $this.Destination
• GetLogSummary. This will return a summary of the log file (Hehe). The method is static so that you don’t have to instantiate the class in order to use it. (Thanks again Doug!)

The two methods: StartRCProcess and ExecuteRCCMD are actually helper methods. I just haven’t figured out how that works in classes. Ideally I’d like to have them hidden or as a function if that even makes sense. So here’s where they come in. At first I just executed robocopy with the necessary arguments. If you’re not interested in the exitcode then using ExecuteRCCMD is what you need. I wrote a blog about enumerating RoboCopy Exitcodes. Using $LastExitCode isn’t going to cut it if you decide to run robocopy jobs parallel. That’s where StartRCProcess comes in.Using Start-Process comes with an overhead of say 20 MB, which could add up in the long run. You do need to wait until the process has finished to retrieve the exitcode. If you really need the exitcode then StartRCProcess is what you need. The property $this.rcExitCodes will only be populated if StartRCProcess is used. Both will populate the $this.rcCMDs property.

Ok I think I’ve covered the basics, time to show some code! 😉

	[Flags()] Enum RoboCopyExitCodes{
	NoChange = 0
	OKCopy = 1
	ExtraFiles = 2
	MismatchedFilesFolders = 4
	FailedCopyAttempts = 8
	FatalError = 16
	}
	Class RoboCopy{
	[String]$Source
	[String]$Destination
	[String]$LogDir
	[String]$JobID
	[String]$Options
	[String[]]$WildCards
	[PSObject[]]$rcCMDs
	[PSObject[]]$rcExitCodes
	#default constructor
	RoboCopy(){}
	#constructor
	RoboCopy([String]$src,[String]$des,[String]$jid,[String]$ld,[string[]]$wc){
	$this.Source = $src
	$this.Destination = $des
	$this.JobID = $jid
	$this.LogDir = $ld
	$this.WildCards = $wc
	}
	[PSCustomObject]VerifyPaths(){
	return [PSCustomObject]@{
	Source = $(Test-Path -Path $this.Source)
	Destination = $(Test-Path -Path $this.Destination)
	LogDirectory = $(Test-Path -Path $this.LogDir)
	}
	}
	StartRCProcess($source,$target,$params,$logFile,$tag){
	#Save RoboCopy Command
	$MessageData = $('robocopy "{0}" "{1}" {2} {3}' -f $source,$target,$($params -join ' '),$logFile)
	$this.rcCMDs += Write-Information -MessageData $MessageData 6>&1 -Tags $tag | Select-Object *
	#Execute Process
	$rcArgs = "`"$($source)`" `"$($target)`" $params $logFile"
	$rcResult = Start-Process robocopy -ArgumentList $rcArgs -WindowStyle Hidden -PassThru -Wait
	#Save ExitCode
	$this.rcExitCodes += [PSCustomObject]@{
	ExitCode = [RoboCopyExitCodes]$rcResult.ExitCode
	StartTime = $rcResult.StartTime
	ExitTime = $rcResult.ExitTime
	rcCMD = $MessageData
	}
	}
	ExecuteRCCMD($source,$target,$params,$logFile,$tag){
	#Save RoboCopy Command
	$MessageData = $('robocopy "{0}" "{1}" {2} {3}' -f $source,$target,$($params -join ' '),$logFile)
	$this.rcCMDs += Write-Information -MessageData $MessageData 6>&1 -Tags $tag | Select-Object *
	#Execute Robocopy CMD
	$rcArgs = @("$($source)","$($target)",$params,$logFile)
	robocopy @rcArgs
	}
	Mirror(){
	$tag = @('Mirror',$this.JobID)
	$params = New-Object System.Collections.Arraylist
	$params.AddRange(@('/MIR','/E','/BYTES','/NP','/NDL','/R:1','/W:1'))
	$logFile = '/LOG:{0}\mirror-{1}.log' -f $this.LogDir,$this.JobID
	$this.StartRCProcess($this.Source,$this.Destination,$params,$logFile,$tag)
	#$this.ExecuteRCCMD($this.Source,$this.Destination,$params,$logFile,$tag)
	}
	Move(){
	$tag = @('Move',$this.JobID)
	$params = New-Object System.Collections.Arraylist
	$params.AddRange(@('/COPY:DATS','/DCOPY:T','/SECFIX','/BYTES','/S','/E','/NP','/NDL','/R:1','/W:1','/MOVE'))
	$logFile = '/LOG:{0}\move-{1}.log' -f $this.LogDir,$this.JobID
	#$this.StartRCProcess($this.Source,$this.Destination,$params,$logFile,$tag)
	$this.ExecuteRCCMD($this.Source,$this.Destination,$params,$logFile,$tag)
	}
	RollBack(){
	$tag = @('RollBack',$this.JobID)
	$params = New-Object System.Collections.Arraylist
	$params.AddRange(@('/COPY:DATS','/DCOPY:T','/SECFIX','/BYTES','/S','/E','/NP','/NDL','/R:1','/W:1','/MOVE'))
	$logFile = '/LOG:{0}\rollback-{1}.log' -f $this.LogDir,$this.JobID
	#$this.StartRCProcess($$this.Source,$this.Destination,$params,$logFile,$tag)
	$this.ExecuteRCCMD($this.Destination,$this.Source,$params,$logFile,$tag)
	}
	Sync(){
	$tag = @('Sync',$this.JobID)
	#Excluded Files & Directories
	$XF = @(
	'/XF'
	'thumbs.db'
	'~*.*'
	'*.pst'
	'desktop.ini'
	'*.lnk'
	)
	$XD = @(
	'/XD'
	"`$Recycle.bin"
	'Boot Recycler'
	'IECompatCache'
	'IEDownloadHistory'
	'Cookies'
	'WINDOWS'
	'PrivacIE'
	"`"System Volume Information`""
	)
	$Excluded = "$($XF -join ' ') $($XD -join ' ')"
	$params = New-Object System.Collections.Arraylist
	$params.AddRange(@($($this.WildCards),'/COPY:DATS','/SECFIX','/BYTES','/S','/PURGE','/E','/NP','/NDL','/R:1','/W:1'))
	$logFile = '/LOG:{0}\sync-{1}.log' -f $this.LogDir,$this.JobID
	#Save RoboCopy Command
	$arrMessageDataInput = @(
	$this.Source
	$this.Destination
	$($params -join ' ')
	$($this.Options -join ' ')
	$Excluded
	$logFile
	)
	$MessageData = $('robocopy "{0}" "{1}" {2} {3} {4} {5}' -f $arrMessageDataInput )
	$this.rcCMDs += Write-Information -MessageData $MessageData 6>&1 -Tags $tag | Select-Object *
	#Execute Robocopy CMD
	$rcArgs = @("$($this.Source)","$($this.Destination)",$params,$XF,$XD,$logFile)
	robocopy @rcArgs
	}
	GetListSource(){
	$tag = @('ListSRC',$this.JobID)
	$params = New-Object System.Collections.Arraylist
	$params.AddRange(@($($this.WildCards),'/L','/S','/E', '/BYTES','/FP','/NC','/NDL','/TS','/R:0','/W:0'))
	$logFile = '/LOG:{0}\listSRC-{1}.log' -f $this.LogDir,$this.JobID
	$this.StartRCProcess($this.Source,'NULL',$params,$logFile,$tag)
	#$this.ExecuteRCCMD($this.Source,$this.Destination,$params,$logFile,$tag)
	}
	GetListDestination(){
	$tag = 'ListDES'
	$params = New-Object System.Collections.Arraylist
	$params.AddRange(@($($this.WildCards),'/L','/S','/E','/BYTES','/FP','/NC','/NDL','/TS','/R:0','/W:0'))
	$logFile = '/LOG:{0}\listDES-{1}.log' -f $this.LogDir,$this.JobID
	#$this.StartRCProcess($this.Source,$this.Destination,$params,$logFile,$tag)
	$this.ExecuteRCCMD($this.Destination,'NULL',$params,$logFile,$tag)
	}
	static [PSCustomObject]GetLogSummary([String]$rcLogFile){
	filter Get-CapacitySize {
	'{0:N2} {1}' -f $(
	if ($_ -lt 1kb) { $_, 'Bytes' }
	elseif ($_ -lt 1mb) { ($_/1kb), 'KB' }
	elseif ($_ -lt 1gb) { ($_/1mb), 'MB' }
	elseif ($_ -lt 1tb) { ($_/1gb), 'GB' }
	elseif ($_ -lt 1pb) { ($_/1tb), 'TB' }
	else { ($_/1pb), 'PB' }
	)
	}
	$rcLogSummary = [PSCustomObject]@{
	Start = $null
	End = $null
	LogFile = $null
	Source = $null
	Destination = $null
	TotalDirs = $null
	CopiedDirs = $null
	FailedDirs = $null
	TotalFiles = $null
	CopiedFiles = $null
	FailedFiles = $null
	TotalBytes = $null
	CopiedBytes = $null
	FailedBytes = $null
	TotalTimes = $null
	Speed = $null
	}
	$rcLogSummary.LogFile = $rcLogFile.Split('\')[-1].ToLower()
	$logFileContent = Get-Content $rcLogFile -Raw
	[regex]$regex_Start = 'Started\s:\s+(?<StartTime>.+[^\n\r])'
	if ($logFileContent -match $regex_Start){
	$rcLogSummary.Start = $Matches['StartTime']
	}
	[regex]$regex_End = 'Ended\s:\s+(?<EndTime>.+[^\n\r])'
	if ($logFileContent -match $regex_End){
	$rcLogSummary.End = $Matches['EndTime']
	}
	[regex]$regex_Source = 'Source\s:\s+(?<Source>.+[^\n\r])'
	if($logFileContent -match $regex_Source){
	$rcLogSummary.Source = $Matches['Source'].Tolower()
	}
	[regex]$regex_Target = 'Dest\s:\s+(?<Target>.+[^\n\r])'
	if($logFileContent -match $regex_Target){
	$rcLogSummary.Destination = $Matches['Target'].ToLower()
	}
	[regex]$regex_Dirs = 'Dirs\s:\s+(?<TotalDirs>\d+)\s+(?<CopiedDirs>\d+)(?:\s+\d+){2}\s+(?<FailedDirs>\d+)\s+\d+'
	if ($logFileContent -match $regex_Dirs){
	$rcLogSummary.TotalDirs = [int]$Matches['TotalDirs']
	$rcLogSummary.CopiedDirs = [int]$Matches['CopiedDirs']
	$rcLogSummary.FailedDirs = [int]$Matches['FailedDirs']
	}
	[regex]$regex_Files = 'Files\s:\s+(?<TotalFiles>\d+)\s+(?<CopiedFiles>\d+)(?:\s+\d+){2}\s+(?<FailedFiles>\d+)\s+\d+'
	if ($logFileContent -match $regex_Files){
	$rcLogSummary.TotalFiles = [int]$Matches['TotalFiles']
	$rcLogSummary.CopiedFiles = [int]$Matches['CopiedFiles']
	$rcLogSummary.FailedFiles = [int]$Matches['FailedFiles']
	}
	[regex]$regex_Speed = 'Speed\s:\s+(?<Speed>.+\/min)'
	if ($logFileContent -match $regex_Speed){
	$rcLogSummary.Speed = $Matches['Speed']
	}
	$arrBytes = @(
	'Bytes\s:\s+(?<TotalBytes>(\d+\.\d+\s)[bmg]|\d+)\s+' #TotalBytes
	'(?<CopiedBytes>\d+.\d+\s[bmg]|\d+)\s+' #CopiedBytes
	'(?:(\d+.\d+\s[bmg]|\d+)\s+){2}' #Skip two
	'(?<FailedBytes>\d+.\d+\s[bmg]|\d+)' #FailedBytes
	)
	[regex]$regex_Bytes = -join $arrBytes
	if ($logFileContent -match $regex_Bytes){
	$rcLogSummary.TotalBytes = [int64]$Matches['TotalBytes'] | Get-CapacitySize
	$rcLogSummary.CopiedBytes = [int64]$Matches['CopiedBytes'] | Get-CapacitySize
	$rcLogSummary.FailedBytes = [int64]$Matches['FailedBytes'] | Get-CapacitySize
	}
	[regex]$regex_Times = 'Times\s:\s+(?<TotalTimes>\d+:\d+:\d+)'
	if ($logFileContent -match $regex_Times){
	$rcLogSummary.TotalTimes = $Matches['TotalTimes']
	}
	return $rcLogSummary
	}
	[String]GetRoboCopyCMD(){
	$paramRoboCopy = @(
	$this.Source
	$this.Destination
	$($this.WildCards -join ' ')
	$this.Options
	$('/LOG:{0}\{1}.log' -f $this.LogDir,$this.JobID)
	)
	return $('robocopy "{0}" "{1}" {2} {3} {4}' -f $paramRoboCopy)
	}
	}

view raw class-Robocopy.ps1 hosted with ❤ by GitHub

Here what’s happening in the List methods:

GetListSource() is using $this.StartRCProcess to generate a list of $this.Source using some default option. While writing I noticed that I forgot to add the wildcards to the parameter. All I had to do was add it!. I added it at the beginning so it lines up accordingly… Robocopy is fickle like that…  GetListDestination does the same only it uses ExecuteRCCMD instead.

Here’s what’s going on in StartRCProcess and ExcuteRCCMD

Both StartRCProcess and ExcuteRCCMD will save the robocopy command using Write-Information. I’m loving Write-Information more and more! StartRCProcess saves the exitcode with some extra information. Here’s where the robocopy exitcode enumeration came in handy! ExecuteRCCMD will run robocopy with the specified arguments. Truth be told I’m more partial to the ExecuteRCCMD method. I added the StartRCProcess more for demo purposes and finally getting to use my Robocopy exitcode enumeration!

For Mirror(),Move() and RollBack(), I omitted the Wildcards. These methods all or nothing in my opinion. If omitted, . will be the default.

Sync() had me going for a while. I still have some issues with Options. For now Sync() uses some default switches. Like I said work in progress…

Quite a bit of code, so does it work? Here’s some code to play with. be sure to edit the source,destination and logdir to your liking. Just remember that robocopy is unforgiving so make sure not to use it of production folders!

#region Main
$rc = [RoboCopy]::New('C:\scripts\move','C:\temp\move','rc-0001','c:\scripts\log',@('*.*'))

#Run RoboCopy methods
$rc.Sync()
$rc.GetListSource()
$rc.GetListDestination()

#Get RoboCopy LogFile Summary
[RoboCopy]::GetLogSummary("$env:HOMEDRIVE\scripts\log\listSRC-rc-0001.log")
[RoboCopy]::GetLogSummary("$env:HOMEDRIVE\scripts\log\listDES-rc-0001.log")
[RoboCopy]::GetLogSummary("$env:HOMEDRIVE\scripts\log\sync-rc-0001.log")

#Get RoboCopy executed CMDs
$rc.rcCMDs
$rc.rcExitCodes
#endregion

First I instantiate the class with arguments. I then run the methods Sync(),GetListSource() and GetListDestination(). Up next is retrieve the LogSummaries from the methods. Here’s a screenshot of the Sync LogSummary

I did a select of $rc.rcCMDs to give you an idea what is being stored

Only want ListDES?

$rc.rcCMDs |
Where-Object{$_.Tags -contains 'ListDes'} |
Select-Object -Property Time*,Tag*,Mess*

The information stream is quite handy! The tags will definitely come in handy when you need to filter on action verb or job ID.

The methods GetListSource() & Mirror() both make use of StartRCProcess(), so let’s see what $rc.rcExitcode has shall we?

Nice!

This is by far my longest blog, if you made this far then… Congratulations! There’s still so much to discover when it comes to classes.

Classes definitely  makes your code look and feel more like a developer 😉 . I feel more comfortable giving a colleague this class than a bunch of scripts. In Richard’s article he’s using both classes and modules. There are sure to be some gotcha’s… Do you go all in with classes or only partial?

I’m hoping that the community can shed some light on the subject. I’d love to hear from you guys on how to improve on this… Let’s make this year, a year of PowerShell Classes! 😛

Hope it’s worth something to you…

Ttyl,

Urv

A simple logger using PowerShell Class

‘Sup PSHomies,

At our last DuPSUG meeting, Jaap Brassers did a short Demo on the latest addition to PowerShell Streams, Information. How did I miss this?

So what’s so great about the new Information stream? The Information stream solves the Write-Host issue of not sending output to a stream like: error;verbose;warning etc. As such we were told that Write-Host is evil and every time you use it a puppy dies… Who wants that on their conscious right?

Well with the Information stream Write-Host is allowed… no more puppy genocide!

Jaap showed us what the stream output looks like and how to write to the information stream. Here’s what the output looks like

Here are a few properties we can play with: TimeGenerated,Source,User,Computer,Tags and MessageData. You get all of this by writing/redirecting to the information stream. The TimeGenerated property caught my eye, imagine creating a timeline of sorts. While googling (don’t act like it’s just me…) I came across a great article by Jeff Hicks on the subject (Seriously, how did I miss this?) In it he also talked about generating a timeline view… 😉

After I had some time to think about how to make use of this, it dawned on me… You know what else is native to PowerShell v5? Classes! When Classes were introduced in v5, they were another way to write DSC Resources. I’ve always thought that there’s more to classes than meets the eye.

If you’re interested in classes, Richard Siddaway has a great article taking you through each step, worth trying out.

Jaap’s demo gave me the idea to try my hand at a simple logger using classes. Here’s what I came up with…

	Class WriteLog{
	[string]$FileBaseName = 'Temp'
	[string]$LogDirectory = 'C:\Scripts\export'
	[string]$Preference = 'SilentContinue'
	[bool]$Console = $true
	[PSObject[]]$InfoMessages
	#default constructor
	WriteLog(){}
	#constructor
	WriteLog($fbn,$ld){
	$this.FileBaseName = $fbn
	$this.LogDirectory = $ld
	}
	WriteInformation($MessageData){
	$info = $false
	if ($this.Preference -eq 'Continue') { $Info = $true }
	if ($Info) {
	$this.InfoMessages += Write-Information -MessageData $MessageData 6>&1 | Select-Object *
	}
	if($this.Console){
	Write-Information -MessageData $MessageData -InformationAction Continue
	}
	}
	ExportToText(){
	$this.InfoMessages |
	Select TimeGenerated,MessageData |
	Out-File "$($this.LogDirectory)\$($this.FileBaseName).txt" -Encoding utf8 -Force -Append -Width 1000
	}
	ExportToXML(){
	$this.InfoMessages |
	Export-Clixml -Path "$($this.LogDirectory)\$($this.FileBaseName).xml" -Encoding UTF8 -Force
	}
	}

view raw class-WriteLog.ps1 hosted with ❤ by GitHub

Here’s a quick rundown:

The idea is to gather output from the Information stream. Constructors are a way of initiating an object for use (Shout out to Doug Finke for breaking this down for me!)

I “borrowed” Jeff Hicks idea of validating the preference first. This way you can toggle between showing Write-Information and/or Write-Host data. You can use Write-Host for a more colorful experience. Did I already mention that Write-Host is cool again? :-P.  I also added the possibility to show data in the console if you choose to, a verbose action of sorts…

I also added two methods of exporting: text and xml. That’s where LogDirectory and FileBaseName come in. For the text export, I selected TimeGenerated and MessageData for a timeline view (I know I know Jeff Hicks did it first :-P). Export to xml saves InfoMessages in raw format.

Here’s some code to play with.

function Get-PowerShellProcess{
[cmdletbinding()]
param()

Write-Verbose "InformationPreference = $InformationPreference"
$Logger.Preference = $InformationPreference
$Logger.WriteInformation("Starting $($MyInvocation.MyCommand)")

Get-Process -Name *PowerShell*
$Logger.WriteInformation("Finishing $($MyInvocation.MyCommand)")
}

#region Main
#Initiate variable
$Logger = [WriteLog]::New('psProcess','C:\scripts\temp')

#Run with InformationAction. Information will be saved and not shown
Get-PowerShellProcess -InformationAction Continue -Verbose

#Run without InformationAction with Console set to $true
$Logger.Console = $true
Get-PowerShellProcess -Verbose

#Run without InformationAction with Console set to $false
$Logger.Console = $false
Get-PowerShellProcess -Verbose
#endregion

Here are some screenshots of the output

I initiated the object a FileBaseName value ‘psProcess’ and LogDirectory ‘C:\scripts\temp’. Default Preference is ‘SilentContinue’ and no ouput to the console

First up run with action set to continue

$Logger.InfoMessages has redirected data.

When console is set to true we’ll see the Information message without explicitly setting InformationAction to ‘continue’. Using InformationAction will save the Information data to InfoMessages property.

Setting the console preference back to $false stops displaying output to the console

I hope that you were able to follow it all. 2016 was all about Operation Validation for me. I think classes are going to be mainstream in 2017! PowerShell + Classes will definitely give you an edge and not to mention make you feel more like a developer! 😉

The line between Dev and Ops is being blurred…

Hope it’s worth something to you…

Ttyl,

Urv