Windows Virtualization Team Blog : WMI, Hyper-V

Hyper-V WMI – Startup-Shutdown-Recover/Snapshots/Error Messages

Taylorb — Thu, 19 Jun 2008 07:36:51 GMT

On Saturday I posted that I have started my own blog and promised to provide summery post to this blog for a while… There are new three posts at http://blogs.msdn.com/taylorb that are not on this blog.

Hyper-V WMI – Configuring Automatic Startup/Shutdown/Recovery Action’s For Virtual Machines

Hyper-V WMI: Creating/Applying/Deleting Virtual Machine Snapshots

Hyper-V WMI: Rich Error Messages for Non-Zero ReturnValue (no more 32773, 32768, 32700…)

Thank’s and Happy Virtualizing!

Taylor Brown
Hyper-V Integration Test Lead
http://blogs.msdn.com/taylorb

Hyper-V WMI – Cloning Virtual Machines Using Import/Export

Taylorb — Sun, 08 Jun 2008 00:38:55 GMT

I have officially given up on the “Hyper-V WMI Using PowerShell Scripts” serious, not because of lack of interest but because or extreme interest implying that I would need to do Part 5, 6, 7, 99… Counting past 5 is hard so from now on I will just title the posts for what they are doing. Today’s post is going to be an end-to-end script to create 10 clones of a given VM.

Here’s a quick tour of the script…

This script takes 4 parameters:
     MasterVM – this is the name of the VM that will be cloned
     Path – this is the base path where the clones will reside
     NewName – this is what the cloned VM’s will be named
     HyperVHost – this is the name of the host that the script will execute against

The function ProcessWMIJob takes the return of a WMI method call and then processes the job waiting for the job to complete and throwing an exception if the job failed.

The main part of the script retrieves the Msvm_VirtualSystemManagmentService class and the MasterVM’s Msvm_ComputerSystem. It then loops 10 times, first changing the name of the VM and then exporting the VM and finally re-importing the VM. After it completes the 10 interactions it restores the name of original name of the MasterVM.

param
(
    [string]$MasterVM = $(Throw "MasterVM required"),
    [string]$Path = $(Throw "Path required"),
    [string]$NewName = "VMCopy",
    [string]$HyperVHost = "localhost"
)

function ProcessWMIJob
{
    param
    (
        [System.Management.ManagementBaseObject]$Result
    )

    if ($Result.ReturnValue -eq 4096)
    {
        $Job = [WMI]$Result.Job

        while ($Job.JobState -eq 4)
        {
            Write-Progress -Id 2 -ParentId 1 $Job.Caption -Status "Executing" -PercentComplete $Job.PercentComplete
            Start-Sleep 1
            $Job.PSBase.Get()
        }
        if ($Job.JobState -ne 7)
        {
            Write-Error $Job.ErrorDescription
            Throw $Job.ErrorDescription
        }
    }
    elseif ($Result.ReturnValue -ne 0)
    {
        Throw $Result.ReturnValue
    }
    Write-Progress $Job.Caption -Status "Completed" -PercentComplete 100 -Id 2 -ParentId 1
}

#Main Script Body
$VMManagementService = Get-WmiObject -Namespace root\virtualization -Class Msvm_VirtualSystemManagementService -ComputerName $HyperVHost
$SourceVm = Get-WmiObject -Namespace root\virtualization -Query "Select * From Msvm_ComputerSystem Where ElementName='$MasterVM'" -ComputerName $HyperVHost
$a = 0

while ($a -lt 10) {
    write-progress -Id 1 "Cloning Vm's" -Status "Executing" -percentcomplete (($a / 10)*100)
    $tempVMName = "$NewName - $a"
    $VMSettingData = Get-WmiObject -Namespace root\virtualization -Query "Associators of {$SourceVm} Where ResultClass=Msvm_VirtualSystemSettingData AssocClass=Msvm_SettingsDefineState" -ComputerName $HyperVHost
    $VMSettingData.ElementName = $tempVMName

    $Result = $VMManagementService.ModifyVirtualSystem($SourceVm, $VMSettingData.PSBase.GetText(1))
    ProcessWMIJob $Result

    $Result = $VMManagementService.ExportVirtualSystem($SourceVm, $TRUE, "$Path")
    ProcessWMIJob $Result

    $Result = $VMManagementService.ImportVirtualSystem("$Path\$tempVMName", $TRUE)
    ProcessWMIJob $Result

    $a ++
}

write-progress -Id 1 -Completed $TRUE -Activity "Cloning Vm's"
$VMSettingData = Get-WmiObject -Namespace root\virtualization -Query "Associators of {$SourceVm} Where ResultClass=Msvm_VirtualSystemSettingData AssocClass=Msvm_SettingsDefineState" -ComputerName $HyperVHost
$VMSettingData.ElementName = $MasterVM

$Result = $VMManagementService.ModifyVirtualSystem($SourceVm, $VMSettingData.PSBase.GetText(1))
ProcessWMIJob $Result

- Taylor Brown
- Hyper-V Test Team

Hyper-V WMI Using PowerShell Scripts – Part 5

Taylorb — Tue, 27 May 2008 09:31:06 GMT

I hope everyone had a great Memorial Day weekend – we had a four day weekend on the Hyper-V team which was excellent! In this post I am going to show how to create a new virtual switch attached to an external network. I’ll start with a complete script and then take it apart and explain what each part is doing.

$VirtualSwitchService = get-wmiobject -class "Msvm_VirtualSwitchManagementService" -namespace "root\virtualization"
$ReturnObject = $VirtualSwitchService.CreateSwitch([guid]::NewGuid().ToString(), "New External Switch", "1024","")

#Create New Virtual Switch
$CreatedSwitch = [WMI]$ReturnObject.CreatedVirtualSwitch

#Create Internal Switch Port
$ReturnObject = $VirtualSwitchService.CreateSwitchPort($CreatedSwitch, [guid]::NewGuid().ToString(), "InternalSwitchPort", "")
$InternalSwitchPort = [WMI]$ReturnObject.CreatedSwitchPort

#Create External Switch Port
$ReturnObject = $VirtualSwitchService.CreateSwitchPort($CreatedSwitch, [guid]::NewGuid().ToString(), "ExternalSwitchPort", "")
$ExternalSwitchPort = [WMI]$ReturnObject.CreatedSwitchPort

$ExternalNic = get-wmiobject -namespace "root\virtualization" -Query "Select * From Msvm_ExternalEthernetPort WHERE IsBound=False"

#Call SetupSwitch
$Job = $VirtualSwitchService.SetupSwitch($ExternalSwitchPort, $InternalSwitchPort, $ExternalNic, [guid]::NewGuid().ToString(), "InternalEthernetPort")
while (([WMI]$Job.Job.JobState -eq 2) -or ([WMI]$Job.Job.JobState -eq 3) -or ([WMI]$Job.Job.JobState -eq 4)) {Start-Sleep -m 100}
[WMI]$Job.Job

Before explaining the elements of the script, I think it’s important to explain a little about Hyper-V’s networking model. Hyper-V’s networking model attempts to be a similar to a real network, there are virtual switches, virtual switch ports and network adapters. When you create a new external virtual network you are actually creating a virtual switch, an internal and external switch port and a virtual network adapter on the host.

So let's look at the script above section by section.

Section 1 - Creating The Switch

Create New Virtual Switch
$CreatedSwitch = [WMI]$ReturnObject.CreatedVirtualSwitch

This section get's the Msvm_VirtualSwtichManagmentService, this is similar to other management service classes like msvm_imagemanagmentsevice. The second line creates the switch, the first parameter to this function is the switch name, typically a guid is a good unique name, the second parameter is the friendly name (what you will see in the UI), the third parameter is the number of learnable addresses in the switch, the last parameter the AzMan scope name (I'll talk more about those in a later post). The third line retrieves the WMI object for the created switch.

Section 2 - Creating Switch Ports

This section creates the internal and external switch ports, think of these as the ports on a physical switch that you would attach to your PC or Modem. In both cases we are calling the CreateSwitchPort method. The first parameter is switch we created in the previous section, the second parameter is the switch port name again we using a guid, the third the friendly name this name does not have to be unique and can be anything you want, and the final parameter again is the AzMan scope. We again retrieve the created switch port's as WMI objects.

Section 3 - Retrieving External Ethernet Connection

$ExternalNic = get-wmiobject -namespace "root\virtualization" -Query "Select * From Msvm_ExternalEthernetPort WHERE IsBound=False"

This section retrieves the external Ethernet port think of this as the port on the modem or the actual network adapter on the physical machine. This query should return only one adapter, in the query above I select all adapters on the machine that are not already bound to a switch (hence the IsBound=False) so if I had two network adapters that not bound this query would need to be more specific. You'll need to figure out what your criteria will be try running "get-wmiobject -namespace "root\virtualization" -Query "Select * From Msvm_ExternalEthernetPort" this will return all of the information available to query against.

Section 4 - Bringing It All Together

$Job = $VirtualSwitchService.SetupSwitch($ExternalSwitchPort, $InternalSwitchPort, $ExternalNic, [guid]::NewGuid().ToString(), "InternalEthernetPort")

while (([WMI]$Job.Job.JobState -eq 2) -or ([WMI]$Job.Job.JobState -eq 3) -or ([WMI]$Job.Job.JobState -eq 4)) {Start-Sleep -m 100}
[WMI]$Job.Job

This final section bring's it all together. The SetupSwitch method takes the WMI objects for the switch, switch ports, external Ethernet port as well as a name and friendly name and binds all the switch port's together. Up to this point if you looked in the Hyper-V Network Manger you would see your switch but it would be a private switch; after this it will be an external switch. The last two lines just wait for the returned WMI object to complete and then prints out the object.

That's it! You now have an external network.

- Taylor Brown
- Hyper-V Test Team

Hyper-V WMI Using PowerShell - Part 4 and Negative 1

Taylorb — Wed, 21 May 2008 10:10:00 GMT

I hope everyone is enjoying Hyper-V RC1 (yep I just linked to my own post -shamless maybe) but, as promissed here's some more WMI goodness.

Title got your attention? Well this is a two part post… First I will show how to use the Shutdown IC to initiate a shutdown of a guest using PowerShell (that's part 4) Ok so why Negative 1? Well what did we do before PowerShell (yeah yeah vbscript but go with me) one option was C# so Part Negative 1 is a C# Example…

Here’s the PowerShell to shutdown a VM named “Vista”… Just like previous examples, we get the Msvm_ComputerSystem… then we use the Associators of query to get the Msvm_ShutdownComponent associated with that VM. Then we just call InitiateShutdown, the first parameter is wether to force a shutdown (like running shutdown /f inside the virtual machine) and the second is the reason for the shutdown. It really is that simple.

$Vm = Get-WmiObject -Namespace root\virtualization -Query "Select * From Msvm_ComputerSystem Where ElementName='Vista'"

$ShutdownIC = Get-WmiObject -Namespace root\virtualization -Query "Associators of {$Vm} Where AssocClass=Msvm_SystemDevice ResultClass=Msvm_ShutdownComponent"

$ShutdownIC.InitiateShutdown("TRUE", "Need to shutdown")

And here’s the same code in C#…

using System;
using System.Collections;
using System.Text;
using System.Management;


namespace ShutdownViaIC
{
    class Program
    {
        static void Main(string[] args)
        {
            //Connect to the Remote Machines Management Scope
            ConnectionOptions options =  new ConnectionOptions();
            ManagementScope scope = new ManagementScope(@"\\localhost\root\virtualization"); scope.Connect();

            //Get the msvm_computersystem for the given VM (Vista)         
            ManagementObjectSearcher searcher = new ManagementObjectSearcher(scope,
                new ObjectQuery("SELECT * FROM Msvm_ComputerSystem WHERE ElementName = 'Vista'"));

            //Select the first object in the Searcher collection
            IEnumerator enumr = searcher.Get().GetEnumerator();
            enumr.MoveNext();
            ManagementObject msvm_computersystem = (ManagementObject)(enumr.Current);

            //Use the association to get the msvm_shutdowncomponent for the msvm_computersystem
            ManagementObjectCollection collection = msvm_computersystem.GetRelated("Msvm_ShutdownComponent");
            ManagementObjectCollection.ManagementObjectEnumerator enumerator = collection.GetEnumerator();
            enumerator.MoveNext();
            ManagementObject msvm_shutdowncomponent = (ManagementObject)enumerator.Current;

            //Get the InitiateShudown Parameters
            ManagementBaseObject inParams = msvm_shutdowncomponent.GetMethodParameters("InitiateShutdown");
            inParams["Force"] = true;
            inParams["Reason"] = "Need to Shutdown";

            //Invoke the Method
            ManagementBaseObject outParams = msvm_shutdowncomponent.InvokeMethod("InitiateShutdown", inParams, null);
            uint returnValue = (uint)outParams["ReturnValue"];

            //Zero indicates success
            if (returnValue != 0)
                Console.WriteLine("SHUTDOWN Failed");            
        }
    }
}

PowerShell like most scripting languages can do simple tasks well simply, but your power and control is limited… This is still the case with PowerShell the code to initiate this shutdown is dead simple in PowerShell and all of three lines, you have more ‘using’ lines than that in the C# code… However when it comes to writing more complex solutions like a Windows service that monitors Hyper-V and implements some custom business logic C# is a great choice… (it’s what the Hyper-V UI is written in).

--Taylor Brown
--Hyper-V test team

Hyper-V WMI Using PowerShell Scripts – Part 3

Taylorb — Tue, 06 May 2008 19:14:00 GMT

In part 1 we went over basic scripts and tools for gathering some generic information about virtual machines and in part 2 we went over VHD creation and WMI job’s. In part 3 I am going to cover getting more detailed information about a guest operating system by using the KVP Exchange integration component. KVP stands for Key Value Pair this is a service that runs in the guest operating system and allows some limited information to be passed from the guest to the host or parent and vice-verse. For now we are going to focus only on the intrinsic KVP’s these are provided by default on virtual machines that have the integration components installed. The intrinsic KVP’s include: FullyQualifiedDomainName, OsName, OsVersion, CSDVersion, OsMajorVersion, OsMinorVersion, OsBuildNumber, OsPlatformID, ServicePackMajor, SuiteMask, ProductType, ProcessorArhitecture.

I’ll start with the PowerShell script and results and then explain how to decipher each of the KVP’s values but first I want to thank Ed one of our top notch developers that provided me this script...

In the gray box is the body of the script, it’s a bit different then what we have seen in the past primarily because is what looks like a function at the top. This function looking thing is a PowerShell filter, what the filter does is take a bunch of XML known in WMI as an “embedded instance" and converts it into objects. If you want to see the XML in it’s raw form remove the "|Import-CimXml” from the last line of the script and you’ll see how handy this little filter is.

So what’s happening in this script? I will ignore the filter for a moment so the first line is the the $Vm = Get-Wmi… So the first line should look pretty common now, we are getting a Msvm_ComputerSystem WMI object for a given virtual machine “Server 2008 – Test1". The second line is new, we are running an Association query to get a Msvm_KvpExchangeCompoents WMI object for this VM, associations are an optimization in WMI you can think of them like a SQL join statement “Please give me all of the X that corresponds to Y”. The third line is just taking the GuestIntrinsicExchangeItems property of the Msvm_KvpExchangeCompoents and piping or sending it (that’s the | character) to the Import-CimXml filter that’s written above. Now for the filter, so all this filter is doing is using an XML xpath query to go over each “Instance/Property” node and adding it’s name and value to this CimObj object and then returning that object…

WMIKVP.ps1 PowerShell Script

filter Import-CimXml
{
    $CimXml = [Xml]$_
    $CimObj = New-Object -TypeName System.Object
    foreach ($CimProperty in $CimXml.SelectNodes("/INSTANCE/PROPERTY"))
    {
        $CimObj | Add-Member -MemberType NoteProperty -Name $CimProperty.NAME -Value $CimProperty.VALUE
    }
    $CimObj
}

$Vm = Get-WmiObject -Namespace root\virtualization -Query "Select * From Msvm_ComputerSystem Where ElementName='Server 2008 - Test1'"
$Kvp = Get-WmiObject -Namespace root\virtualization -Query "Associators of {$Vm} Where AssocClass=Msvm_SystemDevice ResultClass=Msvm_KvpExchangeComponent"

$Kvp.GuestIntrinsicExchangeItems | Import-CimXml

Output of the WMIKVP.ps1 Script

PS C:\> . 'D:\BlogsDemo\powerShell\Demo\WMIKVP.ps1'

Caption     :
Data        : AUTOBVT-M02LJSS
Description :
ElementName :
Name        : FullyQualifiedDomainName
Source      : 2

Caption     :
Data        : Windows Server (R) 2008 Enterprise
Description :
ElementName :
Name        : OSName
Source      : 2

Caption     :
Data        : 6.0.6001
Description :
ElementName :
Name        : OSVersion
Source      : 2

Caption     :
Data        : Service Pack 1
Description :
ElementName :
Name        : CSDVersion
Source      : 2

Caption     :
Data        : 6
Description :
ElementName :
Name        : OSMajorVersion
Source      : 2

Caption     :
Data        : 0
Description :
ElementName :
Name        : OSMinorVersion
Source      : 2

Caption     :
Data        : 6001
Description :
ElementName :
Name        : OSBuildNumber
Source      : 2

Caption     :
Data        : 2
Description :
ElementName :
Name        : OSPlatformId
Source      : 2

Caption     :
Data        : 1
Description :
ElementName :
Name        : ServicePackMajor
Source      : 2

Caption     :
Data        : 0
Description :
ElementName :
Name        : ServicePackMinor
Source      : 2

Caption     :
Data        : 274
Description :
ElementName :
Name        : SuiteMask
Source      : 2

Caption     :
Data        : 3
Description :
ElementName :
Name        : ProductType
Source      : 2

Caption     :
Data        : 9
Description :
ElementName :
Name        : ProcessorArchitecture
Source      : 2

Ok now how do you decipher all of these values like SuiteMask? All of this data except the fully qualified domain name come from a Windows API GetVersionEx but what you really want to look at is the OSVERSIONINFOEX structure. That documents each of these values, for example SuiteMask has a value of 274 above that's 0x112 and according to the documents that means this guest has: Remote Desktop support, Terminal Services is installed, and it's running an Enterprise SKU of Windows...

There's a lot more you can do with the KVP's such as pushing custom data into the guest from the parent partition/host or providing data from the guest so that the parent partition/host can query it. I can provide samples for this in a future post but only if you want me to - so tell me, actually tell me what posts you want maybe networking or offline vhd servicing or maybe import/export?

--Taylor Brown
--Hyper-V test team

Hyper-V WMI Using PowerShell Scripts – Part 2

Taylorb — Sat, 03 May 2008 07:37:00 GMT

In part 1 we went over some basic scripts and tools for gathering information about running virtual machines. In part 2 I am going to cover two things, first basic VHD creation and second determining if Hyper-V WMI methods are succeeding or failing and what the error message is.

PowerShellPlus

Last time I showed the PowerShell 2.0CTP which includes the Graphical PowerShell interface… Those of you that plan to do a lot PowerShell development might want to check out PowerShellPlus (http://www.powershell.com/index.html). It’s a $79 investment if you are using it for commercial use, but there is a 30 day trial – 1 day down and so far I think it’s worth $79… As you can see from the screen capture below the editor offers auto-complete as well as a pretty good debugger.

Creating a VHD Using PowerShell WMI

Creating a VHD using the Hyper-V WMI is pretty easy… And once again PowerShell makes it even easier…

The first command retrieves a WMI object for Msvm_ImageManagmentService.

The second command executes the CreateDynamicVirtualHardDisk method to create a new dynamic VHD. PowerShell is smart enough to know that 20GB = 20 * 1073741824... That’s so COOL!.

PS D:\> $VHDService = get-wmiobject -class "Msvm_ImageManagementService" -namespace "root\virtualization"
PS D:\> $VHDService.CreateDynamicVirtualHardDisk("D:\vhds\TestVhd1.vhd", 20GB)

__GENUS          : 2
__CLASS          : __PARAMETERS
__SUPERCLASS     :
__DYNASTY        : __PARAMETERS
__RELPATH        :
__PROPERTY_COUNT : 2
__DERIVATION     : {}
__SERVER         :
__NAMESPACE      :
__PATH           :
Job              : \\TAYLORB-DP490\root\virtualization:Msvm_StorageJob.InstanceID='Microsoft:Msvm_{B5A1A0EC-6A86-4CB0-AF7A-B336CBA2DCFF}'
ReturnValue      : 4096

Finding Out If Your VHD Creation Succeeded Or Not…

Let’s say you actually want to know if the VHD was created successfully or not (crazy I know…). Well normally you would just check ReturnValue, but what the heck does 4096 mean? 4096 means that the method is executing asynchronously (in the background) and you need to check it’s Job object to see when it’s finished and if it was successful…

As you can see from the ErrorDescription below my job actually failed since I didn’t delete the VHD between the first and second sample… Most of the Hyper-V WMI uses these Job objects so this is a pretty handy bit of code to know…

Again the first command just retrieves a WMI object for Msvm_ImageManagmentService.

The second command is mostly the same except for three key parts, first you can see it stores the return object in $Job but the real magic is the [WMI] before the $VHDSer… What’s happening is your telling PowerShell to make you a PowerShell WMI object for the Job path stored in the Job field. Look at the output from the sample above the Job field is a path to a WMI job object...

The third command is just showing the output of the $Job… You could do $Job.ErrorDesciption if you wanted to just get the ErrorDescription..

PS D:\> $VHDService = get-wmiobject -class "Msvm_ImageManagementService" -namespace "root\virtualization"
PS D:\> $Job = [WMI]$VHDService.CreateDynamicVirtualHardDisk("D:\Users\Public\Documents\Hyper-V\Virtual hard disks\TestVhd1.vhd", 20GB).Job
PS D:\> $Job

__GENUS                 : 2
__CLASS                 : Msvm_StorageJob
__SUPERCLASS            : CIM_ConcreteJob
__DYNASTY               : CIM_ManagedElement
__RELPATH               : Msvm_StorageJob.InstanceID="Microsoft:Msvm_{22FE6994-4CD8-4D06-9F3D-906A23A4BB09}"
__PROPERTY_COUNT        : 43
__DERIVATION            : {CIM_ConcreteJob, CIM_Job, CIM_LogicalElement, CIM_ManagedSystemElement...}
__SERVER                : TAYLORB-DP490
__NAMESPACE             : root\virtualization
__PATH                  : \\TAYLORB-DP490\root\virtualization:Msvm_StorageJob.InstanceID="Microsoft:Msvm_{22FE6994-4CD8-4D06-9F3D-906A23A4B
                          B09}"
Caption                 : Storage Job
Child                   :
DeleteOnCompletion      : True
Description             : Disk Creation Job.
ElapsedTime             : 00000000000000.000000:000
ElementName             : Storage Job
ErrorCode               : 32768
ErrorDescription        : The system failed to create 'D:\Users\Public\Documents\Hyper-V\Virtual hard disks\TestVhd1.vhd' with error 'The f
                          ile exists..' (0x80070050)
ErrorSummaryDescription :
HealthState             : 5
InstallDate             : 00000000000000.000000+000
InstanceID              : Microsoft:Msvm_{22FE6994-4CD8-4D06-9F3D-906A23A4BB09}
JobCompletionStatusCode : 2147942480
JobRunTimes             : 1
JobState                : 10
JobStatus               : Error
LocalOrUtcTime          : 2
Lun                     : 0
Name                    : Msvm_StorageJob
Notify                  :
OperationalStatus       : {2}
OtherRecoveryAction     :
Owner                   :
Parent                  :
PathId                  : 0
PercentComplete         : 0
PortNumber              : 0
Priority                : 0
RecoveryAction          : 3
RunDay                  :
RunDayOfWeek            :
RunMonth                :
RunStartInterval        :
ScheduledStartTime      :
StartTime               :
Status                  : Error
StatusDescriptions      : {Error}
TargetId                : 0
TimeBeforeRemoval       : 00000000000000.000000:000
TimeOfLastStateChange   : 00000000000000.000000+000
TimeSubmitted           :
Type                    : 1
UntilTime               :

Well I think that's going to have to do it for tonight… Stay tuned I have A LOT more to show.

If you prefer the examples in this format tell me, if you prefer the format from yesterday tell me, if you want a different format altogether tell me…

-Good Night and Good Weekend
-Taylor Brown

Hyper-V WMI Using PowerShell Scripts – Part 1

Taylorb — Fri, 02 May 2008 17:53:00 GMT

Hello out there in blog land… This is Taylor Brown some of you may know me from the Virtualization Deployment Summit or from my posts on the TechNet Forums, for those who don’t know me I am a test lead on the Hyper-V team. One of my team’s responsibilities is validating end-to-end integration of all the different parts of Hyper-V such as networking, storage, user-interface or installation. We are also responsible for the relationship between you the customer and the rest of the Hyper-V test team.

Last week I did a demo of some Hyper-V WMI scripts in Powershell and enough people asked for them I figured I'll just post them for everyone… So without further delay here's part 1.

PowerShell 2.0 CTP – Graphical PowerShell Interface

I highly recommend the PowerShell Graphical Interface that is included in the PowerShell 2.0 CTP.

You can read more about it and download the installation package at http://www.microsoft.com/technet/scriptcenter/topics/msh/download2.mspx.

It offers a nice tabbed interface and color coding, its a CTP build so it’s far from bug-free but the benefits out way the pitfalls. You have to uninstall the PowerShell 1.0 Windows update before you can install the CTP build. I don't think I would install the CTP on your production servers, but the PowerShell scripts are generally compatible.

The biggest downside to this interface for me is that it makes me want more features like auto-complete.

Mapping Worker Process ID's to Virtual Machines

Each virtual machine has it's own worker process (vmwp.exe) instance when it's running. Some people have asked how they can map worker process to a specific virtual machine so here's the answer... This is also a great example of the power that WMI and PowerShell have with Hyper-V.

   1: $Vm = Get-WmiObject -Namespace root\virtualization -ComputerName "." `   2: -Query "Select * From Msvm_ComputerSystem Where ElementName='Server 2008 - Test1'"   3: $Vm.ProcessID   4:     5: $Vm = Get-WmiObject -Namespace root\virtualization -ComputerName "." `   6:    -Query "Select * From Msvm_ComputerSystem Where ProcessID=4044"   7: $Vm.ElementName

Lines 1 and 2 retrieves a WMI object for the virtual machine with the friendly name of 'Server 2008 - Test1'. Then line 4 outputs the value in the ProcessID field to the console.

Lines 5 and 6 retrieves the same WMI object as lines 1 and 2 did but retrieves it via the process id. Then line 7 outputs the value in the ElementName (friendly name) of the virtual machine to the console.

Other WMI Properties Of the Msvm_ComputerSystem

One of the best parts about writing scripts in PowerShell over VBScript or JScript is that like a command or batch script you can run commands in the shell window and see the results right away...

In this screen capture I just ran the command from line 1 and 2 above (hint remove the ` and carriage return from the end of line 1 to make the command a single line).

Then I ran $Vm, which is the WMI object I retrieved. This will output all of the properties that object contains. Here's the list - stay tuned for later posts and I will talk about what these properties mean.

PS C:\> $Vm = Get-WmiObject -Namespace root\virtualization -ComputerName "." -Query "Select * From Msvm_ComputerSystem Where ElementName='Server 2008 - Test1'"
PS C:\> $Vm

__GENUS                       : 2
__CLASS                       : Msvm_ComputerSystem
__SUPERCLASS                  : CIM_ComputerSystem
__DYNASTY                     : CIM_ManagedElement
__RELPATH                     : Msvm_ComputerSystem.CreationClassName="Msvm_ComputerSystem",Name="A1223A4B-887D-4F01-895E-FBFB636F76D8"
__PROPERTY_COUNT              : 29
__DERIVATION                  : {CIM_ComputerSystem, CIM_System, CIM_EnabledLogicalElement, CIM_LogicalElement...}
__SERVER                      : TAYLORB-DP490
__NAMESPACE                   : root\virtualization
__PATH                        : \\localhost\root\virtualization:Msvm_ComputerSystem.CreationClassName="Msvm_ComputerSystem",Name="A1223A4B-887D-4F01-895E-FBFB636F76D8"

AssignedNumaNodeList          : {0}
Caption                       : Virtual Machine
CreationClassName             : Msvm_ComputerSystem
Dedicated                     :
Description                   : Microsoft Virtual Machine
ElementName                   : Server 2008 - Test1
EnabledDefault                : 2
EnabledState                  : 2
HealthState                   : 5
IdentifyingDescriptions       :
InstallDate                   : 20080502051703.000000-000
Name                          : A1223A4B-887D-4F01-895E-FBFB636F76D8
NameFormat                    :
OnTimeInMilliseconds          : 3783756
OperationalStatus             : {2}
OtherDedicatedDescriptions    :
OtherEnabledState             :
OtherIdentifyingInfo          :
PowerManagementCapabilities   :
PrimaryOwnerContact           :
PrimaryOwnerName              :
ProcessID                     : 4044
RequestedState                : 12
ResetCapability               : 1
Roles                         :
Status                        :
StatusDescriptions            :
TimeOfLastConfigurationChange : 20080502051707.000000-000
TimeOfLastStateChange         : 20080502051707.000000-000