The Winner is ... Wait-Object

I decided I like the for where is the object i was waiting for was returned, I would pass the InputObject on down the pipeline but if not Write-Error and return null. This allows me to 1. let the command run and do a null check on the return value to decide if the script should continue

Example 1.
$returned = $false | Wait-Object -ScriptBlock {Test-Path C:\Wait\For\Removal } -TimeOut 10

if($returned -ne $null) {
  #do something
}
else {
  #do something else
}

Also this lets me use a try / catch  with the ErrorAction set to stop causing the the catch to trigger in event of failure.

Example 2.
try {
  $returned = $false | Wait-Object -ScriptBlock {Test-Path C:\Wait\For\Removal } -TimeOut 10 -ErrorAction Stop
}
catch {
  exit
}

Here is the Code:

Wait-Object Function Takes Place of Wait-ValueReturned

I previously posted a function Wait-ValueReturned but is did not seem like it flowed with the rest of PowerShell so I re factored the code into Wait-Object but I am not sure about how the command should return. I have considered first return bool from the command to indicate success, which means the command will always return true or false. My other option is to return to object that was being waited on if success and return error record on fail. here is examples of both. Which makes more sense to use in a script

 Returning Bool:

 Returning object or error:

New Utility Function Wait-ValueReturned

I Just need a way to block a scripts execution while I wait on some command to return the correct value. So I created this little function to allow me to pass the command or commands and what i expect back and let it handle the work instead of littering my scripts main body with a bunch of loops, if / else, and sleeps, I can use this to encapsulate all that into a clean function.

PowerShell Objects - Import-Module Pt 3

The -AsCustomObject switch on the New-Module Cmdlet is also available in the Import-Module which opens up a whole new world of using PowerShell objects and modules. Imagine you need to import 2 modules to work with Hyper-V and VMWare in your script but after importing them in that order you notice that Get-VM for VMWare is visiable and the Get-VM command from the Hyper-v module is hidden. The are a couple of way to handle modules with command that are the same name. One would be to use the get-command command to invoke the correct command from the correct module. My perfered way is to use the -AsCustomObject switch when importing the modules. This way I hsave the modules and there commands neatly reference in variable so that it is easy to tell which module the command i am executng is going to run against. Example (sudo-code module names may net be correct)

.

ISESteriods makes ISE Professional Scripting IDE

PowerShell Talk at Silicon Valley Code Camp

Credential IO Script

This is an updated version of the Import and Export Credential functions that store the creds in a json format versus the clixml format used by the original created by the guys @ powertips & powershell.com. I also store them in a known location and I use a string for a look up key to store and retrieve them. This allows me to use EFS to further secure the files on the drive. Enjoy!!

PowerShell Objects - New-Module Cmdlet Pt. 2

If you remember Last we talked we had an Object with 4 Public NoteProperties, 1 Public ScriptMethod, and 1 private member. Now if we look at our ScriptMethod it returns a string unless -AsBool is passed, this can cause issues, like hindering ISE's ability to display Intellisense for the method / function because we are unable to decorate our function with the [OutputType] attribute.

To correct this and make the code much more standardized i want to expose the IsPublished variable since it contains the boolean value indicating if the BlogPost has been published. Also notice that the value of the IsPublished value is being controlled by the object and that is important because we don't want someone or something else to come and set the value to false after we have successfully published the article to the web. So we need to set this Variable to be Read-Only, There are a couple of different ways to do this in PowerShell. First way is use the Set-Variable Cmdlet like so.

Lets run this code again and update the object that $BlogPostInfo contains a reference to and pipe it to Get-Member.

IsPublished is now listed as a Public NoteProperty and you can see we have retrieved its value, but what about setting it.

OK we see it's current value is set to $false and we receive and error when we try to set it's value with a simple assignment statement. So we are good to go, right, maybe lets see. first modify Get-PublishingStatus function so it has and empty param block and add the [OtutputType([System.String])] attribute between the Param block and the [CmdletBinding(PositionalBinding)] attribute, this lets ISE and other PS Editors and Tools what to expect a call to the function to return. Modify the Process block, remove the check for $AsBool and its surrounding context, leaving just a check to $this.IsPublished and returning the appropriate string value. The $this variable is a powershell automatic variable that references the current object, it is only available inside object body or a scriptblock. now we add a function definition for Publish-BlogPost that returns a bool on successful publishing, it also sets the IsPublished NoteProperty to $true since we are publishing the Post. Add the new function to the list of functions exported by the object.

Now we rerun the code to update our $BlogPostInfo variable with a reference to our newly modified object.

OK as we can see IsPublished is $false then we call Publish-BlogPost() which appears to finish successfully but when we check IsPublished  again it is still $false, after looking a the $Error variable we see that an error happened when trying to update IsPublished Value it failed because it is ReadOnly which means that the value assigned to it cannot change after assignment, so that is not what we want. So like I said there are a couple of ways to get the desired behavior and interestingly enough they both involve using the same Cmdlet Add-Member. Keeping the code we have now and changing the Set-Variable call to a Add-Member call.

Running and Inspecting this code we find it works. IsPublished is now updated when the Publish-BlogPost method is called.

Awesome we have a ReadOnly NoteProperty, well no we don't because we did not update the member IsPublished we overwrote it's definition and replaced it with a new version that did not include the ReadOnly option so now the variable is free to be updated by any object, process, etc. Also another problem is that anytime we want to change its value we have to overwrite its implementation in memory and when overwriting (overriding) the member when need to define it exactly the same each time or run into issues of scoping and accessibility. Remember i said there was another way using add-member and it is to change the formal definition of the IsPublished member. I removed the current variable altogether. I pipe the object to Add-Member and add a script property that contains only a get scriptblock that returns $False and the modified the Publish-BlogPost Script Method to Call add-member and add the same script property but this tme it returns $True.

Next Time will will talk of further uses of the New-Module Cmdlet pertaining to Object creation.

PowerShell Object Creation – New-Module Pt. 1

I have seen quite a few posts on creating custom objects in PowerShell, comparing it to techniques used in languages such as JavaScript but most use some variation of defining an object literal using Select-Object, New-Object, or a HashTable that is cast to PSCustomObject which are all fine and great ways of creating a one off Property Bag. These posts seem skip the most powerful way to define objects in PowerShell and that is to use the New-Module Cmdlet. The New-Module Cmdlet has a switch –AsCustomObject and a parameter –ScriptBlock that allow you to define a custom object. Inside the ScriptBlock every Variable defined is a property and you control whether it’s public or private by using the Export-ModuleMember Cmdlet if you export a variable it is public otherwise it is private. The most powerful part comes in the form that your functions defined inside the module ScriptBlock become the methods and the parameters define the methods arguments for the object and again the visibility is controlled by the Export-ModuleMember Cmdlet. The Functions can be Advanced Functions with Parameter Validation and Comment Based Help. Lets look at some code.



Running this code will provide us with a local variable $BlogPostInfo that we can inspect.






We can see that the variable has the PSCustomObject type and are variable are now NoteProperties and our function is now a ScriptMethod. Also notice that our IsPublished variable is not included in the list because it is private, we did not export it. Next time we will cover some advanced topics such as defining ScriptProperties and method overriding.


$Until_Then = Good-Times | Get-Command