Benp's Guide to Stuff : wmi

Scripting Hyper-V with WMI and PowerShell: Part 1 – Introduction + Querying State

benp — Mon, 11 Aug 2008 18:37:00 GMT

Scripting Hyper-V with WMI and PowerShell

Part 1 – Introduction + Querying State

Introduction

When it comes to scripting Hyper-V there are really 2 methods:

1. Using the virtualization WMI provider that ships with Hyper-V.

2. Using the cmdlets provided by System Centre Virtual Machine Manager 2008

So which option should you use? Well if you want an easy life, the answer is absolutely Option 2. Use SCVMM 2008, and scripting Hyper-V is like a pleasurable dream. The cmdlets are task orientated, provide a rich set of features and really do work very well. So why is this a guide to Option 1 – Using the virtualization WMI provider? Well, sometimes Hyper-V will be used without an accompanying System Centre deployment, and if that’s the case, using WMI is your only scripting option.

I`ll be honest, using the WMI provider to script Hyper-V is unintuitive, complicated and feels quite clunky. So the question has to be asked “Why is the Hyper-V WMI provider so difficult to use?” The answer is Industry Standards. The virtualization WMI provider fully complies with the standards outlined by the Distributed Management Task Force (DMTF). Whilst standards are great for creating consistency among different vendors, there are often comprises with the simplicity of individual solutions. Contrastingly the SCVMM cmdlets are a bespoke solution designed by Microsoft to be simple, intuitive and powerful, but do not adhere to any industry standards.

So, with the expectation that the Hyper-V WMI journey will be a challenging one, let’s get on with it.

WMI Basics

As mentioned we will be using the virtualization WMI provider, and before going any further I would strongly recommend that you spend some time understanding WMI to a reasonable depth. If you can answer the following questions, you’re probably familiar enough with WMI to get the most out of this tutorial:

1. What is namespace?

2. What is a class?

3. How do you create a WMI Object in PowerShell?

Basic WMI information is out of scope for this tutorial, so if you can’t answer the above questions, before continuing I would suggest the following pre-reading/viewing:

1. Brief WMI Intro on Technet Edge - http://edge.technet.com/Media/Powershell-tips-and-tricks-from-the-field-with-Ben-Pearce

2. Windows, PowerShell and WMI – Tech Ed 2008 Session http://www.microsoft.com/emea/spotlight/sessionh.aspx?videoid=996

3. Microsoft Windows PowerShell Step by Step Book- http://www.microsoft.com/MSPress/books/10329.aspx

Hyper-V + WMI

There are 2 key points you need to understand to start using the Hyper-V WMI provider.

1. All Hyper-V classes live in the “Virtualization” namespace. Therefore whenever you want to instantiate an object you need to specify this namespace. The following sample lists all the classes available in this namespace:

Get-WMIObject –namespace “root\virtualization” -list

2. PowerShell must be elevated and running as an administrator. If you run PowerShell in a non-administrative context you will not be able to connect to any guests, and will only be able to affect the host. In Server 2008 you need to right-click the PowerShell icon, then click “Run As Administrator” to achieve this, even if logged on as an administrator.

VMStateQuery

Often, I find the best way to learn something is with a worked example. Attached to this post is VMStateQuery.ps1, which is an example PowerShell script which can be used to determine the state of guests deployed to a Hyper-V host. The script can be used to return the state of all guests on a host, or the state of 1 particular guest.

Usage

.\VMStateQuery.ps1

This returns a list of all guests and their state, sorted alphabetically.

.\VMStateQuery.ps1 -vhost myremotehost -sortbystate

This returns a list of all the guests on MyRemoteHost, and sorts the guests by state.

.\VMStateQuery.ps1 –vhost myremotehost –vguest MyGuest1

This returns the state of the guest MyGuest1, running on the host MyRemoteHost.

Explanation

Let’s dig into some interesting parts of this script.

The only time we use WMI in this example is in this 1 line:

$vms = Get-WMIObject -Class Msvm_ComputerSystem -Namespace "root\virtualization" -ComputerName $vhost

This line connects using WMI and retrieves all instances of MSVM_ComputerSystem on the computer specified by $VHost. This line returns an array of all guests and the host, each one represented by an object. In order to find out what we can with this object type we can do two things. Firstly, use Get-Member to obtain all properties and methods, or use this MSDN link, which details each property and method.

Having looked at the properties of this object we can see 2 properties that will be particularly useful when trying to query a guest’s state: elementname and enabledstate. ElementName is the name of the guest that you see in the Hyper-V MMC console, and enabledstate is a number that represents the state of the machine.

This bit of code filters our array of guests, and returns any that match the following

$vms = $vms | where-object {$_.elementname -eq $vguest}

We simply use where-object to filter, such that only guests whose elementname equals $vguest are retained.

We use the enabledstate property to identify the state of the machine. However, the state of the machine is a number which might not make too much sense. Therefore I’ve created a function called ConvertStateToFriendly which simply uses a switch statement to return a friendly word for the state. The call to this function is nested as an expression that can be used by the format-table cmdlet to display the information nicely. Here’s the code:

$statefriendly = @{Expression={convertStateToFriendly $_.enabledstate};Label="State";width=25}

$vms | format-table Elementname, $statefriendly

This code looks a little bid nasty, but is simply a way of creating custom tables. More details on how this mechanism works can be found here.

One final part I want to explain is this line:

$vms = $vms | where-object{$_.caption -ne "Hosting Computer System"}

When you get all instances of MSVM_ComputerSystem, one of the returned objects represents the host system. In this script I am not really interested in the state of the host, just the state of the guests. Therefore the above line simply looks at the caption property of the objects, and drops the object with the name “Hosting Computer System”.

All the rest of the script is generic PowerShell code, used for parameters, error checking and other useful bits and pieces.

Hyper-V WMI Resources

The two best resources for Hyper-V WMI scripting that I have come across so far are the MSDN page, and James O’Neil’s Hyper-V management library on CodePlex. The MSDN page is the definitive source on the WMI provider and is here:

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

The Code Plex project which James uploaded is a pretty comprehensive library on managing Hyper-V and WMI. It’s an excellent source, but be warned it is pretty hardcore and very code efficient in places, which can sometimes be quite tricky to understand (maybe that’s just me J)

http://www.codeplex.com/PSHyperv

My colleague Richard Macdonald has written a very similar script, but using C# instead of PowerShell. Check out his blog here for the code.

Well that’s it for part 1. Stay tuned for Part 2 –Hyper-V Data Gathering.

Enjoy

BenP

Inteverview with me on Technet Edge

benp — Mon, 23 Jun 2008 22:01:00 GMT

Hi All

I got kidnapped by the Tech Net Edge guys whilst I was at Tech Ed the other week, and intereviewed about the PowerShell and WMI session that I was presenting there. If you'd like to see the interview in full it's here:

http://edge.technet.com/Media/Powershell-tips-and-tricks-from-the-field-with-Ben-Pearce/

You might need to use "the force" whilst watching the demos, as sadly some of the commands I was using were slightly off the screen.

Have fun

BenP

Tech Ed 2008 - Demo 5 - Administering Failover Clustering

benp — Thu, 12 Jun 2008 21:02:00 GMT

Finally, here is the last demo.

Demo 5 – Administering Failover Clustering

I have already written a detailed post, and a similar script on this subject, here. However, I promised all the demos would be on my blog, so attached is the exact script I used at Tech Ed 2008.

Enjoy!

BenP

Tech Ed 2008 - Demo 4 - Administering Hyper-V

benp — Thu, 12 Jun 2008 21:01:00 GMT

So here is Demo 4 – Administering Hyper-V

I am planning to put more posts on my blog, looking at this subject in more depth, so stay tuned for more in depth demos. This was is what I demo’d at Tech Ed 2008. Notice the namespace that is used:

Gwmi –namespace “root\virtualization” –list

Gwmi –namespace “root\virtualization” –class msvm_computersystem | get-member

Gwmi –namespace “root\virtualization” –class msvm_computersystem | format-table elementname, enabledstate

Thanks

BenP

Tech Ed 2008 - Demo 3 - How do I Know Which Classes to Use

benp — Thu, 12 Jun 2008 20:52:00 GMT

Ola

Demo 3 – How Do I Know Which Classes to Use

In this demo I firstly used WMI Browser, which provides a GUI that can be used to visually display WMI information. That can be downloaded from here:

I then browsed for classes in PowerShell. I have already documented this on my blog and it can be found here:

Phew, that was a short post.

Enjoy!

BenP

Tech Ed 2008 - Demo 2 - Administering Servers in Bulk

benp — Thu, 12 Jun 2008 20:39:00 GMT

Bonjour Bonjour

It’s time for Demo 2 – Administering Servers in Bulk. I’ve attached the 4 scripts that I used.

Demo 2 – Administering Servers in Bulk

BulkServers1.ps1 – This script reads in a text file, containing 1 server per line. It simply then writes the server names back to the console

BulkServers2.ps1 – This script extends the first script and simply gets the hostname, operating system and service pack level for each server listed in the input file.

BulkServers3.ps1 – This script gets a little bit more complex and in fact is rather exciting. It again reads an input file and for each server, gets operating system information, bios information, writes this to a CSV file and then opens the csv file in your default CSV file handler.

BulkServers4.ps1 – The piece de resistance! This script is very similar to the above script, except that rather than read an input file with server names, it connects to the Domain Controller container in the Active Directory, and gets information from all computers in that container.

Please note, there is no error checking in these scripts, and are purely working illustrations. I would flesh these scripts out a bit more before I used them in anything other than a test infrastructure.

All done, stay tuned for Demo 3 – How Do I Know Which Classes to Use

That is all.

BenP

Tech Ed 2008 - Demo 1 - Administering Windows

benp — Thu, 12 Jun 2008 20:33:00 GMT

Hello Again

Well I’ve delivered my session “Windows, PowerShell and WMI: Unveiling Microsoft’s Best Kept Secret”, and as promised here are the scripts for the Demo’s I used during my session:

Demo 1 – Administering Windows

All these demos are simple command lines that I just typed straight in PowerShell, no need for any fancy scripts.

Basics

The following lines of code show help on how to use the Get-WMIObject cmdlet in PowerShell, how to list all classes in the cimv2 namespace and finally how to use some basic parameters.

Get-Help -name Get-WMIObject

Get-Help -name Get-WMIObject –det

get-wmiobject -namespace "root\cimv2" –list

Gwmi -namespace "root\cimv2" –list

Gwmi -namespace "root\cimv2" -class Win32_LogicalDisk

Gwmi -class Win32_LogicalDisk

Gwmi Win32_LogicalDisk

Gwmi Win32_LogicalDisk –computername localhost

$cred = get-credentials

Gwmi Win32_LogicalDisk –credential $cred

Disks

These lines of code show how to get disk information from a system, identify all the properties and methods of the disk objects that can be used, then uses some properties.

Gwmi Win32_LogicalDisk | Get-Member

$disks = gwmi Win32_LogicalDisk –computername localhost

$disks[0].freespace

$disks[0].freespace/1gb

$disks[0].filesystem

Hotfixes

These lines connect to a system and list all the Hotfixes that have been installed.

$hotfixes = gwmi Win32_QuickFixEngineering –computername localhost

$hotfixes | get-member

$hotfixes | format-table Hotfixid

OperatingSystem

These lines enumerate basic operating system information: the OS version, service pack level and OS architecture type.

$os = gwmi win32_OperatingSystem -computername Serverxxx

$os | get-member

$os | format-list caption, CSDVersion,OSArchitecture

Network Adapter

The following lines modify the IP Address and Subnet Mask of a network adapter using the EnableStatic method.

$nics = Gwmi win32_NetworkAdapterConfiguration

$nic = $nics | where{$_.description –like “*XXXXXXXXXXXX*”}

$IPAddress = x.x.x.x

$subnetmask = x.x.x.x

$nic.EnableStatic($IPAddress, $SubnetMask)

Well that’s the first demo stay tuned for Demo 2 – Administering Servers in Bulk.

Enjoy!

BenP

Listing WMI Namespaces installed on a host

benp — Tue, 29 Jan 2008 14:06:00 GMT

Ladies and Gents

Many months ago I posted a script on how to search a namespace for different classes. The post is here

A common question I then get asked is “How do I know what WMI namespaces are installed on a system?” The answer is not immediately obvious so I thought I’d share it with you all.

Get-WMIObject -class __Namespace -namespace root | Format-Table name

I get the following output from my Vista RTM machine.

name

----

subscription

DEFAULT

MicrosoftDfs

CIMV2

Cli

Nap

SECURITY

SmsDm

RSOP

ccm

WMI

Searching WMI

benp — Fri, 15 Jun 2007 15:49:00 GMT

Ladies and Gents

A lot people have been asking me: “How do I know if there is a WMI provider for xxxx?”. Quite often a quick search in live.com will get you the results, but there is a way of searching WMI from within PowerShell. I have created a really simple script that allows me to search the CIMV2 namespace really easily. Here’s the script:

$text = $Args[0]

write-host

"Searching Namespace: root\cimv2 ...... "

$Results = gwmi -namespace "root\cimv2" -list | where-object {$_.name -like ("*" + $text + "*")}

if ($Results -eq $Null)

{

write-host

write-host "No Matches for:" $Text

write-host

}

else

{

write-host

write-host "Class"

write-host "-----"

write-host

foreach ($Class in $Results)

{

write-host $Class.Name

}

write-host

}

The code to do the searching is 1 line and simply uses where-object to filter the root\cimv2 namespace. The rest is just for iterating round the collection of $Results and formatting it nicely. I know I could write this in a 1 liner each time I wanted to search WMI, but I`m lazy. Using this I can concentrate on WMI which is tough enough and not have to think about how to search it J

I then create a function that hooks to this script. I put the following line in my profile in order to do this:

new-item -path function:search-cimv2 -value {& 'C:\scripts\search-cimv2.ps1' $Args[0]}

Simply type in search-cimv2 disk and it will return all the WMI classes in the CIMV2 namespaces that contain the text ”Disk”. Note the use of * in the script that means it will fine the text anywhere in the class name.

Hope this helps

BenP

Tech-Ed 2007 - Top 5 PowerShell Questions

benp — Fri, 08 Jun 2007 00:16:00 GMT

Ladies + Gents

This week I have had the privilege of working at TechEd 2007. I’ve been on the PowerShell demo stand in the Technical Learning Centre and talking to what feels like most of the 12000 attendees about how cool PowerShell is. It probably doesn’t surprise you to hear there were some really common questions, so I thought I’d list my top questions and answers:

1. How can I learn PowerShell?

Well I can only speak from my personal experience. When I was just beginning with PowerShell I came across “PowerShell Week”, a series of webcasts put together by The Scripting Guys. This series includes 5 webcasts which take you from the very basics of PowerShell to some pretty cool stuff. The webcasts can be found here and are pretty awesome:

http://www.microsoft.com/technet/scriptcenter/webcasts/ps.mspx

What about books?!? I personally own 2 PowerShell books which I think are great. The first one is more of a tutorial book and is called “Windows PowerShell Step by Step” by Ed Wilson. This is great book for those just starting out with PowerShell. Find out more about the book here:

http://www.microsoft.com/MSPress/books/10329.aspx

The other book I have is the daddy of all PowerShell books. It’s called “PowerShell in Action” by Bruce Payette. It’s a meaty book which I continuously refer to. If you really need to know the answer to something about PowerShell it’s probably in this book. Find out more about it here:

http://www.manning.com/payette/

Finally, print out the PowerShell cheat sheet, laminate it and leave it by PC. Whenever you forget some syntax, grab the sheet for instant memory recall. Links here in 2 formats:

Word 2007 Format

http://blogs.msdn.com/powershell/archive/2007/01/24/powershell-cheat-sheet.aspx

PDF Format

http://blogs.msdn.com/powershell/archive/2007/01/25/powershell-cheat-sheet-redux-the-pdf-version.aspx

2. Can I script the active directory?

The answer to this is yes! I have seen some great PowerShell scripts that do some really cool stuff with AD. I’ve already written quite a bit about this on my blog. Check out the following 3 archived blogs for more detailed information:

Guide to Managing the AD with PowerShell

http://blogs.technet.com/benp/archive/2007/03/05/benp-s-basic-guide-to-managing-active-directory-objects-with-powershell.aspx

Searching the AD with PowerShell

http://blogs.technet.com/benp/archive/2007/03/26/searching-the-active-directory-with-powershell.aspx

Creating an AD Shell with PowerShell

http://blogs.technet.com/benp/archive/2007/04/10/creating-an-ad-shell.aspx

3. Does PowerShell work against remote hosts?

The answer to this is yes and no. There is no native support to run any cmdlet against a remote host. For example I cannot say:

get-service –computername server1

Cmdlets generally only work on the computer that they are executed on. However, some cmdlets (for example Get-WMIObject) can be run against remote hosts. The Get-WMIObject cmdlet itself has inbuilt support to connect to remote hosts, and use the WMI providers that are running on them.

This means that you can run any scripts that use WMI against remote hosts. The following line would get the running services on a remote computer :

Get-WMIObject Win32_Service –computername Server1

WMI is not a new technology; it’s a mature technology that has been installed out of the box since Windows 2000. This means that you can use PowerShell to remotely administer boxes, as long there is a WMI provider that allows you do this. There are hundreds and hundreds of WMI providers, so the chances are you can do what you want using WMI.

4. Does PowerShell install on Windows 2008 Server Core?

In Windows Server 2008 Beta 3, the answer is no. PowerShell requires the .Net framework to be installed. The .Net framework will not install on Server Core. It won’t install because there are many components of the .Net framework that require Windows features installed, that are no installed in Server Core. For example there is no GUI in Server Core, and therefore none of the GUI .Net components could ever work. So the .Net framework is not available in Server Core and therefore PowerShell is not available.

5. Can I call PowerShell cmdlets from my own custom app?

Yes you can. Whether it is an ASP.Net application, or standard exe you can hook into PowerShell and run cmdlets. You need to host a PowerShell Runspace in your application, MSDN has loads of information on how you can do this. The first link below is the MSDN PowerShell homepage, the 2^nd link introduces the concept of hosting PowerShell runspaces in applications:

MSDN PowerShell Home

http://msdn2.microsoft.com/en-us/library/aa139691.aspx

PowerShell Runspace

http://msdn2.microsoft.com/en-us/library/ms714459.aspx

Well, that’s it for now. The TechEd 2007 party starts in a couple of hours, and I need a beer.

That is all

Benp

Clustering Best Practices: Using PowerShell to Check Hotfix Compliance

benp — Tue, 15 May 2007 16:40:00 GMT

So Guys + Gals

As well as writing PowerShell scripts and running a PowerShell course here in the UK, I spend a lot of time looking at clusters. I go to customers and run a cluster health check to make sure that their cluster adheres to best practices. Lots of what I do involves manual checking of various values, so I thought I would write some PowerShell scripts to automate some of this checking.

So for the next few posts I am going to post some scripts to check that certain aspects of a high availability cluster adhere to best practice.

My friend and colleague Richard Macdonald is doing exactly the same thing but in VBScript (boo ... hisss). Check out his similar version(s), but in VBScript.

http://blogs.technet.com/richard_macdonald/archive/2007/05/03/879029.aspx

Checking Hotfix Compliance

What does this script do? It checks whether the recommended hotfixes that should be installed on a cluster are installed on each node. With high availability systems it’s crucial that all nodes are patched consistently, and they are patched with the latest fixes.

Check out the following KB’s for a list of fixes for each Operating System and Service Pack level.

Windows 2000 – Service Pack 4

http://support.microsoft.com/kb/895090

Windows 2003 -RTM

http://support.microsoft.com/kb/895092/

Windows 2003 – Service Pack 1

http://support.microsoft.com/kb/923830/

Windows 2003 – Service Pack 2

http://support.microsoft.com/kb/935640/

How to use this script

Firstly, download the script. It is attached to this blog in a zip file.

This script takes the cluster name, and text file with listed fixes as arguments. E.g.

.\Check-ClusHotfix.ps1 MyCluster Fixes-Win2k3-SP1.txt

This will create some output on the screen, and a tab delimited file which can be manipulated easily in Excel if needed. It tells you exactly what fix is installed on each node. You do not need to run this script on the cluster, just on a workstation which has RPC access to the cluster nodes.

How this script works

It reads in a txt file with a list of fixes, then queries each node in the cluster to ascertain if the fix is installed. It writes the output to screen and creates a csv file with the output.

In order to get this working I have used the Cluster WMI provider. More details on the cluster WMI provider can be found here:

http://msdn2.microsoft.com/en-us/library/aa372876.aspx

I won’t explain the whole script, however these are some the key parts that are worth looking at in detail.

$AllNodes = Get-WmiObject -class MSCluster_Node -namespace "root\mscluster" -computername $ClusterName

This returns a collection of cluster nodes. In order to make sure we connect to each node in the cluster, we can use a foreach loop.

foreach ($Node in $AllNodes)

Then with each node we can use the WMI class Win32_QuickFixEngineering to get the installed fixes.

$InstalledFixes = Get-WmiObject -class "Win32_QuickFixEngineering" -namespace "root\CIMV2" -computername $Node.Name

All we then do is loop through each hotfix from the text file and run the following command. $Checklist is created by using get-content and is an array of text lines. This is the collection that we loop through

$FixInstalled = $InstalledFixes | where-object {$_.HotfixID -like '*' + $checklist[$i] + '*'}

We then just write out results to a 2 dimensional array which mimics a table, which we can output at the end.

The actual code that does the useful stuff is very small, the rest of it is basic error checking and formatting the output. Attached is a zip file with the script and some text files for checking various systems.

Please, please make sure you test this in a non-production environment before you run it against your production cluster. Never run anything on a cluster unless you are 110% confident that it is fine to do so.

If you have any questions or feedback, just give me a shout.

That is all.

BenP