Windows Management Infrastructure Blog

Windows Management Framework 3.0 Community Technology Preview (CTP) #2 Available for Download

Osama Sajid [MSFT] — Sat, 03 Dec 2011 19:47:52 GMT

I’m pleased to announce that the Community Technology Preview #2 (CTP2) is available for download.

Windows Management Framework 3.0 CTP2 makes some updated management functionality available to be installed on Windows 7 SP1 & Windows Server 2008 R2 SP1. Windows Management Framework 3.0 contains Windows PowerShell 3.0, WMI & WinRM.

IMPORTANT: If you have WMF3.0 CTP1 installed, you must uninstall it before installing CTP2.

Overview of changes since WMF 3.0 CTP1
1. Customer Reported Bug Fixes
Many customer reported bugs have been fixed since the WMF 3.0 CTP1. The release notes contains a list of bug titles, but please check Connect for full details.

2. Single Command Pane in Windows PowerShell ISE
The Command and Output panes in Windows PowerShell ISE have been combined into a single Command pane that looks and behaves like the Windows PowerShell console.

3. Updatable Help
The WMF 3.0 CTP1 release notes described a new Updatable Help system in Windows PowerShell 3.0 and included a copy of the help content. The Updatable Help system is now active on the Internet. To download and update help files, type: Update-Help.

4. Windows PowerShell Workflows
A number of enhancements have been made in the scripting experience for Windows PowerShell Workflows, including new keywords: Parallel, Sequence & Inlinescript. A document describing these changes will be published to the download page shortly.

5. Remote Get-Module
The Get-Module cmdlet now supports implicit remoting. You can now use the new PSSession and CIMSession parameters of the Get-Module cmdlet to get the modules in any remote session or CIM session. A number of other module enhancements are listed in the release notes.

Feedback & Bugs
We welcome any feedback or bug submissions to the Windows PowerShell Connect site: http://connect.microsoft.com/PowerShell

Additional Information:
This software is a pre-release version. Features and behavior are likely to change before the final release.

This preview release is designed to enable the community to experience and review the preliminary designs and direction of key features Windows PowerShell 3.0 and to solicit feedback before features are finalized.

For an interesting post describing what to expect with a CTP, read this very old post from Jeffrey

Travis Jones [MSFT]
Program Manager – Windows PowerShell
Microsoft Corporation

Windows Management Framework 3.0 Community Technology Preview (CTP) #1 Available for Download

Osama Sajid [MSFT] — Tue, 20 Sep 2011 18:37:00 GMT

Copying blog post from PowerShell blog

Windows Management Framework 3.0 CTP1 makes some updated management functionality available to be installed on Windows 7 SP1 & Windows Server 2008 R2 SP1. Windows Management Framework 3.0 contains Windows PowerShell 3.0, WMI & WinRM.

Windows PowerShell 3.0
Some of the new features in Windows PowerShell 3.0 include:

Workflows
Workflows that run long-running activities (in sequence or in parallel) to perform complex, larger management tasks, such as multi-machine application provisioning. Using the Windows Workflow Foundation at the command line, Windows PowerShell workflows are repeatable, parallelizable, interruptible, and recoverable.
Robust Sessions
Robust sessions that automatically recover from network failures and interruptions and allow you to disconnect from the session, shut down the computer, and reconnect from a different computer without interrupting the task.
Scheduled Jobs
Scheduled jobs that run regularly or in response to an event.
Delegated Administration
Commands that can be executed with a delegated set of credentials so users with limited permissions can run critical jobs
Simplified Language Syntax
Simplified language syntax that make commands and scripts look a lot less like code and a lot more like natural language.
Cmdlet Discovery
Improved cmdlet discovery and automatic module loading that make it easier to find and run any of the cmdlets installed on your computer.
Show-Command
Show-Command, a cmdlet and ISE Add-On that helps users find the right cmdlet, view its parameters in a dialog box, and run it.

WMI
WMI in Windows Management Framework 3.0 CTP1 introduces:

A new provider development model
This new model brings down the cost of provider development and removes the dependency on COM.
A new MI Client API to perform standard CIM operations.
The API can be used to interact with any standard WsMan + CIMOM implementation, allowing management applications on Windows to manage non-Windows computers.
The ability to write Windows PowerShell cmdlets in native code
The new WMI Provider APIs supports an extended Windows PowerShell semantics API allowing you to provide rich Windows PowerShell semantics. e.g., Verbose, Error, Warning, WhatIf, Confirm, Progress

WinRM
With Windows Management Framework 3.0 CTP1:

Connections are more robust
Session disconnect and reconnect, with or without client session reconstruction, allows long-running tasks to continue even when the session in which they were started is closed and the client computer is shut down. This feature also allows administrators to reconnect from different computers to check the status of remote running tasks and get results.
Connections are more resilient
In Windows PowerShell 3.0 CTP1, connections can survive short-term network failures; the client-server connection is not severed at the first sign of trouble. If network problems persist, the client is safely disconnected and can reconnect by using the Connect-PSSession or Receive-PSSession cmdlets.

Windows PowerShell Web Service
Windows PowerShell Web Service enables an administrator to expose a set of PowerShell cmdlets as a RESTful web endpoint accessible via the Open Data Protocol (OData). This provides remote access to invoke cmdlets from both Windows and non-Windows clients.

Prerequisites

Windows Management Framework 3.0 CTP1 can be installed on the following supported operating systems:

Windows 7 with Service Pack 1
Windows Server 2008 R2 with Service Pack 1

Windows PowerShell 3.0 requires version 4.0 of the common language runtime (CLR). CLR 4.0 is includes with the Microsoft .NET Framework version 4.0.

To install WMF 3.0 CTP1:

Download and extract the correct package for your architecture from the Microsoft Download Center
1. For 64-bit systems, download WMF3-CTP1-x64.cab
2. For 32-bit systems, download WMF3-CTP1-x86.cab
Extract the contents of the downloaded CAB file by typing: expand <<package name>> -F:* <<destination you want for extracted files>>
Close all Windows PowerShell 2.0 windows.
Run the WINDOWS6.1-KB2506143 MSU.

NOTES:

You do not have to uninstall or remove any programs before installing the WMF 3.0 CTP1.
This package requires Service Pack 1 (SP1) for Windows 7. If you receive a “This update does not apply” message when trying to install, verify that SP1 is installed.

To uninstall the WMF 3.0 CTP1:

Locate and uninstall the following installed Windows Update: KB2506143

Additional Information:

This software is a pre-release version. Features and behavior are likely to change before the final release.

Travis Jones
Windows PowerShell PM
Microsoft Corporation

BITS – More Flexible Bandwidth Limit Policies

Aditya Patwardhan [MSFT] — Thu, 03 Feb 2011 03:26:35 GMT

Background Intelligent Transfer Service (BITS) has introduced a more granular control over the BITS bandwidth usage for background jobs, with a new set of group policies. Bandwidth limits can now be applied to the three BITS job priorities individually, hence providing a way of allocating more bandwidth to higher priority jobs.

A concept of time based schedules is presented, splitting the day into two schedules, namely, “Working Schedule” and “Non-Working Schedule”. These two schedules are complement of each other. Another schedule called the “Maintenance Schedule” is also supported. The bandwidth limits defined during Maintenance Schedule pre-empt Working and Non-Working schedule bandwidth limits. Within each time based schedule, bandwidth limits can individually assigned per job priority.

Highlights:

· Priority based bandwidth control allows higher priority jobs to use more bandwidth, but still imposing a limit on it.

· Time based schedules allow jobs to automatically switch their bandwidth usage when schedule changes, say from Working Schedule to Non-Working Schedule.

· Bandwidth limits can be ignored for jobs, if the source and destination are on the same subnet, using a setting in the group policy.

· Bandwidth limits can be set in kbps, mbps and unlimited units, per job priority level.

· Schedules are defined as a continuous time slot; say Monday – Friday – 8 am to 5 pm.

These group policies are available under:

Local Computer Policy -> Administrative Templates -> Network -> Background Intelligent Transfer Service

Setting a bandwidth policy on Work Schedule:

Setting a bandwidth policy on Maintenance schedule:

Hope this helps!

Aditya Patwardhan [MSFT]

Using WS-Man to invoke a Powershell Cmdlet

Steve.L_ — Tue, 25 Jan 2011 00:32:00 GMT

First, let me apologize for the lack of posts to this blog. Out original team goal was to have a new post every month, but holidays/vacations/work got in the way. I’ll try to restart this rhythm. For this first post of the New Year, I’m going to cover a more technical topic.

Most Windows administrators should already be aware that Powershell is the preferred ITPro scripting and command-line experience. Many products from Microsoft and also third-parties expose their management interface as Powershell cmdlets. Since Powershell is currently only available on Windows, how can you manage Windows from a non-Windows box?

Although Powershell remoting is built on top of WS-Management, it’s really a protocol within a protocol and trying to interop with PSRP (Powershell Remoting Protocol) directly would essentially require replicating Powershell on the client. The alternative is to make use of a lesser known remote command-line tool called WinRS. WinRS is a simple utility allows remote cmd.exe and is also built on top of WS-Management. The difference is that WinRS reuses Create and Delete from WS-Transfer and introduces a few new custom SOAP web-methods. For this blog post, I’ll be focusing on the WinRS “protocol” and won’t be discussing WS-Transfer, SOAP, nor HTTP in detail. The complete details of the WinRS WS-Management Protocol extensions is documented here: http://msdn.microsoft.com/en-us/library/cc251526(v=PROT.10).aspx

WinRS has a relatively simple protocol, the workflow is:

1. WS-Transfer Create to create a shell, an EPR (End-Point Reference) to the created Shell is returned which is used for the next set of operations
2. Invoke the Command custom SOAP action to start a new command
3. Invoke the Receive custom SOAP action to receive output from the command (there is a corresponding Send for sending input, but it’s not needed for this scenario)
4. repeat step 3 until CommandState is Done
5. WS-Transfer Delete on the shell EPR

Let’s go through each step in a bit more detail.

For the WS-Transfer Create SOAP message, the body should contain the streams you want to send and receive. The resource URI should be: http://schemas.microsoft.com/wbem/wsman/1/windows/shell/cmd. We are essentially creating a cmd.exe shell which we use to run powershell.exe.

<Shell xmlns='http://schemas.microsoft.com/wbem/wsman/1/windows/shell’>
<InputStreams>stdin</InputStreams>
<OutputStreams>stdout stderr</OutputStreams>
</Shell>

If the request was successful, you’ll receive a standard WS-Transfer Create SOAP response which contains the newly created Shell EPR which resembles:

<w:SelectorSet>
<w:Selector Name="ShellId">AFCFB065-F551-4604-BFDFD9B706798B5D</w:Selector>
</w:SelectorSet>

This EPR should be cached for all subsequent operations. The first custom SOAP action Command uses the Action uri: http://schemas.microsoft.com/wbem/wsman/1/windows/shell/Command. WinRS supports two console modes: interactive and batch. For an interactive session, WinRS will wait for input (even if the command completes) until the client indicates there is no more. For a batch session, WinRS will expect input to be sent only during the lifetime of the running command. For this scenario, it is important to specify the WS-Management option WINRS_CONSOLEMODE_STDIN with a value of true which means to use batch mode. The command-line is split into separate Command and Arguments. The SOAP fragment would look like:

…
<w:OptionSet>
<w:Option Name='WINRS_CONSOLEMODE_STDIN'>TRUE</w:Option>
</w:OptionSet>
</s:Header>
<s:Body>
<CommandLine xmlns='http://schemas.microsoft.com/wbem/wsman/1/windows/shell'>
<Command>powershell</Command>
<Arguments>get-service | format-csv </Arguments>
</CommandLine>
</s:Body>

If this request was successful, the response will contain a CommandId element in the body that should be cached and used for subsequent operations for receiving the output. Although the protocol was defined to allow one shell to host multiple commands, WinRS is limited to a single command per shell. An example body of this response would resemble:

<rsp:CommandResponse>
<rsp:CommandId>772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E</rsp:CommandId>
</rsp:CommandResponse>

Once the Command response is received, the command is running on the server. WinRS will block output (and therefore the command) once the maximum envelope size is reached. The custom SOAP action Receive uses the action uri: . Since the resulting output may exceed a single SOAP envelope, the client needs to specify an incrementing SequenceId in case any packets were lost. WinRS will only cache the last sent packet. The request should contain the streams you want to read from and the CommandId associated to the stream in the body:

<Receive SequenceId='0'
xmlns='http://schemas.microsoft.com/wbem/wsman/1/windows/shell'>
<DesiredStream CommandId='772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E'>
stdout stderr
</DesiredStream>
</Receive>

The response will contain the text output of the streams base64 encoded (to keep the SOAP xml well-formed and valid). The client should check the state of the command to know whether to continue to invoke Receive for more output.

<rsp:ReceiveResponse>
<rsp:Stream Name="stdout" CommandId="772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E">DQo=</rsp:Stream>
<rsp:Stream Name="stdout" CommandId="772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E">
    U3RhdHVzICAgTmFtZSAgICAgICAgICAgICAgIERpc3BsYXlOYW1lICAgICAgICAgICAgICAgICAgICAgICAgICAg</rsp:Stream>
<rsp:Stream Name="stdout" CommandId="772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E">
    DQotLS0tLS0gICAtLS0tICAgICAgICAgICAgICAgLS0tLS0tLS0tLS0gICAgICAgICAgICAgICAgICAgICAgICAgICANClJ1bm5pbmcgIH
dpbm1nbXQgICAgICAgICAgICBXaW5kb3dzIE1hbmFnZW1lbnQgSW5zdHJ1bWVudGF0aW9uICAgIA0KDQoNCg==</rsp:Stream>
<rsp:Stream Name="stdout" CommandId="772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E" End="true"></rsp:Stream>
<rsp:Stream Name="stderr" CommandId="772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E" End="true"></rsp:Stream>
<rsp:CommandState CommandId="772B44DF-2EA2-4AA5-87D1-A07E1FAE7A4E"
     State="http://schemas.microsoft.com/wbem/wsman/1/windows/shell/CommandState/Done">
<rsp:ExitCode>0</rsp:ExitCode>
</rsp:CommandState>
</rsp:ReceiveResponse>

Once the CommandState is “Done”, there is no more output and WS-Transfer Delete should be called on the shell EPR. This will clean-up any resources being used on the server.

The example code shows how to invoke a Powershell cmdlet. It does not make use of any WinRM api’s, but instead creates the necessary SOAP messages from templates and uses System.Net.HttpWebRequest to send it over the wire. To enable using the sample code in Windows, you’ll need to enable Basic authentication in the WinRM service config (which only works for local acocunts), you can run this Powershell command as admin: Set-Item WSMan:\localhost\Service\Auth\Basic $true. You will need to deploy a server cert to use HTTPS or for testing purposes, set the WinRM service config to allow unencrypted HTTP. Here's an example command line to use with the sample code:

WinRSPsh http://server:5985/wsman user password "get-service"

If you want the output in a application consumable form, you can convert to XML (.Net serialization):

WinRSPsh http://server:5985/wsman user password "(get-service ^| convertto-xml).OuterXml"

Note that in the above example, you have to escape the pipe so that cmd.exe doesn't try to interpret it.

Enabling BITS logging

Alex Ng [MSFT] — Mon, 30 Aug 2010 21:24:00 GMT

Here's an oldie but a goodie. Heath Stewart provides example scripts on how to enable and disable ETW logging for the BITS service.

See http://blogs.msdn.com/b/heaths/archive/2008/07/07/bits-logging.aspx

WinRM 2.0 and Windows PowerShell 2.0 on Windows Update

Nathan Burkhart — Tue, 22 Jun 2010 23:03:52 GMT

Today, we released Windows PowerShell 2.0 and WinRM 2.0 for pre-Windows 7 operating systems on Windows Update. This non-security, optional update is designed for Windows Server 2008 SP2, Windows Vista SP2, Windows Server 2003 SP2, and Windows XP SP3. Now it's even easier to install these great management tools!

Check out this post at the PowerShell blog for more details.

Enjoy!

Nathan Burkhart

Program Manager | WS-Management

Configure SCCM to use BITS + BranchCache

Alex Ng [MSFT] — Fri, 28 May 2010 21:36:17 GMT

System Center Configuration Manager (SCCM) leverages BITS and BranchCache to download patches from a local distribution point and conserve WAN usage. Check out this blog post that provides an overview of how SCCM leverages this feature and how to enable it.

http://blogs.msdn.com/b/steverac/archive/2010/02/06/configuring-sccm-and-branch-cache.aspx

Alex Ng

SDET – Windows Manageability

Configurig WSMan Limits

Aditya Patwardhan [MSFT] — Fri, 07 May 2010 21:01:00 GMT

Here is an article that shows how to use Powershell to easily configure WSMan Limits.

http://blogs.msdn.com/powershell/archive/2010/05/03/configuring-wsman-limits.aspx

Hope this helps.

Aditya Patwardhan [MSFT]

Why do I get ACCESS DENIED when running commands on a remote PS runspace?

Manoj Ampalam — Mon, 03 May 2010 06:17:00 GMT

This blog entry describes the reasons behind getting "Access Denied" on certain commands run on remote PS runspaces and ways to work around them. The category of commands include ones that authenticate to other services, try to access network resources and others that depend on the "impersonation" level of the security token.

The commands would otherwise work when run on locally.

A brief context of why this problem occurs : Powershell uses WSMan (or WinRM) to communicate to a remote endpoint. The default authentication that WinRM supoprts (Kerberos or Negotiate) ends up generating a "network" token on the server side that does not have authentication privileges. Powershell remote runspace and all associated commands run in the context of the "network" token.

To support these scenarios, WinRM has added the support for CredSSP in version 2.0. CredSSP authentication results in server side token that is capable of doing authentication. Refer http://msdn.microsoft.com/en-us/library/ee309365(VS.85).aspx for more details

Scripts to make your life easier

Aditya Patwardhan [MSFT] — Tue, 27 Apr 2010 16:38:00 GMT

I found a blog which has a few helpful VBScripts to perform some common tasks.

http://blogs.msdn.com/alejacma/archive/tags/WMI/default.aspx

Hope this helps.

Aditya Patwardhan [MSFT]

Configuring BITS Upload Server with PowerShell and ADSI

Alex Ng [MSFT] — Sat, 03 Apr 2010 02:01:00 GMT

A common request that I get from customers is that they would like to use PowerShell to configure the BITS Upload Server extension on IIS. In the past, automating upload server configuration required the use of the Windows Scripting Host and the BITS ADSI extension (see http://msdn.microsoft.com/en-us/library/aa362825(v=VS.85).aspx ). It is also possible to do this using PowerShell and the same BITS ADSI extension.

First, let’s begin by installing the BITS Upload Server extension for IIS. We will need to import the Server Manager cmdlets and use the Add-WindowsFeature cmdlet to do this.

PS> Import-Module ServerManager

PS> Add-WindowsFeature BITS-IIS-Ext

In order to enable or disable BITS uploads using the BITS ADSI extension; we will need to run PowerShell using Single-Threaded Apartment (STA).

PS> powershell.exe –sta

Let’s start configuring a website to allow BITS uploads. To do this, we will need an ADSI object that represents the website’s configuration settings. In the following example, we get the configuration for an IIS directory called “Uploads” under the “Default Web Site”.

PS> $siteObj = New-Object System.DirectoryServices.DirectoryEntry("IIS://LocalHost/W3SVC/1/root/Uploads")

To enable BITS uploads on this directory; we can call the EnableBitsUploads method. (Note: The local path associated with this directory must allow write access to the built-in “IUSR” user. Otherwise, any BITS uploads to this directory will result in an access denied error.)

PS> $siteObj.EnableBitsUploads()

We call the RefreshCache method to synchronize the ADSI object with the latest configuration settings. We can then get a list of the configurable properties for this directory. The properties that affect the BITS upload server configuration are highlighted below. You can find out more about them at http://msdn.microsoft.com/en-us/library/aa362818(v=VS.85).aspx .

PS > $siteObj.RefreshCache()

PS > $siteObj.Properties

PropertyName Value Capacity Count

------------ ----- -------- -----

AppPoolId DefaultAppPool 4 1

DontLog False 4 1

DirBrowseFlags 1073741854 4 1

DefaultDoc Default.htm,Default.asp,in... 4 1

AuthFlags 1 4 1

AnonymousUserName IUSR 4 1

AspDiskTemplateCacheDirectory D:\inetpub\temp\ASP Compil... 4 1

HttpErrors {401,*,FILE,D:\inetpub\cus... 9 9

AccessSSLFlags 0 4 1

NTAuthenticationProviders Negotiate,NTLM 4 1

AccessFlags 513 4 1

ScriptMaps {.asp,D:\Windows\system32\... 14 14

RedirectHeaders 0 0

HttpCustomHeaders X-Powered-By: ASP.NET 4 1

BITSSessionDirectory BITS-Sessions 4 1

BITSMaximumUploadSize 18446744073709551615 4 1

BITSSessionTimeout 1209600 4 1

BITSServerNotificationType 0 4 1

BITSServerNotificationURL 4 1

BITSHostId 4 1

BITSHostIdFallbackTimeout 86400 4 1

BITSAllowOverwrites 0 4 1

BITSCleanupUseDefault True 4 1

BITSCleanupCount 12 4 1

BITSCleanupUnits 1 4 1

BITSMaxUploadSizeUnits 0 4 1

BITSSessionTimeoutUnits 0 4 1

BITSHostIdFallbackTimeoutU... 0 4 1

BITSNumberOfSessionsLimit 50 4 1

BITSSessionLimitEnable False 4 1

KeyType IIsWebVirtualDir 4 1

Path D:\inetpub\wwwroot\Uploads 4 1

AppIsolated 0 4 1

AppRoot /LM/W3SVC/1/ROOT 4 1

BITSUploadEnabled True 4 1

BITSCleanupWorkItemKey {590e5102-9718-477b-bce0-d... 4 1

The current BITSMaximumUploadSize value is 18446744073709551615, which indicates that the default upload size limit is being used (on IIS 7.0 the default upload size limit is 30 million bytes). We can set this limit to a different value. After updating the value, we call the CommitChanges method so that the new configuration takes effect.

PS > $siteObj.BITSMaximumUploadSize = 10000000

PS > $siteObj.CommitChanges()

Finally, if we need to disable BITS uploads to the directory, we can call the DisableBitsUploads method.

PS > $siteObj.DisableBitsUploads()

Hope this helps!

Alex Ng

SDET – Windows Manageability

What is the DMTF?

Nathan Burkhart — Wed, 24 Mar 2010 17:34:00 GMT

As you may know, WinRM and WMI are implementations of public standards -- WMI is our implementation of CIM, and WinRM is our implementation of the WS-Management protocol. These are both published by the Distributed Management Task Force (DMTF), a consortium of 160 companies and organizations that develops and promotes standards for systems management. You can read more about them at http://www.dmtf.org/about.

The world of standards development can b a strange and confusing one. If you want to learn more about the DMTF, what they produce, and how they're organized, there's a great tutorial hosted by WBEM Solutions that explains it clearly: http://www.wbemsolutions.com/tutorials/DMTF.

Enjoy!

Nathan Burkhart

Program Manager | WS-Management

Out-of-band Hardware Management using WS-Management and Powershell

Steve.L_ — Wed, 17 Mar 2010 22:24:00 GMT

This will be the first in a series of posts about out-of-band management. First, "out-of-band" basically means outside of the Operating System. Specifically, a client is managing hardware irrespective of what OS is installed or if an OS is even installed/running. This is possible because the hardware (typically called a Baseboard Management Controller (BMC)) implements some management protocol and in this case, we're using WS-Management.

The scripts I have here are tested against Intel's vPro only because that happens to be what is in my office. The same scripts (in theory) should work against any vendor implementation of WS-Management as long as the appropriate CIM Profiles are available. I'll leave discussion about CIM Profiles for another post. If you want to use these scripts, I assume the hardware you want to manage is already provisioned for remote management. Also, to successfully execute these scripts, you need to enable unsigned script execution in Powershell, allow unencrypted traffic, and trust the management endpoint in the WinRM client configuration (you should only do these things in a test environment).

For this first entry, we'll focus on one aspect of the CIM Power State Management Profile specifically on changing the power state. BMCs are typically low power devices that enable management of the main system. They are capable of running just on standby power. Some share the NIC with the main system, so you could have a computer system turned off (on standby) and plugged into the network and be able to remotely turn it back on.

The first step is to get the current power state. Here's the first of two Powershell scripts and I'll explain any interesting parts of it.

Param ([parameter(Mandatory=$true,Position=0)][string] $connectionUrl = "http://wsman-intelpc:16992/wsman",
[System.Management.Automation.PSCredential] $credential,
[string] $authentication = "Digest")

Since we are remoting to the hardware, we need some information. First is the connectionUrl, this includes the transport (http or https), the computer address, the port, and the rest of the URL. In this case, I've hardcoded the URL to the machine in my office and using the standard vPro port and URL. Next, we need credentials as well as the authentication method.

    $assocPowerMgmtSvc = Get-WSManInstance -ConnectionURI $connectionUrl -Authentication $authentication `
        -Credential $credential -Enumerate -ResourceURI cimv2/CIM_AssociatedPowerManagementService

    if ($assocPowerMgmtSvc -eq $null)
    {
        "The remote endpoint does not support the Power State Management Profile"
        exit
    }

If you follow the Use Cases defined in the CIM Power State Management Profile spec, you would first see if the management endpoint supports this particular profile by going to the Interop namespace and looking for the corresponding instance of CIM_RegisteredProfile. Then find the associated CIM_AssociatedPowerManagementService instance and then validate its capabilities, and finally perform the management operation. We'll shortcut some of this by attempting to get the CIM_AssociatedPowerManagementService directly. If it exists, we'll try to read the current power state, if not, well then it's obviously not supported.

    $powerStates = "Unknown", "Unknown", "On", "Sleep-Light", "Sleep-Deep",
        "Power Cycle (Off-Soft)", "Off-Hard", "Hibernate (Off-Soft)", "Off-Soft",
        "Power cycle (Off-Hard)", "Master Bus Reset", "Diagnostic Interrupt (NMI)",
        "Off-Soft Graceful", "Off-Hard Graceful", "Master Bus Reset Graceful",
        "Power Cycle off-Soft Graceful", "Power Cycle Off-Hard Graceful"

    $assocPowerMgmtSvc.PowerState + ":" + $powerStates[$assocPowerMgmtSvc.PowerState]

The CIM class will just return an integer value (for localization reasons), so we'll hardcode the English values here so that we know a value of 2 means On and 8 means Off. Pretty simple so far. Changing the power state is a bit more complicated which we cover next and is in a seperate script.

$remoteParams = @{ConnectionURI=$connectionUrl;Authentication=$authentication;Credential=$credential}

I'm skipping defining the Powershell script parameters which are similar to Get with the addition of a PowerState parameter. Unlike reading the current state, setting it requires multiple network calls, so we'll store the commonly used paramters in a variable.

    $powerprofile = Get-WSManInstance @remoteParams -Enumerate -ResourceURI `
        cimv2/CIM_RegisteredProfile?__cimnamespace=interop |
        Where-Object { $_.RegisteredName -eq "Power State Management" }

    if ($powerprofile -eq $null)
    {
        "The remote endpoint does not support the Power State Management Profile"
        exit
    }

Here I show what it looks like to see if the managed node supports the Power State Management Profile. One thing you'll notice is that I use Powershell to perform filtering on the client. Intel vPro supports the WS-Management Selector filter, however, it only filters against Key properties and the RegisteredName property of CIM_RegisteredProfile is not a key. To be completely proper, we are supposed to check the Capabilties to see if it supports the RequestPowerStateChange method, however, it's just easier to call it to determine whether it will work.

    $comp = Get-WSManInstance @remoteParams -Enumerate -ResourceURI cimv2/CIM_ComputerSystem |
        Where-Object { $_.Dedicated -ne 14 }
    $ManagedSystemName = $comp.Name

Now that we know that this machine supports it, we need to find the right CIM_ComputerSystem that we want to turn on or off. In the case of the BMC, you'll actually get two instances of CIM_ComputerSystem where one represents the BMC itself and the other the managed system. CIM_ComputerSystem has a Dedicated property we can filter agains to determine which is which. A value of 14 means the Management System, so we just look for the other one. Since this isn't a key property, we perform the filtering on the client using Powershell. We store the name of the managed system for later use.

$managedSystemEPR = Get-WSManInstance @remoteParams -Enumerate -ResourceURI cimv2/CIM_ComputerSystem `
-Dialect Selector -Filter "Name='$managedSystemName'" -ReturnType EPR

The CIM method we'll actually be using later to change the power state requires an EPR (EndPoint Reference) which is the path to an instance. The WS-Management GET operation doesn't support returning a EPR (rather than the object itself), so we'll use a little trick here (otherwise we'd have to construct the XML ourselves). Basically, I perform an enumeration, but using the Selector filter, I can just get the single instance I care about and have the EPR returned.

$powerMgmtSvcs = @(Get-WSManInstance @remoteParams -Enumerate -ResourceURI cimv2/* -Dialect Association `
-Filter "{Object=CIM_ComputerSystem?Name=$ManagedSystemName;ResultClassName=CIM_PowerManagementService}")

Next, we need to get the CIM_PowerManagementService that is associated with the instance of CIM_ComputerSystem we want to change the power state since the method belongs to this class. We do this using the Association filter dialect providing the CIM_ComputerSystem instance resource URI and specifying the ResultClassName we want.

    Invoke-WSManAction @remoteParams -ResourceUri cimv2/CIM_PowerManagementService -SelectorSet `
        @{Name=$powerMgmtSvcs[0].Name;CreationClassName=$powerMgmtSvcs[0].CreationClassName} `
        -Action RequestPowerStateChange -ValueSet `
        @{PowerState=$powerState;ManagedElement=$($managedSystemEPR.InnerXml)}

Finally, we are ready to call the RequestPowerStateChange method. We need to provide the path to the specific instance of CIM_PowerManagementService and I'm using the SelectorSet parameter to do this. The method parameters is the new PowerState and ManagedElement is the instance of CIM_ComputerSystem we want to power on/off.

I'll have more scripts and scenarios in the future. Note that I'll be on leave during April, so my next post will be either the end of this month or in May.

Steve Lee
Senior Test Manager
Standards Based Management

Collecting WinRM Traces

Manoj Ampalam — Tue, 16 Mar 2010 19:28:00 GMT

This blog entry explains how to collect WinRM ETW and WPP traces:

WinRM ETW Traces:

You can use EventViewer to look at WinRM ETW events:

· They are under Application and Services Logs à Microsoft àWindowsàWindows Remote Management

Operational channel is enabled by default. Analytic needs to be enabled

Use the following to show and enable Analytic log:

· Menu à View àShow Analytic and Debug Logs

· Rightclick on Analytic log and Enable Log

Alternatively one can enable Analytic logs using:

· Wevtutil.exe sl Microsoft-Windows-Winrm/Analytic /e:true /q

Here’s a way to collect ETW log dump using logman.exe

· Start the provider: logman.exe start winrmtrace -p Microsoft-Windows-Winrm -o winrmtrace.etl -ets

· Run the repro.

· Stop the provider: logman.exe stop winrmtrace -ets

Here’s a way to convert the etl log to various formats

· XML: tracerpt.exe winrmtrace.etl -of XML -o winrmtrace.xml

· CSV: tracerpt.exe winrmtrace.etl -of CSV -o winrmtrace.csv

· TXT: netsh trace convert winrmtrace.etl dump=TXT

Note that these are just operational and analytic logs. If there is a low level design/implementation problem that couldn’t be figured out using these logs, WPP traces may be required. Following are steps on how to generate WinRM WPP traces.

WinRM WPP Traces:

Launch a PowerShell console with the elevated admin credentials and run the following commands:

· Import-Module psdiagnostics

· Enable-WSManTrace

· Now reproduce the problem by sending the subscription packets from the client. Continue with the next step after the problem stops.

· Disable-wsmantrace

· Send us the file %windir%\system32\wsmtraces.log

Powershell Remoting fails with 502 error from server

Manoj Ampalam — Thu, 25 Feb 2010 22:19:00 GMT

502 usually results from an intermediate gateway/proxy unable to understand server’s response.

If however, you don't expect a gateway or proxy to sit between your client and server, this error may result from a misconfigured proxy settings on your client box.

To view, proxy settings, run the following on your client box:

netsh winhttp show proxy

The problem should go away once you reset your client side proxy configuraiton

netsh winhttp reset proxy

Powershell Remoting through Load Balancers : The "select or value was not found" problem

Manoj Ampalam — Thu, 25 Feb 2010 22:11:00 GMT

Powershell remoting is supported over load balancers with configuration described at http://msdn.microsoft.com/en-us/library/ee309370(VS.85).aspx#load_balancing_in__the__iis_extension_hosting_model

Users when trying to use this feature may hit a problem that breaks an active runspace with an error that looks like the following:

"the select or value F8037657-C31F-4B2F-9BCA-CAD89BC7C9F1 specified in the request was not found. "

The above error ideally means that the runspace does not exist or has already expired. However, users may hit this even when the remote runspace is active in a load balancer scenario. This will happen when winrm (the underlying transport protocol) uses multi-handshake auth protocols like Kerb, Negotiate or CredSSP.

There were two workaround to this issue:

- Configure LB to explicitly set the outbound cookie on every response (the default behavior is to set only on the request that did not have any cookie set)

- Adding a custom HTTP module on the IIS endpoint to replays back the cookie on every response

WinRM hosted in IIS fails to start with error 1300 in event log

Manoj Ampalam — Thu, 25 Feb 2010 21:57:00 GMT

WinRM is hosted within IIS by enabling the WinRM native module at a particular IIS site, app or a vdir. IIS sites and apps can be configured to run in a specific application pool. Each application pool runs under a specific user context. WinRM will fail to start when the user associated with the application pool does not have the required privileges.

When this happens, the following event shows up in the event log:

The WinRM service is unable to start because of a failure during initialization.

Additional Data
The error code is 1300.

To fix this, do the following:

Open secpol.msc
Navigate to Local Policies -- User Rights Assignment
Select the value "Generate Security Audits"
Add the user account to the list

Windows Management Framework Install Failure and Investigation

kmathur — Wed, 17 Feb 2010 17:24:00 GMT

Since Windows Management Framework was released Oct. 2009, our customers have been excited about using PowerShell 2.0 on down-level OSes. Meanwhile, we also received feedback from both internal and external customers about our product issues. One of them is WMF install failure followed by the mysterious “The update does not apply to your system” error message. It is a blocking issue for some customers since they cannot get WMF successfully installed and the error message does not help much with a fix.

You can find details here.

Quick and Dirty Large Scale Event forwarding for Windows

kmathur — Thu, 28 Jan 2010 19:53:00 GMT

We recently got a question on this blog about event forwarding.

This post by Otto Helweg gives a great introduction to event forwarding mechanism in windows - http://blogs.technet.com/otto/archive/2008/07/08/quick-and-dirty-enterprise-eventing-for-windows.aspx

Kapil Mathur [MSFT]

Perform asynchronous asset management using Windows Powershell cmdlets for WMI

kmathur — Thu, 21 Jan 2010 02:09:00 GMT

With Windows 7 wmi cmdlets now have support to perform tasks asynchronously.

Asynchronous execution typically involves –

· Run commands in background

· Wait/stop on them

· Retrieve results

· Check status of execution

Thus to collect hard inventory data like total Physical Memory from a list of machines in your domain, while not blocking the original machine from which the inventory collection is being triggered, you’ll follow these steps -

Step 1: On a Windows Powershell console on your machine, run the following command -

PS C:\> $c = gwmi -class win32_computersystem -asjob -throttlelimit 2 –computername “machine1”,”machine2”,”mchine3”

Now you go about completing other tasks.

Two parameters to note here

1. Asjob – This parameters tells Windows Powershell that the specified task has to be run in background. By specifying -asjob, you have ensured that you are not blocked on the completion of this task.

2. Throttlelimit – you can choose to limit the number of simultaneous tasks started with this parameter. In the above case, we get data from only two machines at a time because the throttlelimit was specified as 2. When the data is returned from one of the two machines, only then is a connection to third machine made to get data. This gives you control on resource utilization (network bandwidth etc.)

Step 2: When you are ready to process the results of the above command, run the following on Windows Powershell console -

PS C:\> wait-job $c

When this commands returns you would have the results in $c.childJobs

Step3: Now you can use the powerful processing and reporting capabilities of Windows Powershell to collate the data just gathered.

Below we are getting Total Physical Memory data from all the machines and putting it in a CSV file through a Windows Powershell script snippet.

$ShareinfoName = @()

$filename = 'ShareInfo.csv'

foreach ($share in $c.ChildJobs) {

if($share.Output.Count)

{

$ShareinfoName += $share.Output[0] | % {

$_| select @{e={$share.Output[0].TotalPhysicalMemory};n='Name'},

@{e={$share.Output[0].Name};n='TotalPhysicalMemory'}

}

$ShareInfoName | select Name,TotalPhysicalMemory | export-csv -noType $filename

Kapil Mathur [MSFT]

WMI in the cloud

kmathur — Tue, 12 Jan 2010 03:52:00 GMT

Recently I came accross an interesting post which talks about how to use WMI with Windows Azure.

http://blog.wadewegner.com/index.php/2009/11/04/leveraging-wmi-in-an-azure-web-role/

wmic vs WMI Powershell cmdlets

kmathur — Wed, 06 Jan 2010 22:51:00 GMT

Compare WMIC.EXE with Windows Powershell Cmdlets for WMI

The WMI command-line (WMIC) utility provides a command-line interface for WMI. With Windows 7 you can do everything that you can do with wmic using Windows Powershell and much more by leveraging powerful features of Windows Powershell.

Below are some scenarios in wmic and their equivalent in Windows Powershell commands, try them out and compare the results and general experience working with both -

WMIC Version	Windows Powershell Version
wmic bios get caption, manufacturer, smbiosbiosversion, version	get-wmiobject win32_bios caption, manufacturer, smbiosbiosversion, version
wmic logicaldisk where drivetype=3 get name, freespace, systemname, filesystem, size, volumeserialnumber /format:list	get-wmiobject win32_logicaldisk name, freespace, systemname, filesystem, size, volumeserialnu mber -filter drivetype=3
wmic process call create 'notepad.exe'	invoke-wmimethod win32_process -name create -argumentlist 'notepad.exe'
wmic /node:<machine name> /user:<username>/password:<password> logicaldisk where drivetype=3 get name, freespace, filesystem, size	Get-wmiobject -ComputerName <machine name> -credential <remote credentials> win32_logicaldisk name, freespace, systemname, filesystem, size, volumeserialnumber -filter drivetype=3
WMIC PROCESS where name='notepad.exe' delete	gwmi win32_process -filter "name='notepad.exe'" \| remove-wmiobject
wmic ENVIRONMENT SET NAME="TEMP", VARIABLEVALUE="NEW" , username="<system>"	gwmi win32_environment -filter 'Name="testvar" and username="<system>"' \| set-wmiinstance -argument @{variableValue="testvalue"}

This post talks about some other reasons why using powershell is a good idea if you are working with WMI

Kapil Mathur [MSFT]

Using "within" in a WMI event query

kmathur — Mon, 28 Dec 2009 21:59:00 GMT

What happens when we don't specify a "within" interval in a WQL notification query with an intrinsic event class name?

For example:

SELECT * FROM __InstanceCreationEvent

WHERE TargetInstance ISA 'Win32_NTLogEvent' AND

TargetInstance.LogFile = 'System' AND

TargetInstance.EventCode = '1007'

The WITHIN interval is only required if there isn’t a real WMI Event Provider that supports that event class. In the case of the NTEventLog WMI Provider, it’s a real event provider, meaning that the events are not polled, they are pushed. So events come in as they happen.

For a general overview of WMI eventing you could visit this page.

Kapil Mathur [MSFT]

Finding out which machines are Laptops in a domain

kmathur — Mon, 14 Dec 2009 19:30:00 GMT

Say you want to provision some settings only on all laptops in your corporate domain. The problemthough is, how do you identify which computers ones are laptops?

WMI Class win32_systemEnclosure has a property - ChassisTypes. ChassisTypes is 9 in a laptop.

Addtion based on reader feedback: ChassisTypes might not be 9 always, on some machines you'll see 8 (portable), 9 (notebook) as well. It is also a good idea to look for batteries as well using win32_battery class.

ChassisTypes

Data type: uint16 array

Access type: Read-only

Array of chassis types. This property is inherited from CIM_Chassis.

Value	Meaning
1	Other
2	Unknown
3	Desktop
4	Low Profile Desktop
5	Pizza Box
6	Mini Tower
7	Tower
8	Portable
9	Laptop
10	Notebook
11	Hand Held
12	Docking Station
13	All in One
14	Sub Notebook
15	Space-Saving
16	Lunch Box
17	Main System Chassis
18	Expansion Chassis
19	SubChassis
20	Bus Expansion Chassis
21	Peripheral Chassis
22	Storage Chassis
23	Rack Mount Chassis
24	Sealed-Case PC

Details on win32_systemenclosure

http://msdn.microsoft.com/en-us/library/aa394474(VS.85).aspx

Kapil Mathur [MSFT]

CIM 101

kmathur — Mon, 07 Dec 2009 18:35:00 GMT

The CIM is an information model, a conceptual view of the managed environment, that attempts to unify and extend the existing instrumentation and management standards (SNMP, DMI, CMIP, etc.) using object-oriented constructs and design. WMI uses the Common Information Model (CIM) industry standard to represent systems, applications, networks, devices, and other managed components. So if you use WMI or winrm in any way, you will encounter CIM.

Wbemsolutions.com has a nice tutorial on CIM. Check it out!

Kapil Mathur [MSFT]