Snazzy-Up Your PowerShell with a GUI

I’d like to say that I work with virtualization every day, and in a way I do.  Virtually every server in my employer’s environment is virtualized (see what I did there?).

That we are a small team in an SME environment dictates that we are I.T. generalists.  That’s not a curse—that’s variety and opportunity alleviating the mundane.  It’s also an opportunity to automate the mundane. 

For the purposes of user provisioning I wanted to use PowerShell for identity management on a shoestring budget.   As with many things, creating is harder than destroying; this provisioning needs a GUI.  Pick an OU, pick a user/template, and copy with new details.  While that’s how I got to the point of driving a GUI with PowerShell, it’s difficult to effectively convey a company-specific workflow.  So I’ll demonstrate with something virtualization-focused.

With a little bit of Googling I found an older option or two along with .NET-based Windows Presentation Foundation (WPF).  .NET this plus .NET that sounded appealing with me, so I dug in further. 

There are solid posts to be found that give you all that you need.  I’m working against some of my musings, so here I share my journey toward the same end result.

At a higher level the process is relatively simple:

• Generate a GUI form in Extensible Application Markup Language (XAML).
• Load the XAML in PowerShell with some minor (automated) transformations.
• Instantiate the WPF form.
• Create variables for working with our GUI elements.
• Define PowerShell event handlers for each GUI element, incorporating our workflow within.

Generating Your GUI’s XAML

To generate the GUI we need something that will generate XAML that WPF can handle.  Anything from Visual Studio 2010 on up will do here.  I used Visual Studio 2015 Community since it is full featured with an investment of $0.

Open Visual Studio and create a new project.  Choose WPF Application under Visual C# Templates and give it a name.  Any name will do—we only want the XAML which this project will generate.

What you will notice is a blank window in the main center pane, labeled MainWindow.xaml.  The pane below contains the XAML in which we are interested. 

I find it best to turn on the toolbox from the View menu and pin it to the side bar this yields an environment tailored for creating window forms.

Let’s use the toolbox to drag and position a few controls:

• A ComboBox selector for Cluster
• A DataGrid to display VMs within a selected Cluster.
• A Button for launching a selected VM’s console.
• A Label or three for clarity.

While we can add these controls in any order, Visual Studio will set the form’s tab order based on the order of definition.  That’s not a particularly big deal because of a neat Visual Studio feature:  the GUI form is tied to the XAML and the XAML is tied to the GUI form. We can adjust the tab order by re-ordering the text inside the XAML pane copy and paste!

With each control use the properties pane and give it a unique name, which we will  use later to bind to PowerShell variables.  I like to start all label control names with “label_” for easier exclusion from this binding process.

Loading the XAML

All we need from Visual Studio is the XAML, which we will copy and paste into a PowerShell here-string.  The string isn’t perfect for PowerShell processing yet, so we’ll also rework it to take care of these issues and cast as XML:

Instantiating the GUI Form

Next we need to load the PresentationFramework assembly and process our form so that it can be presented:

Creating GUI Variables

We need to be able to work with the controls on form that comprise our GUI, and that means variables that let us get/set values and work with other properties and methods afforded to us by WPF.   

We can do this rather handily in PowerShell by invoking Set-Variable for nodes within the XML that comprises our form.  The iteration of those nodes will return Label controls as well, which we’ll ignore based on giving them a prefix of “Label_”, which was mentioned earlier:

Defining Event Handlers

WPF will send asynchronous signals (events) to our script when the GUI is acted upon.  Examples include when a selection is made, a button is clicked, and when the window is instantiated or destroyed. 

Defining event handler functions in our PowerShell lets us dictate our workflow:

• When the window is created, connect to vCenter, get a list of clusters, and populate the cluster ComboBox.
• When a selection is made in the cluster ComboBox, get a list of cluster VMs and populate the details DataGrid.
• When a VM selection is made in the DataGrid, enable the console Button.
• When the console Button is clicked, launch a vSphere Remote Console window.
• When the window is closed, disconnect from vCenter

Anything is possible, of course.  Here’s our event handlers:

Final Bits

There’s not much left!  Define the vCenter server against which we will operate and display the form:

Reveal

Run this little puppy and off we go.  Pick a cluster from the drop-down to see a list of VMs and click the column headers to if you don’t like it ordered by VM name.  Choose a VM and the console button becomes active so long as the VM state is “PoweredOn.”

What else?

• My error checking and validations are non-existent--Add some.
• Add another button to perform another task.
• Change what VM properties appear in the DataGrid.
• Do something else and have fun with it!

Full Code

You can grab the full code from here.

Proper Attribution is Proper

• Stephen Owen’s XAML to GUI
• The Scripting Guys’ I've Got a PowerShell Secret: Adding a GUI to Scripts