Getting Creative: a Bespoke Solution for Feature Update Deployments

This is the first blog post in what I hope will be a series of posts demonstrating several custom solutions I created for things such as feature update deployments, managing local admin password rotation, provisioning Windows 10 devices, managing drive mappings and more. My reasons for creating these solutions was to overcome some of the current limitations in existing products or processes, make things more cloud-first and independent of existing on-prem infrastructure where possible, and to more exactly meet the requirements of the business.

Although I will try to provide a generalised version of the source code where possible, I am not providing complete solutions that you can go ahead and use as is. Rather my intention is to inspire your own creativity, to give working examples of what could be done if you have the time and resource, and to provide source code as a reference or starting point for your own solutions should you wish to create them!

Someone asked me recently how we deploy feature updates and it was a difficult question to answer other than to say we use a custom-built process. Having used some of the existing methods available (ConfigMgr Software Updates, ConfigMgr custom WaaS process, Windows Update for Business) we concluded there were shortcomings in each of them, and this provided inspiration to create our own, customized process to give us the control, reliability, user experience and reporting capability that we desired. Don’t get me wrong – I am not saying these methods aren’t good – they just couldn’t do things exactly the way we wanted.

So I set out to create a bespoke process – one that we could customize according to our needs, that was largely independent of our existing Configuration Manager infrastructure and that could run on any device with internet access. This required making use of cloud services in Azure as well as a lot of custom scripting! In this blog, I’ll try to cover what I did and how it works.

User Experience

First, let’s look at the end user experience of the feature update installation process – this was something key for us, to improve the user experience keeping it simple yet informative, and able to respond appropriately to any upgrade issues.

Once the update is available to a device, a toast notification is displayed notifying the user that an update is available. Initially, this displays once a day and automatically dismisses after 25 seconds. (I’ve blanked out our corporate branding in all these images)

We use a soft deadline – ie the update is never forced on the user. Enforcing compliance is handled by user communications and involvement from our local technicians. With one week left before the deadline, we increase the frequency of the notifications to twice per day.

If the deadline has passed, we take a more aggressive approach with the notifications, modifying the image and text, displaying it every 30 minutes and it doesn’t leave the screen unless the user actions or dismisses it.

The update can be installed via a shortcut on the desktop, or in the last notification it can be initiated from the notification itself.

Once triggered, a custom UI is displayed introducing the user to the update and what to expect.

When the user clicks Begin, we check that a power adapter is connected and no removable USB devices are attached – if they are, we prompt to the user to remove them first.

The update runs in three phases or stages – these correspond to the PreDownload, Install and Finalize commands on the update (more on that later). The progress of each stage is polled from the registry, as is the Setup Phase and Setup SubPhase.

Note that the user cannot cancel the update once it starts and this window will remain on the screen and on top of all other windows until the update is complete. The user can click the Hide me button, and this will shrink the window like so:

This little window also cannot be removed from the screen, but it can be moved around and is small enough to be unobtrusive. When the update has finished installing, or when the user clicks Restore, the main window will automatically display again and report the result of the update.

The colour scheme is based on Google’s material design, by the way.

If the update failed during the online phase, the user can still initiate the update from the desktop shortcut but toast notifications will no longer display as reminders. The idea is that IT can attempt to remediate the device and run the update again after.

If successful, the user can click Restart to restart the computer immediately. Then the offline phase of the upgrade runs, where you see the usual light blue screen and white Windows update text reporting that updates are being installed.

Once complete, the user will be brought back to the login screen, and we won’t bother them anymore.

If the update rolled back during the offline phase, we will detect this next time they log in and notify them one time:

Logging and Reporting

The entire update process is logged right from the start to a log file on the local machine. We also send ‘status messages’ at key points during the process and these find their way to an Azure SQL database which becomes the source for reporting on update progress across the estate (more on this later).

A PowerBI report gives visual indicators of update progress as well as a good amount of detail from each machine including update status, whether it passed or failed readiness checks and if failed, why, whether it passed the compatibility assessment, if it failed the assessment or the install we give the error code, whether any hard blocks were found, setup diag results (2004 onward), how long the update took to install and a bunch of other stuff we find useful.

Since 2004 though, we have starting inventorying certain registry keys using ConfigMgr to give us visibility of devices that won’t upgrade because of a Safeguard hold or other reason, so we can target the upgrade only to devices that aren’t reporting any known compatibility issues.

If a device performs a rollback, we can get it to upload key logs and registry key dumps to an Azure storage account where an administrator can remotely diagnose the issue.

How does it work?

Now lets dive into the process in more technical detail.

Deployment Script

The update starts life with a simple PowerShell script that does the following:

  • Creates a local directory to use to cache content, scripts and logs etc
  • Temporarily stores some domain credentials in the registry of the local SYSTEM account as encrypted secure strings for accessing content from a ConfigMgr distribution point if necessary (more on this later)
  • Downloads a manifest file that contains a list of all files and file versions that need to be downloaded to run the update. These include scripts, dlls (for the UI), xml definition files for scheduled tasks etc
  • Each file is then downloaded to the cache directory from an Azure CDN
  • 3 scheduled tasks are then registered on the client:
    • A ‘preparer’ task which runs prerequisite actions
    • A ‘file updater’ task which keeps local files up-to-date in case we wish to change something
    • A ‘content cleanup’ task which is responsible for cleaning up in the event the device gets upgraded through any means
  • A ‘status message’ is then sent as an http request, creating a new record for the device in the Azure SQL database

This script can be deployed through any method you wish, including Configuration Manager, Intune or just manually, however it should be run in SYSTEM context.

Content

All content needed for the update process to run is put into a container in a storage account in Azure. This storage account is exposed via an Azure Content Delivery Network (CDN). This means that clients can get all the content they need directly from an internet location with minimal latency no matter where they are in the world.

Feature Update Files

The files for the feature update itself are the ESD file and WindowsUpdateBox.exe that Windows Update uses. You can get these files from Windows Update, WSUS, or as in our case, from Configuration Manager via WSUS. We simply download the feature updates to a deployment package in ConfigMgr and grab the content from there.

You could of course use an ISO image and run setup.exe, but the ESD files are somewhat smaller in size and are sufficient for purpose.

The ESD files are put into the Azure CDN so the client can download them from there, but we also allow the client the option to get the FU content from a local ConfigMgr distribution point if they are connected to the corporate network locally. Having this option allows considerably quicker content download. Since IIS on the distribution points is not open to anonymous authentication, we use the domain credentials stamped to the registry to access the DP and download the content directly from IIS (credentials are cleaned from the registry after use).

Status Messages

Similar to how ConfigMgr sends status message to a management point, this solution also send status messages at key points during the process. This works by using Azure Event Grid to receive the message sent from the client as an http request. The Event Grid sends the message to an Azure Function, and the Azure Function is responsible to update the Azure SQL database created for this purpose with the current upgrade status of the device. The reason for doing it this way is that sending an http request to Event Grid is very quick and doesn’t hold up the process. Event Grid forwards the message to the Azure Function and can retry the message in the case it can’t get through immediately (although I’ve never experienced any failures or dead-lettering in practice). The Azure Function uses a Managed Identity to access the SQL database, which means the SQL database never needs to be exposed outside of its sandbox in Azure, and no credentials are needed to update the database.

We then use PowerBI to report on the data in the database to give visibility of where in the process every device is, if there are any issues that need addressing and all the stats that are useful for understanding whether devices get content from Azure or a local DP, what their approximate bandwidth is, how long downloads took, whether they were wired or wireless, make and model, upgrade time etc.

Preparation Script

After the initial deployment script has run, the entire upgrade process is driven by scheduled tasks on the client. The first task to run is the Preparation script and this attempts to run every hour until successful completion. This script does the following things:

  • Create the registry keys for the upgrade. These keys are stamped with the update progress and the results of the various actions such as pre-req checks, downloads etc. When we send a ‘status message’ we simply read these keys and send them on. Having progress stamped in the local registry is useful if we need to troubleshoot on the device directly.
  • Run readiness checks, such as
    • Checking for client OS
    • Checking disk space
  • Check for internet connectivity
  • Determine the approximate bandwidth to the Azure CDN and measure latency. This is done by downloading a 100MB file from the CDN and timing the download and using ‘psping.exe’ to measure latency. From this, we can calculate an approximate download time for the main ESD file.
  • Determine if the device is connected by wire or wireless
  • Determine if the device is connected to the corporate network
  • If the device is on the corporate network, we check latency to all the ConfigMgr distribution points to determine which one will be the best DP to get content from
  • Determine whether OS is business or consumer and which language. This helps us figure out which ESD file to use.
  • Download WindowsUpdateBox.exe and verify the hash
  • Download the feature update ESD file and verify the hash
    • Downloads of FU content is done using BITS transfers as this proved the most reliable method. Code is added to handle BITS transfer errors to add resilience.
  • Assuming all the above is done successfully, the Preparation task will be disabled and the PreDownload task created.

PreDownload Script

The purpose of this script is to run the equivalent of a compatibility assessment. When using the ESD file, this is done with the /PreDownload switch on WindowsUpdateBox.exe. Should the PreDownload fail, the error code will be logged to the registry. Since 2004, we also read the SetupDiag results and stamp these to the registry. We also check the Compat*.xml files to look for any hard blocks and if found, we log the details to the registry.

If the PreDownload failed, we change the schedule of the task to run twice a week. This allows for remediation to be performed on the device before attempting the PreDownload assessment again.

If the PreDownload succeeds, we disable the PreDownload task and create two new ones – a Notification task and an Upgrade task.

We also create a desktop shortcut that the user can use to initiate the upgrade.

Notification Script

The Notification script runs in the user context and displays toast notifications to notify the user that the upgrade is available, what the deadline is and how to upgrade, as already mentioned.

Upgrade Script

When the user clicks the desktop shortcut or the ‘Install now’ button on the toast notification, the upgrade is initiated. Because the upgrade needs to run with administrative privilege, the only thing the desktop shortcut and toast notification button does is to create an entry in the Application event log. The upgrade scheduled task is triggered when this event is created and the task runs in SYSTEM context. The UI is displayed in the user session with the help of the handy ServiceUI.exe from the MDT toolkit.

Upgrade UI

The user interface part of the upgrade is essentially a WPF application coded in PowerShell. The UI displays some basic upgrade information for the user and once they click ‘Begin’ we run the upgrade in 3 stages:

  1. PreDownload. Even though we ran this already, we run again before installing just to make sure nothing has changed since, and it doesn’t take long to run.
  2. Install. This uses the /Install switch on WindowsUpdateBox.exe and runs the main part of the online phase of the upgrade.
  3. Finalize. This uses the /Finalize switch and finalizes the update in preparation for a computer restart.

The progress of each of these phases is tracked in the registry and displayed in the UI using progress bars. If there is an issue, we notify the user and IT can get involved to remediate.

If successful, the user can restart the computer immediately or a later point (though we discourage this!). We don’t stop the user from working while the upgrade is running in the online phase and we allow them to partially hide the upgrade window so the upgrade does not hinder user productivity (similar to how WUfB installs an update in the background.)

After the user restarts the computer, the usual Windows Update screens take over until the update has installed and the user is brought to the login screen again.

Drivers and Stuff

We had considered upgrading drivers and even apps with this process, as we did for the 1903 upgrade, however user experience was important for us and we didn’t want the upgrade to take any longer than necessary, so we decided not to chain anything onto the upgrade process itself but handle other things separately. That being said, because this is a custom solution it is perfectly possible to incorporate additional activities into it if desired.

Rollback

In the event the that OS was rolled back during the offline phase, a scheduled task will run that will detect this and raise a toast notification to inform the user. We have a script that will gather logs and data from the device and upload it to a storage account in Azure where an administrator can remotely diagnose the issue. I plan to incorporate that as an automatic part of the process in a future version.

Updater Script

The solution creates an Updater scheduled task which runs once per day. The purpose of this task is to keep the solution up to date. If we want to change something in the process, add some code to a file or whatever is necessary, the Updater will take care of this.

It works by downloading a manifest file from the Azure CDN. This file contains all the files used by the solution with their current versions. If we update something, we upload the new files to the Azure storage account, purge them from the CDN and update the manifest file.

The Updater script will download the current manifest, detect that something has changed and download the required files to the device.

Cleanup Script

A Cleanup task is also created. When this task detects that the OS has been upgraded to the required version, it will remove all the scheduled tasks and cached content to leave no footprint on the device other than the log file and the registry keys.

Source Files

You can find a generalised version of the code used in this solution in my Github repo as a reference. As mentioned before though, there are many working parts to the solution including the Azure services and I haven’t documented their configuration here.

Final Comments

The main benefit of this solution for us is that it is completely customised to our needs. Although it is relatively complex to create, it is also relatively easy to maintain as well as adapt the solution for new W10 versions. We do still take advantage of products like ConfigMgr to allow devices to get content from a local DP if they are corporate connected, and ConfigMgr / Update Compliance / Desktop Analytics for helping us determine device compatibility and ConfigMgr or Intune to actually get the deployment script to the device. We also make good use of Azure services for the status messages and the cloud database, as well as PowerBI for reporting. So the solution still utilizes existing Microsoft products while giving us the control and customisations that we need to provide a better upgrade experience for our users.

Windows 10 Upgrade Splash Screen – Take 2

Recently I tweeted a picture of the custom Windows 10-style splash screen I’m using in an implementation of Windows as a Service with SCCM (aka in-place upgrade), and a couple of people asked for the code, so here it is!

A while ago a blogged about a custom splash screen I created to use during the Windows 10 upgrade process. Since then, I’ve seen some modifications of it out there, including that of Gary Blok, where he added the Windows Setup percent complete which I quite liked. So I made a few changes to the original code as follows:

  • Added a progress bar and percentage for the Windows Setup percent complete
  • Added a timer so the user knows how long the upgrade has been running
  • Prevent the monitors from going to sleep while the splash screen is displayed
  • Added a simple way to close the splash screen in a failure scenario by setting a task sequence variable
  • Re-wrote the WPF part into XAML code

Another change is that I call the script with ServiceUI.exe from the MDT toolkit instead of via the Invoke-PSScriptasUser.ps1 as this version needs to read task sequence variables so must run in the same context as the task sequence.

I haven’t added things like looping the text, or adding TS step names as I prefer not to do that, but check out Gary’s blog if you want to know how.

To use this version, download the files from my Github repo. Make sure you download the v2 edition. Grab the ServiceUI.exe from an MDT installation and add it at top-level (use the x64 version of ServiceUI.exe if you are deploying 64-bit OS). Package these files in a package in SCCM – no program needed.

To call the splash screen, add a Run Command Line step to your upgrade task sequence and call the main script via Service UI, referencing the package:

ServiceUI.exe -process:Explorer.exe %SYSTEMROOT%\System32\WindowsPowershell\v1.0\powershell.exe -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass -File "Show-OSUpgradeBackground.ps1"

To close the screen in a failure scenario, I add 3 steps as follows:

The first step kills the splash screen simply by setting the task sequence variable QuitSplashing to True. The splash screen code will check for this variable and initiate closure of the window when set to True.

The second step just runs a PowerShell script to wait 5 seconds for the splash screen to close

The last step restores the taskbar to the screen

For that step, run the following PowerShell code:

# Thanks to https://stackoverflow.com/questions/25499393/make-my-wpf-application-full-screen-cover-taskbar-and-title-bar-of-window
$Source = @"
using System;
using System.Runtime.InteropServices;

public class Taskbar
{
    [DllImport("user32.dll")]
    private static extern int FindWindow(string className, string windowText);
    [DllImport("user32.dll")]
    private static extern int ShowWindow(int hwnd, int command);

    private const int SW_HIDE = 0;
    private const int SW_SHOW = 1;

    protected static int Handle
    {
        get
        {
            return FindWindow("Shell_TrayWnd", "");
        }
    }

    private Taskbar()
    {
        // hide ctor
    }

    public static void Show()
    {
        ShowWindow(Handle, SW_SHOW);
    }

    public static void Hide()
    {
        ShowWindow(Handle, SW_HIDE);
    }
}
"@
Add-Type -ReferencedAssemblies 'System', 'System.Runtime.InteropServices' -TypeDefinition $Source -Language CSharp

# Restore the taskbar
[Taskbar]::Show()

ConfigMgr Client TCP Port Tester

This is a little tool I created for testing the required TCP ports on SCCM client systems. It will check that the required inbound ports are open and that the client can communicate to its management point, distribution point and software update point on the required ports. It also includes a custom port checker for testing any inbound or outbound port.

The default ports are taken from the Microsoft documentation, but these can be edited in the case that non-default ports are being used, or additional ports need to be tested.

The tool does not currently test UDP ports.

Requirements

  • Windows 8.1 + / Windows Server 2012 R2 +
  • PowerShell 5
  • .Net Framework 4.6.2 minimum

Download

Download from the GitHub.

Usage

To use the tool, extract the ZIP file, right-click the ‘ConfigMgr Client TCP Port Tester.ps1′ and run with PowerShell.

Checking Inbound Ports

Select Local Ports in the drop-down box and click GO to test the required inbound ports.

Checking Outbound Ports

Select the destination in the drop-down box (ie management point, distribution point, software update point).

Enter the destination server name if not populated by the defaults and click GO. The tool will test ICMP connectivity first, then port connectivity.

Custom Port Checking

To test a custom port, select Custom Port Test from the drop-down box. Enter the port number, direction (ie Inbound or Outbound) and destination (Outbound only). Click Add to add the test to the grid. You can add several tests. Click GO.

Adding Default Servers

You can pre-populate server names by editing the Defaults.xml file found in the defaults directory. For example, to add a default management point:

<ConfigMgr_Port_Tester>
  <ServerDefaults>
    <ManagementPoint>
      <Value>SCCMMP01</Value>
    </ManagementPoint>

Editing / Adding Default Ports

You can also edit, add or remove the default ports in the Defaults.xml file. For example, to add port 5985 in the default local port list:

<PortDefaults>
  <LocalPorts>
    <Port Name="80" Purpose="HTTP Communication"/>
    <Port Name="443" Purpose="HTTPS Communication"/>
    <Port Name="445" Purpose="SMB"/>
    <Port Name="135" Purpose="Remote Assistance / Remote Desktop"/>
    <Port Name="2701" Purpose="Remote Control"/>
    <Port Name="3389" Purpose="Remote Assistance / Remote Desktop"/>
    <Port Name="5985" Purpose="WinRM"/>
  </LocalPorts>

Source Code

Source code can be found in my GitHub repo.

New Tool: Delivery Optimization Monitor

Delivery Optimization Monitor is a tool for viewing Delivery Optimization data on the local or a remote PC.

It is based on the built-in Delivery Optimization UI in Windows 10 but allows you to view data graphically from remote computers as well.

The tool uses the Delivery Optimization PowerShell cmdlets built in to Windows 10 to retrieve and display DO data, including stats and charts for the current month, performance snapshot data and data on any current DO jobs.

Requirements

  • A supported version of Windows 10 (1703 onward)
  • PowerShell 5 minimum
  • .Net Framework 4.6.2 minimum
  • PS Remoting enabled to view data from remote computers.

This WPF tool is coded in Xaml and PowerShell and uses the MahApps.Metro and LiveCharts open source libraries.

Download

Download the tool from the Technet Gallery.

Use

To use the tool, extract the ZIP file, right-click the Delivery Optimization Monitor.ps1 and run with PowerShell.

To run against the local machine, you must run the tool elevated. To do so, create a shortcut to the ps1 file. Edit the properties of the shortcut and change the target to read:

PowerShell.exe -ExecutionPolicy Bypass -File “<pathtoPS1file>”

Right-click the shortcut and run as administrator, or edit the shortcut properties (under Advanced) to run as administrator.

For completeness, you can also change the icon of the shortcut to the icon file included in the bin directory.

Delivery Optimization Statistics

There are 3 tabs – the first displays DO data for the current month together with charts for download and upload statistics.

The second tab displays PerfSnap data and the third displays any current DO jobs.

Shout Out

Shout out to Kevin Rahetilahy over at dev4sys.com for blogging about LiveCharts in PowerShell.

Source Code

Source code can be found on GitHub.

New Tool: ConfigMgr Client Notification

Today I whipped-up a very simple tool for ConfigMgr admins and support staff. It allows you to send client notifications (using the so-called fast channel), such as downloading the computer policy, collecting hardware inventory, checking compliance etc, to remote computers from your local workstation independently of the ConfigMgr console.

CNT

The tool connects to your ConfigMgr site server using a Cimsession and PSSession, so you need WsMan operational in your environment. You simply provide some computer name/s in the text box, enter your site server name, select which client notification you want to send and click GO. The tool will get the online status of the clients from the SMS Provider to give you an indication of which systems will receive the client notification. Then it will trigger the client notification on online systems from the site server.

The tool is coded in PowerShell / Xaml and uses the MahApps Metro libraries for WPF styling.

Download

Download the tool from here.

Installation

I decided not to package the tool this time but just to release the files as they are, so if you need to tweak something for it to work in your environment, such as a non-default WsMan port, you can do that. Download and extract the zip file, right-click the ‘ConfigMgr Client Notification Tool.ps1’ and run with PowerShell.

Requirements

– Dot Net 4.6.2 minimum

  • PowerShell 5 minimum
  • WSMan remote access to the ConfigMgr Site server on the default port
  • Appropriate RBAC permissions for performing client operations
  • A version of ConfigMgr that supports the client notifications

Feel free to leave any feedback.

Create a Custom Splash Screen for a Windows 10 In-Place Upgrade

A while back I wrote a blog with some scripts that can be used to improve the user experience in a Windows 10 in-place upgrade. The solution included a simple splash screen that runs at the beginning of the upgrade to block the screen to the user and discourage interaction with the computer during the online phase of the upgrade. Since then, I made some improvements to the screen and styled it to look more like the built-in Windows update experience in Windows 10. Using this splash screen not only discourages computer interaction during the upgrade, but also creates a consistent user experience throughout the upgrade process, for a user-initiated upgrade.

The updated screen contains an array of text sentences that you can customise as you wish. Here is an example of what it could look like:

The splash screen is not completely foolproof in that it is still possible to use certain key combinations, like ctrl-alt-del and alt-tab etc, but the mouse cursor is hidden and mouse buttons will do nothing. The intention is simply to discourage the user from using the computer during the online phase. If the computer is locked, it will display the splash screen again when unlocked. If you wish to block user interaction completely, you might consider a more hardcore approach like this or this.

To use the splash screen, download all the files in my GitHub repository here (including the bin directory). Create a standard package in ConfigMgr containing the files (no program needed) and distribute. Then add a Run PowerShell Script step in the beginning of your in-place upgrade task sequence that looks like the following (reference the package you created):

ts

Once the splash screen has been displayed, the task sequence will move on to the next step – the screen will not block the task sequence.

How does it work?

The Invoke-PSScriptAsUser.ps1 simple calls the Show-OSUpgradeBackground.ps1 and runs it in the context of the currently logged-on user so that the splash screen will be visible to the user (task sequences run in SYSTEM context so this is necessary).

The Show-OSUpgradeBackground.ps1 determines your active screens, creates a runspace for each that calls PowerShell.exe and runs the Create-FullScreenBackground.ps1 for each screen.

The Create-FullScreenBackground.ps1  does the main work of displaying the splash screen. It will hide the task bar, hide the mouse cursor and display a full screen window in the Windows 10 update style. I’ve used the excellent MahApps toolkit to create the progress ring. The text displayed in the screen can be defined by placing short sentences in the $TextArray variable. The dispatcher timer will cycle through each of the these every 10 seconds (or whatever value you set) ending with a final sentence “Windows 10 Upgrade in Progress” which will stay on the screen until the computer is restarted into the next phase of the upgrade.

You can test the splash screen before deploying it simply by running the Show-OSUpgradeBackground.ps1 script.

Remember to deselect the option Show task sequence progress in the task sequence deployment to avoid having the task sequence UI show up on top of the window.

Find Windows 10 Upgrade Blockers with PowerShell

This morning I saw a cool post from Gary Blok about automatically capturing hard blockers in a Windows 10 In-Place Upgrade task sequence. It inspired me to look a bit further at that, and I came up with the following PowerShell code which will search all the compatibility xml files created by Windows 10 setup and look for any hard blockers. These will then be reported either in the console, or you can write them to file where you can copy them to a central location together with your SetupDiag files, or you could stamp the info to the registry or a task sequence variable as Gary describes in his blog post. You could also simply run the script against an online remote computer using Invoke-Command.

The script is not the one-liner that Gary likes, so to use in a task sequence you’ll need to wrap it in a package and call it.

# Searches the Windows 10 Setup Compatibility logs for upgrade hard blockers
# Find all the compatibility xml files
$SearchLocation = 'C:\$WINDOWS.~BT\Sources\Panther'
$CompatibilityXMLs = Get-childitem "$SearchLocation\compat*.xml" | Sort LastWriteTime Descending
# Create an array to hold the results
$Blockers = @()
# Search each file for any hard blockers
Foreach ($item in $CompatibilityXMLs)
{
$xml = [xml]::new()
$xml.Load($item)
$HardBlocks = $xml.CompatReport.Hardware.HardwareItem | Where {$_.InnerXml -match 'BlockingType="Hard"'}
If($HardBlocks)
{
Foreach ($HardBlock in $HardBlocks)
{
$FileAge = (Get-Date).ToUniversalTime() $item.LastWriteTimeUTC
$Blockers += [pscustomobject]@{
ComputerName = $env:COMPUTERNAME
FileName = $item.Name
LastWriteTimeUTC = $item.LastWriteTimeUTC
FileAge = "$($Fileage.Days) days $($Fileage.hours) hours $($fileage.minutes) minutes"
BlockingType = $HardBlock.CompatibilityInfo.BlockingType
Title = $HardBlock.CompatibilityInfo.Title
Message = $HardBlock.CompatibilityInfo.Message
}
}
}
}
# Report results
If ($Blockers)
{
$Blockers
# Export to file
#$Blockers | export-csv -Path "$env:SystemDrive\Windows\CCM\Logs\W10UpgradeHardBlockers.csv" -NoTypeInformation -UseCulture -Force
}
Else
{
Write-host "No hard blockers found"
}

The console output looks like this:

HardBlock

You should remove the FileAge property if using it in a task sequence as that’s a real-time value and is a quick indicator of when the blocker was reported.

If you use my solution here for improving the user experience in an IPU, you could also report this info to the end user by adding a script using my New-WPFMessageBox function, something like this…


$Stack = New-Object System.Windows.Controls.StackPanel
$Stack.Orientation = "Vertical"

$TextBox = New-Object System.Windows.Controls.TextBox
$TextBox.BorderThickness = 0
$TextBox.Margin = 5
$TextBox.FontSize = 14
$TextBox.FontWeight = "Bold"
$TextBox.Text = "The following hard blocks were found that prevent Windows 10 from upgrading:"

$Stack.AddChild($TextBox)

Foreach ($Blocker in $Blockers)
{
    $TextBox = New-Object System.Windows.Controls.TextBox
    $TextBox.BorderThickness = 0
    $TextBox.Margin = 5
    $TextBox.FontSize = 14
    $TextBox.Foreground = "Blue"
    $TextBox.Text = "$($Blocker.Title): $($Blocker.Message)"
    $Stack.AddChild($TextBox)
}

$TextBox = New-Object System.Windows.Controls.TextBox
$TextBox.BorderThickness = 0
$TextBox.Margin = 5
$TextBox.FontSize = 14
$TextBox.Text = "Please contact the Helpdesk for assistance with this issue."

$Stack.AddChild($TextBox)

New-WPFMessageBox -Title "Windows 10 Upgrade Hard Block" -Content $Stack -TitleBackground Red -TitleTextForeground White -TitleFontSize 18

…which creates a message box like this:

wpf

Thanks to Gary and Keith Garner for the inspiration here!

Create Interactive Charts with WPF and PowerShell

So I’m not a big Twitter fan, but I do admit – as an IT professional you can find a lot of useful and pertinent information there. One example was this morning when I happened to notice a tweet from Microsoft about their opensource projects on Github. After a quick perusal, I happened across an interesting project called Interactive Data Display for WPF. According to its description:

Interactive Data Display for WPF is a set of controls for adding interactive visualization of dynamic data to your application. It allows to create line graphs, bubble charts, heat maps and other complex 2D plots which are very common in scientific software. Interactive Data Display for WPF integrates well with Bing Maps control to show data on a geographic map in latitude/longitude coordinates. The controls can also be operated programmatically.

There are some nice-looking chart examples there such as:

sinline

markers

barchart (1)

Since there are no native charting controls in WPF this was of interest, so I fired up my PowerShell ISE and tried to get this working.

I created the following simple example using a bar chart. You can change the X or Y values then click Plot to update the chart.

Chart

The nice thing with this control is that it’s interactive – you can scroll the mouse wheel to zoom in and out, as well as move the axis left and right, and double-click to re-center.

barchartinteractive

Here’s the POSH code for the example:

## Example of how to use the opensource InteractveDataDisplay module from Microsoft to create a WPF chart in PowerShell
Add-Type AssemblyName PresentationFramework
Add-Type AssemblyName System.IO.Compression.FileSystem
# Location to download the required libraries and reference them from
$Source = "C:\Users\tjones\OneDrive\PowerShell\POSH Projects\Interactive Data Display"
#region DownloadDependencies
$URLs = @(
'https://api.nuget.org/v3-flatcontainer/system.reactive.interfaces/3.1.1/system.reactive.interfaces.3.1.1.nupkg'
'https://api.nuget.org/v3-flatcontainer/microsoft.maps.mapcontrol.wpf/1.0.0.3/microsoft.maps.mapcontrol.wpf.1.0.0.3.nupkg'
'https://api.nuget.org/v3-flatcontainer/system.reactive.windows.threading/3.1.1/system.reactive.windows.threading.3.1.1.nupkg'
'https://api.nuget.org/v3-flatcontainer/system.reactive.platformservices/3.1.1/system.reactive.platformservices.3.1.1.nupkg'
'https://api.nuget.org/v3-flatcontainer/system.reactive.core/3.1.1/system.reactive.core.3.1.1.nupkg'
'https://api.nuget.org/v3-flatcontainer/interactivedatadisplay.wpf/1.0.0/interactivedatadisplay.wpf.1.0.0.nupkg'
'https://api.nuget.org/v3-flatcontainer/system.reactive/3.1.1/system.reactive.3.1.1.nupkg'
'https://api.nuget.org/v3-flatcontainer/system.reactive.linq/3.1.1/system.reactive.linq.3.1.1.nupkg'
)
Foreach ($URL in $URLs)
{
$SubfolderName = $($URL.Split('/') | Select Last 1).trimend('.nupkg')
If (!(Test-Path $Source\$SubfolderName))
{
# Download file
$Output = "$Source\$($URL.Split('/') | Select Last 1)"
Invoke-WebRequest Uri $URL OutFile $Output
# Create directory
$null = New-Item Path $Source Name $SubfolderName ItemType Directory Force
# Extract to directory
[System.IO.Compression.ZipFile]::ExtractToDirectory( $Output, "$Source\$SubfolderName" )
# Cleanup nupkgs
Remove-item Path $Output Force
}
}
#endregion
# Add the required libraries
Add-Type Path "$Source\microsoft.maps.mapcontrol.wpf.1.0.0.3\lib\net40-Client\Microsoft.Maps.MapControl.WPF.dll"
Add-Type Path "$Source\System.Reactive.Interfaces.3.1.1\lib\net45\System.Reactive.Interfaces.dll"
Add-Type Path "$Source\System.Reactive.Core.3.1.1\lib\net45\System.Reactive.Core.dll"
Add-Type Path "$Source\System.Reactive.Linq.3.1.1\lib\net45\System.Reactive.Linq.dll"
Add-Type Path "$Source\System.Reactive.PlatformServices.3.1.1\lib\net45\System.Reactive.PlatformServices.dll"
Add-Type Path "$Source\System.Reactive.Windows.Threading.3.1.1\lib\net45\System.Reactive.Windows.Threading.dll"
Add-Type Path "$Source\InteractiveDataDisplay.WPF.1.0.0\lib\net452\InteractiveDataDisplay.WPF.dll"
# Define the UI in xaml
[XML]$Xaml = @'
<Window
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation&quot;
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml&quot;
xmlns:d3="clr-namespace:InteractiveDataDisplay.WPF;assembly=InteractiveDataDisplay.WPF"
Title = "InteractiveDataDisplay Bar Chart Example" SizeToContent="WidthAndHeight" MinHeight="450" MinWidth="450" WindowStartupLocation = "CenterScreen" ResizeMode="NoResize" >
<Grid>
<StackPanel Orientation="Vertical">
<StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
<Label Content="X Axis" FontSize="16"/>
<TextBox Name="X1" Text="1" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5"/>
<TextBox Name="X2" Text="2" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
<TextBox Name="X3" Text="3" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
<TextBox Name="X4" Text="4" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
<TextBox Name="X5" Text="5" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
</StackPanel>
<StackPanel Orientation="Horizontal" HorizontalAlignment="Center">
<Label Content="Y Axis" FontSize="16"/>
<TextBox Name="Y1" Text="5" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5"/>
<TextBox Name="Y2" Text="4" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
<TextBox Name="Y3" Text="3" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
<TextBox Name="Y4" Text="2" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
<TextBox Name="Y5" Text="1" VerticalContentAlignment="Center" HorizontalContentAlignment="Center" Width="30" FontSize="16" Margin="5" />
</StackPanel>
<Button Name="Plot_Button" Content="Plot" Height="50" Width="100" HorizontalAlignment="Center" FontSize="32" Foreground="green" Margin="5"/>
<d3:Chart Name="plotter" Height="430" Width="430">
<d3:Chart.Title>
<TextBlock HorizontalAlignment="Center" FontSize="18" Margin="0,5,0,5">Enter plot values</TextBlock>
</d3:Chart.Title>
<d3:BarGraph Name="barChart" Color="Blue" Height="430" Width="430" />
</d3:Chart>
</StackPanel>
</Grid>
</Window>
'@
# Load all the named objects into items in a hashtable
$Hash = [hashtable]::Synchronized(@{})
$Hash.Window = [Windows.Markup.XamlReader]::Load((New-Object TypeName System.Xml.XmlNodeReader ArgumentList $xaml))
$XAML.SelectNodes("//*[@*[contains(translate(name(.),'n','N'),'Name')]]") | ForEach-Object Process {
$Hash.$($_.Name) = $Hash.Window.FindName($_.Name)
}
# Handle the Button click event
$Hash.Plot_Button.Add_Click({
# Plot the chart
$Hash.barChart.Plot(@(
$Hash.X1.Text,$Hash.X2.Text,$Hash.X3.Text,$Hash.X4.Text,$Hash.X5.Text
),@(
$Hash.Y1.Text,$Hash.Y2.Text,$Hash.Y3.Text,$Hash.Y4.Text,$Hash.Y5.Text
))
})
# Display the window
$null = $Hash.window.Dispatcher.InvokeAsync{$Hash.window.ShowDialog()}.Wait()

There are a number of dependency libraries that the script will download for you, or you can also install them via the NuGet gallery as indicated in the project’s readme.

This is just a quick demo, but it’s a pretty cool control!

Create a Custom Toast Notification with WPF and PowerShell

In this quick post I will demonstrate a custom toast notification created using WPF and PowerShell. This is not the built-in Windows 10 toast notification created using the [Windows.UI.Notifications] namespace (check out the excellent BurntToast module for that), but simply to demonstrate how to create something similar in code that would also work in older operating systems like Windows 7, and that is completely customisable without any predefined style templates.

toast

To add an image I recommend to convert the image to a base64 string. This means you can include the image in the script and distribute it without having to include any additional files. To create a base64 string from an image file, use the following code, then use Out-File to save the $Base64 variable to a text file. You can then copy and paste the content of the text file into the $Base64 variable in the notification script.


$File = "C:\Users\tjones\Pictures\smsagent.png"
$Image = [System.Drawing.Image]::FromFile($File)
$MemoryStream = New-Object System.IO.MemoryStream
$Image.Save($MemoryStream, $Image.RawFormat)
[System.Byte[]]$Bytes = $MemoryStream.ToArray()
$Base64 = [System.Convert]::ToBase64String($Bytes)
$Image.Dispose()
$MemoryStream.Dispose() 

You can customise a few parameters such as height and width, image size and text content at the top of the script.  In the example, I have set the property ‘IsHitTestVisible’ to $False on the textboxes so that you can click anywhere on the notification to open the webpage, but the beauty here is you can customise this as you like:

  • perform whatever action you want or none at all
  • add your own custom content to the notification, including any WPF element
  • change the animation style

There are a couple of limitations:

  • I haven’t added support for touch devices, ie swipe to dismiss
  • The notification won’t move to the Action Center in Windows 10 on expiry

Here’s the code:

# Demo script to display a custom 'toast' notification
# Load required assemblies
Add-Type AssemblyName PresentationFramework, System.Windows.Forms
# User-populated variables
$WindowHeight = 140
$WindowWidth = 480
$Title = "New Blog Post by SMSAgent!"
$Text = "Trevor Jones has posted a new blog: Create a custom toast notification with WPF and PowerShell. Click here to read."
$Timeout = 10
$ImageHeight = 100
$ImageWidth = 100
# Set screen working area, bounds and start and finish location of the window 'top' property (for animation)
$workingArea = [System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea
$Bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
$TopStart = $workingArea.Bottom
$TopFinish = $workingArea.Bottom ($WindowHeight + 10)
$CloseFinish = $Bounds.Bottom
# Code to create a base64 string from an image file
<#
$File = "C:\Users\tjones\Pictures\smsagent.png"
$Image = [System.Drawing.Image]::FromFile($File)
$MemoryStream = New-Object System.IO.MemoryStream
$Image.Save($MemoryStream, $Image.RawFormat)
[System.Byte[]]$Bytes = $MemoryStream.ToArray()
$Base64 = [System.Convert]::ToBase64String($Bytes)
$Image.Dispose()
$MemoryStream.Dispose()
#>
# Create the custom logo from Base64 string
$Base64 = "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"
$CustomImage = New-Object System.Windows.Media.Imaging.BitmapImage
$CustomImage.BeginInit()
$CustomImage.StreamSource = [System.IO.MemoryStream][System.Convert]::FromBase64String($Base64)
$CustomImage.EndInit()
# Calculate element dimensions
$MainStackWidth = $WindowWidth 10
$SecondStackWidth = $WindowWidth $ImageWidth -10
$TextBoxWidth = $SecondStackWidth 30
# Define the notification UI in Xaml
[XML]$Xaml = "
<Window
xmlns='http://schemas.microsoft.com/winfx/2006/xaml/presentation&#39;
xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml&#39;
Title='Druva Notification' Width='$WindowWidth' Height='$WindowHeight'
WindowStyle='None' AllowsTransparency='True' Background='Transparent' Topmost='True' Opacity='0.9'>
<Window.Resources>
<Storyboard x:Name='ClosingAnimation' x:Key='ClosingAnimation' >
<DoubleAnimation Duration='0:0:.5' Storyboard.TargetProperty='Top' From='$TopFinish' To='$CloseFinish' AccelerationRatio='.1'/>
</Storyboard>
</Window.Resources>
<Window.Triggers>
<EventTrigger RoutedEvent='Window.Loaded'>
<BeginStoryboard>
<Storyboard >
<DoubleAnimation Duration='0:0:.5' Storyboard.TargetProperty='Top' From='$TopStart' To='$TopFinish' AccelerationRatio='.1'/>
</Storyboard>
</BeginStoryboard>
</EventTrigger>
</Window.Triggers>
<Grid>
<Border BorderThickness='0' Background='#333333'>
<StackPanel Margin='20,10,20,10' Orientation='Horizontal' Width='$MainStackWidth'>
<Image x:Name='Logo' Width='$ImageWidth' Height='$ImageHeight'/>
<StackPanel Width='$SecondStackWidth'>
<TextBox Margin='5' MaxWidth='$TextBoxWidth' Background='#333333' BorderThickness='0' IsReadOnly='True' Foreground='White' FontSize='20' Text='$Title' FontWeight='Bold' HorizontalContentAlignment='Center' Width='Auto' HorizontalAlignment='Stretch' IsHitTestVisible='False'/>
<TextBox Margin='5' MaxWidth='$TextBoxWidth' Background='#333333' BorderThickness='0' IsReadOnly='True' Foreground='LightGray' FontSize='16' Text='$Text' HorizontalContentAlignment='Left' TextWrapping='Wrap' IsHitTestVisible='False'/>
</StackPanel>
</StackPanel>
</Border>
</Grid>
</Window>
"
# Create a global hash table to add dispatcher to
$Global:UI = @{}
# Create the window
$Window = [Windows.Markup.XamlReader]::Load((New-Object TypeName System.Xml.XmlNodeReader ArgumentList $xaml))
# Set the image
$Logo = $Window.FindName('Logo')
$Logo.Source = $CustomImage
# Add the closing animation to the global variable
$UI.ClosingAnimation = $Window.FindName('ClosingAnimation')
# Window loaded
$Window.Add_Loaded({
# Activate
$This.Activate()
# Play a sound
$SoundFile = "$env:SystemDrive\Windows\Media\Windows Notify.wav"
$SoundPlayer = New-Object System.Media.SoundPlayer ArgumentList $SoundFile
$SoundPlayer.Add_LoadCompleted({
$This.Play()
$This.Dispose()
})
$SoundPlayer.LoadAsync()
# Set the location of the left property
$workingArea = [System.Windows.Forms.Screen]::PrimaryScreen.WorkingArea
$this.Left = $workingarea.Width ($this.ActualWidth + 10)
# Create a dispatcher timer to begin notification closure after x seconds
$UI.DispatcherTimer = New-Object TypeName System.Windows.Threading.DispatcherTimer
$UI.DispatcherTimer.Interval = [TimeSpan]::FromSeconds($Timeout)
$UI.DispatcherTimer.Add_Tick({
$UI.ClosingAnimation.Begin($Window)
})
$UI.DispatcherTimer.Start()
})
# Window closing
$Window.Add_Closing({
# Stop the dispatcher timer
$UI.DispatcherTimer.Stop()
})
# Closing animation is completed
$UI.ClosingAnimation.Add_Completed({
$Window.Close()
})
# Window Mouse enter
$Window.Add_MouseEnter({
# Change cursor to a hand
$This.Cursor = 'Hand'
})
# Window mouse up (simulate click)
$Window.Add_MouseUp({
# Open a web page, stop the dispatcher timer and close the notification
Start-Process "https://smsagent.wordpress.com"
$UI.DispatcherTimer.Stop()
$This.Close()
})
# Display the notification
$null = $window.Dispatcher.InvokeAsync{$window.ShowDialog()}.Wait()

New tool: ConfigMgr Add2Collection

Today I released a new tool for the community! ConfigMgr Add2Collection is a free tool that allows IT administrators and support staff to add resources to collections in ConfigMgr independently of the ConfigMgr console. It honors role-based access control (RBAC) to limit visibility of collections where appropriate. It can be used either on the Site Server or a remote workstation using PS remoting.

The tool includes a collection explorer so you can browse for collections, view collection details and current membership.

See more info here.

add2-2

add2-1