I’m happy to announce that Package Conversion Manager 2.0 is available on the Microsoft Download Center in conjunction with this SP1 release.

Key Changes for Package Conversion Manager 2.0

The 2.0 release of PCM doesn’t have new features implemented yet we did resolve bugs found and reported along with other known issues.  However, we did make a key change for the longer term support of PCM and that was to build a single set of binaries available in a single installer to support both ConfigMgr RTM & SP1.  This is the case for all languages supported from our RTM release.  Thus, you can use a single download for all your RTM & SP1 systems for PCM.

Downloading Package Conversion Manager 2.0

To get started or upgrade your version of PCM, please visit the PCM Home page.  For those who are interested in the bits only, please use the following links for each language-

· English

· Chinese

· German

· French

· Japanese

· Russian

Reminder:  Training for Package Conversion Manager 2.0

As a very quick reminder, we wanted to share that you can learn more about PCM from my blog posts below -

• Kicking the tires for Configuration Manager 2012’s Package Conversion Manager (PCM)
• ConfigMgr 2012 PCM-  Walking through PCM Plug-In capabilities
• ConfigMgr 2012- Introducing Package Conversion Manager (PCM) for Seamless Migration to the AppMo
• ConfigMgr 2012- Package Conversion Manager (PCM) & Readiness State
• Using Package Conversion Manager (PCMs) Fix & Convert – Moving Manual Readiness Packages
• Package Conversion Manager Readiness States & Rules
• Extending Microsoft System Center Configuration Manager 2012 Package Conversion Manager (PCM)

Getting support for PCM 2.0

As a final notice, we wanted to let you know that you can receive full support through CSS for 2.0 just as you could with 1.0.  This support is valid for 1 year from today.

Enjoy!

Thanks,

-Chris

In today’s post, I want to help many of you get started by providing you some files that will import some basic packages/programs into your Configuration Manager 2012 system.  Beyond this, I wanted to enable you to test our collection intent functionality enabling you to easily move WQL query targets to the new Application Model’s Global Conditions & Requirements.

Lastly, I’ve also attached a tool (PCMTestTool.exe) that allow you to easily “clean” the system and run through various times to get the hang of it.  This tool is available as-is and isn’t supported by Microsoft.

Preparing your Configuration Manager 2012 Infrastructure for the test drive

Let’s start by downloading the files attached to this blog.  They are in a single zip file called KickingTiresPCM.zip.  You can download them here.

After this, we need to do a couple of quick things before we get deep into kicking the tires.  First, you must have already installed Configuration Manager 2012 on a server OS such as Windows 2008/R2.  We do not have any requirements outside a working server-side infrastructure.  You do not for the purpose of this test need working clients as the packages I’m providing to you are not designed to be deployed to clients.

Second, you will need to create a new configuration file for PowerShell that allows us to target both framework versions as the clean script is written using PowerShell.  By default, PowerShell isn’t targeted against both .NET 2.0 and .NET 4.0.  I outline how to do this in my blog post here.  In order to effectively run through the plug-in demo, you will need to do this step.

Setting up Applications for Testing of Configuration Manager PCM Usage

The first step is to import some applications.  I’ve outlined in the following blog post how to effectively import a set of applications called HRBusinessApps.zip (they are part of the above zip.)  To simplify, use my blog titled “ConfigMgr 2012 PCM Walking Through PCM Plug In Capabilities” under the section titled Developing your Plug In.

After you’ve imported the applications, you will need to change the source for the packages. To do this, you follow these instructions outlined in the above blog in section “Edit the Program Source for the HR Business Apps” -

Stepping through Analyze, Convert, Fix & Convert, and Scheduling with PCM

In the past, I’ve provided several detailed blogs on how to utilize the features of PCM.  Rather than repeat them, I’m going to provide them as reference as they will step you through using the major aspects of PCM.  The blogs are outlined below and if you have any questions, please do not hesitate to let me know.

Analyzing Packages in PCM

Using Fix & Convert scenario in PCM

Targeting:  Using PCM’s Collection Query Migration to the App Model

Using Scheduled Package Analyzer to schedule Analysis

Developing a Plug-In for PCM to support custom wrappers

Resetting Configuration Manager Readiness to re-test/re-enable PCM

To allow you to go through multiple iterations of testing and learning, I’ve provided you a tool our development team built that will facilitate cleaning your test environment.  This application is fully un-supported though it is signed with Microsoft’s digital signature to ensure you can trust it.  It provides several functions and I will provide their outline below.

Inside the downloaded zip file, you will find an application called PCMTestTool.exe.  This application allows you to do the following-

• It creates packages & programs for you to test PCM
• It will create these packages & programs with sample WQL queries for you to test Fix & Convert including collection intent
• It will remove all PCM-specific state such as readiness, etc. so that you can test over & over again

This is the primary purpose of this blog is to help get you started with testing.  This allows you to test PCM without having any internal needs and you can simply download the single attached zip file, following instructions provided to import the packages/programs and off you go.  You can then utilize PCMTestTool.exe to clean your Configuration Manager 2012 test server to re-run and test.  You can also use PCMTestTool.exe against your own applications if you like.

By default, each package created will create a WQL collection.  If you like to create a package with a unique WQL, you can use WQL Collection argument.

Summary

In today’s post, I focused on helping many of you get started in testing your environment by not requiring you to do it against your packages/programs.   Instead, I provided you with files you can use to test PCM and get familiar with it.  This will allow you to go through the various scenarios that PCM solves for you.

Let me know if you have any problems!

Enjoy!

Thanks,

-Chris

KickingTiresPCM.zip

In the complicated and dynamic world of applications, Enterprises continued to find unique and interesting ways to approach software delivery with System Center Configuration Manager.  During the development of Package Conversion Manager (PCM), we quickly determined that one area that was ripe for investment was in helping customers to take advantage of PCM when using custom wrappers.

Custom wrappers are defined as non-MSI based capabilities such as scripts or executable that usually provide capabilities above and beyond what Configuration Manager offered.  With System Center Configuration Manager 2012, the application model provides much of the robustness that were found in these custom wrappers.  The PCM team wanted to ensure that we provided a low-cost solution for IT professionals (or developers) to automate and integrate with PCM’s analysis engine to allow wrappers to work effectively for migration.

By default, PCM’s analysis engine will interrogate programs and determine if it is MSI and if not will mark any non-MSI as Manual assuming it meets 3 rules outlined in the below.  If the program has content, is a software distribution package, and contains at least 1 program it is marked as manual.

What does this mean for you?  If you are using a wrapper that is a script (.vbs) or exe then you will show all manual.

The PCM team was aware of this huge need and thus we approached this in a manner where we provide you a “hook” that will interact with our analysis engine.  The hook allows you to write a script, or code, that will interrogate your wrapper to pull out key pieces of data such as detection method or manipulate metadata (like contact help desk information) – and do it only once.

Thus, the plug in doesn’t just magically solve your problem.  The experts in wrappers is you and your team and we focused on enabling you to use this expert knowledge to develop a wrapper that would interrogate your “system” and figure out what needs to be extracted and provide it to the PCM engine.  This serialize & de-serialize process makes it very robust and capable of handling a multitude of scenarios.

Developing your Plug In:  A Sample to get Started

To get you started, I’m providing an attachment that has a set of applications that you will need to import into your Configuration Manager 2012 system.  The first step is to download using the link below included with this post.  It is called HRBusinessApps.zip.  Afterwards, let’s import then so let’s open the Administrator console and do the following -

1. Click the Software Library Wonderbar
2. Click Packages
3. Right-click, select Folder, and then Create Folder and name it HR
4. Click HR folder
5. In the Ribbon, click Import
6. Click Browse and locate the HRBusinessApps.zip downloaded from my blog
7. Click Next
8. Click Close

After completing it, you should see the summary and completion success.

Source Path:  Editing to location of Test MSI’s

I’ve provided as a sample a base Test MSI that you can download below in attachment MSISimple.zip.  This zip contains a simple MSI with a product ID and the association.  It is for testing purposes only.  The next step is to download it and put on your network (UNC) and then edit the source path for the imported packages.

Download & Put on Network Share

1. Download to your local machine
2. Upload to a share on the network

Edit the Program Source for the HR Business Apps

Because you are importing from a different environment, you will need to change the properties of the programs to point to the test MSI.  This is rather trivial and I outline the steps below.

1. Click the Software Library Wonderbar
2. Click Packages
3. Click HR
4. Right-click on the first package, click Properties
5. Click the Data Source tab
6. Under the “This package contrains source files, click Set
7. Select Network path (UNC name)
8. Enter the UNC path to the location \\server\share\ to the Simple MSI.  (EX:  \\Server\Test MSIs\MSI – Simple)

After this, you are ready to get started creating your plug-in and the first thing to make sure you see is that you analyze the packages and they return manual.

Plug In:  Why do I need to do this?

For this sample, I’ve provided you a PowerShell script that has been built by our development team.  The purpose of the powershell script is to interrogate information stored in XML streams that are utilized by Wrapper called “SoftwareInstaller.exe”.

You can either use the scripts which are included in the zip file available for download from this blog or create two new PowerShell scripts as outlined below.

1. PlugInAppModel.ps1
2. SharedFunctions.ps1

NOTE: If the Admin console is installed to someplace other than the default location you will need to modify the first entry in the SharedFunctions.ps1 to point to the appropriate location.

The code to copy is the following- PlugInAppModel.ps1

#   Microsoft Corporation.

#

#   PCM Plug-In Sample

#

#   This Sample modifies the application to be created,

#   it shows the way to alter the information such as 

#   Display Name, change the Deployment Type Priority, 

#   and provide a Detection Method.

#

#   Input Parameters:

#   packageID FullFileName SiteServerName

#

#   Example Call:

#

#   PS > .PCMPlugIn.ps1 PKGID0001 C:\3213321-3313213-32313.xml SCCMMachinName 

#Read Input parameters

$packageId      = $args[0]

$fullFileName   = $args[1]

$sccmServerName = $args[2]

$currentPath= Split-Path $MyInvocation.MyCommand.Path

import-module "$currentPath\SharedFunctions.ps1"

try

  {

     #Loads Application Model into Application Domain

    LoadSccmAssemblies

    #Deserialize XML file

    $applicaton = GetApplicationObject $fullFileName

    #Modifies Application Name

    $applicaton.Title = $applicaton.Title + "_ModifiedByPlugIn"

    $applicaton.DisplayInfo.Current.Title = $applicaton.DisplayInfo.Current.Title + "_ModifiedByPlugIn"

    #If there is any Deployment Type change its Installer properties

    if($applicaton.DeploymentTypes.Count -gt 0)

    {

        VerifyEmptyProductCode $applicaton.DeploymentTypes

        $deploymentType = $applicaton.DeploymentTypes[0]

        $deploymentType.Installer.InstallCommandLine = 'MSIExec.exe /i "SimpleMSI.msi" /q'

        $deploymentType.Installer.UninstallCommandLine = 'MSIExec.exe /uninstall "SimpleMSI.msi"'

        $deploymentType.Installer.DetectionMethod = [Microsoft.ConfigurationManagement.ApplicationManagement.DetectionMethod]::Enhanced

        Create-EnhancedDetectionMethod $deploymentType.Installer $sccmServerName    

        #Add a dependency to a predefined Application

        AddDTPreExistantDependency "Automatic01_ModifiedByPlugin" $sccmServerName $deploymentType

        #Adds a Predefined Requirement to the DT

        Add-DTRequirements $deploymentType "Test setting" "Test Value" $sccmServerName

    }

    #Change DT Priority

    ChangeDTPriority($applicaton)

    #Add Custom Predifined DT

    Add-DeploymentType $applicaton "Custom Deployment Type" $sccmServerName

    #Saves Modified Application into the same File

    SaveApplicationObject $applicaton $fullFileName

    #If everything was executed successfuly exit with 0

    Write-Host "The PCM Plug IN executed successfuly"

    exit 0

  }catch

  {

    #If we need to report a problem with the plug in exit with 1

    Write-Host "The PCM Plug IN executed with errors"

    exit 1

  }

The code to copy is the following – SharedFunctions.ps1

$sccmPath = "C:\Program Files (x86)\Microsoft Configuration Manager\AdminConsole\bin\"

function Get-AuthoringScope($siteServerName)

{

  $returnValue = [string]::Empty  

  $connectionManager = new-object Microsoft.ConfigurationManagement.ManagementProvider.WqlQueryEngine.WqlConnectionManager

  if($connectionManager.Connect($siteServerName))

  {

      $result = $connectionManager.ExecuteMethod("SMS_Identification","GetSiteID", $null) 

      $returnValue = $result["SiteID"].StringValue.Replace("{", [string]::Empty)

      $returnValue = $returnValue.Replace("}", [string]::Empty)

      $returnValue = "ScopeId_" + $returnValue

      $connectionManager.Dispose()

  }

  $returnValue

}

function Get-ExecuteWqlQuery($siteServerName, $query)

{

  $returnValue = $null

  $connectionManager = new-object Microsoft.ConfigurationManagement.ManagementProvider.WqlQueryEngine.WqlConnectionManager

  if($connectionManager.Connect($siteServerName))

  {

      $result = $connectionManager.QueryProcessor.ExecuteQuery($query)

      foreach($i in $result.GetEnumerator())

      {

        $returnValue = $i

        break

      }

      $connectionManager.Dispose() 

  }

  $returnValue

}

function Create-EnhancedDetectionMethod($installer, $siteServerName)

{

    $authScope = Get-AuthoringScope $siteServerName

    $refName = "SettingRef_" + [Guid]::NewGuid().ToString()

    $cfgItemType = [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemPartType]::File

    $setting = Create-EDMSetting $cfgItemType

    $logicalName = $setting.LogicalName

    $dataType = [Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.ScalarDataType]::GetDataTypeFromDotNetTypeName("String")

    $settingSourceType = [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemSettingSourceType]::File

    $settingReference = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.SettingReference -ArgumentList $authScope, $refName, 0, $logicalName, $dataType, $settingSourceType , $false

    $settingReference.MethodType = [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemSettingMethodType]::Count

    $constantValue = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.ConstantValue -ArgumentList "0",$dataType

    $operands = new-object "Microsoft.ConfigurationManagement.DesiredConfigurationManagement.CustomCollection``1[Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.ExpressionBase]"

    $operands.Add($settingReference)    

    $operands.Add($constantValue)

    $expressionOperator = [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ExpressionOperators.ExpressionOperator]::NotEquals

    $rootExp = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.Expression -ArgumentList $expressionOperator, $operands

    $installer.EnhancedDetectionMethod = new-object Microsoft.ConfigurationManagement.ApplicationManagement.EnhancedDetectionMethod

    $installer.EnhancedDetectionMethod.Settings.Add($setting)

    $severity = [Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.NoncomplianceSeverity]::Critical

    $installer.EnhancedDetectionMethod.Rule = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.Rule -ArgumentList "exp1", $severity , $null, $rootExp

}

function Create-EDMSetting([Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemPartType]$configItemType)

{

    if($configItemType -eq [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemPartType]::File)

    {

        $setting = new-object Microsoft.ConfigurationManagement.DesiredConfigurationManagement.FileOrFolder -ArgumentList $configItemType, $null

        $setting.FileOrFolderName = "TestFile.txt" 

        $setting.Path = "C:\ProgramFiles\SomeSoftware"

    }

    $setting

}

#Deserialize XML into Application

function GetApplicationObject([string]$xmlFilePath)

{

   $fileContent = get-content $xmlFilePath -readcount 0   

  [Microsoft.ConfigurationManagement.ApplicationManagement.Serialization.SccmSerializer]::DeserializeFromString($fileContent,$false)

}

function SaveApplicationObject($application, [string]$fullFileName)

{ 

  if($applicaton -ne $null)

  {

    [Microsoft.ConfigurationManagement.ApplicationManagement.Serialization.SccmSerializer]::Serialize($application, $false).Save($fullFileName)    

  }

}

#Load Sccm Assemblies

function LoadSccmAssemblies()

{

    $filesToLoad = "Microsoft.ConfigurationManagement.ApplicationManagement.dll","AdminUI.WqlQueryEngine.dll", "AdminUI.DcmObjectWrapper.dll" 

    Set-Location $sccmPath

    [System.IO.Directory]::SetCurrentDirectory($sccmPath)

    foreach($fileName in $filesToLoad)

    {

       $fullAssemblyName = [System.IO.Path]::Combine($sccmPath, $fileName)

       if([System.IO.File]::Exists($fullAssemblyName ))

       {   

           $FileLoaded = [Reflection.Assembly]::LoadFrom($fullAssemblyName )

       }

       else

       {

            Write-Host ([System.String]::Format("File not found {0}",$fileName )) -backgroundcolor "red"

       }

    }

}

#Changes the Deployment Type Priority

function ChangeDTPriority($application)

{

    if($application.DeploymentTypes.Count -gt 1)

    {    

        $reorderedDT = new-object "Microsoft.ConfigurationManagement.ApplicationManagement.NamedObjectCollection``1[[Microsoft.ConfigurationManagement.ApplicationManagement.DeploymentType]]"

        for($i=$application.DeploymentTypes.Count-1; $i -ge 0; $i--)

        {

            #Inverse DT Priority on the firs two DTs

            $temp = $application.DeploymentTypes[$i]

            $application.DeploymentTypes.Remove($temp)

            $reorderedDT.Add( $temp )            

        }

        $application.DeploymentTypes = $reorderedDT

    }

}

function AddDTPreExistantDependency($appName, $siteServerName, $deploymentType)

{

 $app = Get-ApplicationObjectFromServer $appName $siteServerName

 if($app -ne $null )

    {

     $appAuthScope = $app.Scope

     $appLogicalName = $app.Name  

     $dtAppVersion = $deploymentType.Application.Version  

     $dtAuthScope = $app.DeploymentTypes[0].Scope 

     $dtLogicalName = $app.DeploymentTypes[0].Name 

     $dtVersion = $deploymentType.Version 

     $DTDesiredState = [Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.DeploymentTypeDesiredState]::Required 

     $intentExpression = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.DeploymentTypeIntentExpression -ArgumentList $appAuthScope, $appLogicalName, $dtAppVersion, $dtAuthScope, $dtLogicalName, $dtVersion, $DTDesiredState, $true

     $operands = new-object "Microsoft.ConfigurationManagement.DesiredConfigurationManagement.CustomCollection``1[[Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.DeploymentTypeIntentExpression]]"

     $operands.Add($intentExpression)

     $expression = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.DeploymentTypeExpression -ArgumentList ([Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ExpressionOperators.ExpressionOperator]::Or),$operands

     $anno =  new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.Annotation

     $anno.Description = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.LocalizableString -ArgumentList "Description", $appLogicalName, $null

     $anno.DisplayName = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.LocalizableString -ArgumentList "DisplayName", $appLogicalName, $null

     $rule = new-object "Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.DeploymentTypeRule" -ArgumentList ([Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.NoncomplianceSeverity]::Critical, $anno, $expression)

     $deploymentType.Dependencies.Add($rule)

    }

}

function Get-ApplicationObjectFromServer($appName,$siteServerName)

{    

    $resultObject = Get-ExecuteWqlQuery $siteServerName "select thissitecode from sms_identification" 

    $siteCode = $resultObject["thissitecode"].StringValue

    $path = [string]::Format("\\{0}\ROOT\sms\site_{1}", $siteServerName, $siteCode)

    $scope = new-object System.Management.ManagementScope -ArgumentList $path

    $query = [string]::Format("select * from sms_application where LocalizedDisplayName='{0}'", $appName.Trim())

    $oQuery = new-object System.Management.ObjectQuery -ArgumentList $query

    $obectSearcher = new-object System.Management.ManagementObjectSearcher -ArgumentList $scope,$oQuery

    $applicationFoundInCollection = $obectSearcher.Get()    

    $applicationFoundInCollectionEnumerator = $applicationFoundInCollection.GetEnumerator()

    if($applicationFoundInCollectionEnumerator.MoveNext())

    {

        $returnValue = $applicationFoundInCollectionEnumerator.Current

        $getResult = $returnValue.Get()        

        $sdmPackageXml = $returnValue.Properties["SDMPackageXML"].Value.ToString()

        [Microsoft.ConfigurationManagement.ApplicationManagement.Serialization.SccmSerializer]::DeserializeFromString($sdmPackageXml)

    }

}

#Add Predifined DT

function Add-DeploymentType($application, $DTName, $siteServerName)

{

    $objectId= new-object Microsoft.ConfigurationManagement.ApplicationManagement.ObjectId -ArgumentList ([Guid]::NewGuid.ToString()), ("Transformed DT " + $DTName)

    $deploymentType = new-object Microsoft.ConfigurationManagement.ApplicationManagement.DeploymentType -ArgumentList $objectId , ([Microsoft.ConfigurationManagement.ApplicationManagement.MsiInstallerTechnology]::TechnologyId)

    $deploymentType.Title = $DTName;

    $deploymentType.Version = 1;

    $deploymentType.Enabled = $true

    $deploymentType.Name = "DeploymentType_" + [Guid]::NewGuid().ToString()

    $deploymentType.Description = "DT Added by PCM PLug In"

    #$deploymentType.Hosting = HostingTechnology.Registrar.First();

    $deploymentType.Scope = Get-AuthoringScope $siteServerName;

    #$deploymentType.Application.AutoInstall = $true

    $application.DeploymentTypes.Add($deploymentType)

    $deploymentType.Installer.InstallCommandLine = 'MSIExec.exe /i "SimpleMSI.msi" /q'

    $deploymentType.Installer.UninstallCommandLine = 'MSIExec.exe /uninstall "SimpleMSI.msi"'

    $deploymentType.Installer.DetectionMethod = [Microsoft.ConfigurationManagement.ApplicationManagement.DetectionMethod]::Enhanced

    Create-EnhancedDetectionMethod $deploymentType.Installer $sccmServerName    

}

function Add-DTRequirements($deploymentType, $requirementName, $requirementValue, $siteServerName)

{ 

     $deploymentType.Requirements.Clear()

     $setting = Get-DcmSettingReference $requirementName $siteServerName

     $operands = new-object "Microsoft.ConfigurationManagement.DesiredConfigurationManagement.CustomCollection``1[[Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.ExpressionBase]]"

     $operands.Add($setting)

     $constant = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.ConstantValue($requirementValue, [Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.DataType]::String)

     $operands.Add($constant)

     $expression = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.Expression -ArgumentList ([Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ExpressionOperators.ExpressionOperator]::IsEquals), $operands

     $appLogicalName = $requirementName + " Equals " + $requirementValue

     $anno =  new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.Annotation 

     $anno.DisplayName = new-object Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.LocalizableString -ArgumentList "DisplayName", $appLogicalName, $null

     $rule = new-object "Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.Rule" -ArgumentList ( ("Rule_" + [Guid]::NewGuid().ToString()), [Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Rules.NoncomplianceSeverity]::None, $anno, $expression)

     $deploymentType.Requirements.Add($rule)

}

function Get-DcmSettingReference($settingName, $siteServerName)

{     

    $referencedSetting = Create-DcmSetting $settingName $siteServerName

    Build-SettingReference $referencedSetting

}

function Build-SettingReference($setting)

{

     $authScope =  Get-AuthoringScope $siteServerName

     $gsrLogicalName = $setting.ParentConfigItem.LogicalName

     $dataType = [Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.DataType]::String

     $gsr = new-object  Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.GlobalSettingReference -ArgumentList $authScope, $gsrLogicalName, $dataType, $setting.LogicalName, ([Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemSettingSourceType]::WqlQuery)

     $gsr

}

function Create-DcmSetting ($settingName, $siteServerName)

{

    #Create a DcmConnection

    $connectionManager = new-object Microsoft.ConfigurationManagement.ManagementProvider.WqlQueryEngine.WqlConnectionManager  

    $isConnected = $connectionManager.Connect($siteServerName)

    $dcmConnectionObj = new-object Microsoft.ConfigurationManagement.AdminConsole.DesiredConfigurationManagement.ConsoleDcmConnection -ArgumentList $connectionManager, $null

    #The object was implemented with explicit interfaces

    $dcmConnection = Get-Interface $dcmConnectionObj ([Microsoft.ConfigurationManagement.DesiredConfigurationManagement.IDcmStoreConnection])               

    [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.GlobalSettingsConfigurationItem]$gsci = [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.GlobalSettingsConfigurationItem]::CreateNew($dcmConnectionObj, [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemType]::GlobalSettings)

    $gsci.Description = "Test Global Setting added by PCM Plug In"

    $gsci.Name = $settingName

    $gsci.Type = [Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItemType]::GlobalSettings

    #set category ID: IS this always the same? as in hardcoded within SCCM?

    $gsci.CategoryIDs = [string[]] "GlobalCondition:08347928-D747-4b2e-B99C-94876C0D3D74"

    $setting = Get-Setting $gsci

    #add it to the ci

    $gsci.Settings.ChildSimpleSettings.Add($setting)

    #Assuming we want to add a new Global setting to Sccm.

    $newItem = $dcmConnection.StoreNewItem([Microsoft.ConfigurationManagement.DesiredConfigurationManagement.ConfigurationItem]$gsci)

    $setting

}

function Get-Setting($parent)

{

    $setting = new-object Microsoft.ConfigurationManagement.DesiredConfigurationManagement.WqlQuerySetting $parent

    $setting.SettingDataType = [Microsoft.SystemsManagementServer.DesiredConfigurationManagement.Expressions.DataType]::String

    $setting.WqlClass = "SMS_R_System";

    $setting.WqlNamespace = "ROOT\ccm";

    $setting.WhereClause = "";

    $setting.WqlProperty = "ClientType";

    $setting.Description = "SMS_R_System\ClientType"

    $setting.Name = "SMS_R_System\ClientType"

    $setting

}

#In order for the application to Serialize, the Installer.ProductCode is being set to " ",

#this is only when PCM is unable to locate the product code.

function VerifyEmptyProductCode($DeploymentTypes)

{

    foreach($i in $DeploymentTypes)

    {

        if($i.Installer.ProductCode -eq " ")

        {

           $i.Installer.ProductCode = [Guid]::NewGuid().ToString()

        }

    }

}

function Get-Interface {

#.Synopsis

#   Allows PowerShell to call specific interface implementations on any .NET object. , Workaround for Powershell Bug : 249840

#.Description

#   Allows PowerShell to call specific interface implementations on any .NET object. 

#

#   As of v2.0, PowerShell cannot cast .NET instances to a particular interface. This makes it

#   impossible (shy of reflection) to call methods on explicitly implemented interfaces.   

#.Parameter Object

#   An instance of a .NET class from which you want to get a reference to a particular interface it defines.

#.Parameter InterfaceType

#   An interface type, e.g. [idisposable], implemented by the target object.

#.Example

#   // a class with explicitly implemented interface   

#   public class MyObj : IDisposable {

#      void IDisposable.Dispose()

#   }

#   

#   ps> $o = new-object MyObj

#   ps> $i = get-interface $o ([idisposable])

#   ps> $i.Dispose()      

#.ReturnValue

#   A PSCustomObject with ScriptMethods and ScriptProperties representing methods and properties on the target interface.

#.Notes

#   LASTEDIT:  2009-03-25 11:35:23

    [CmdletBinding()]

    param(

        [ValidateNotNull()]

        $Object,

        [ValidateScript( { $_.IsInterface } )]

        [type]$InterfaceType

    )

    $private:t  = $Object.GetType()

    try {

        $private:m  = $t.GetInterfaceMap($InterfaceType)

    } catch [argumentexception] {

        throw "Interface $($InterfaceType.Name) not found on ${t}!"

    }

    $private:im = $m.InterfaceMethods

    $private:tm = $m.TargetMethods

    # TODO: use param blocks in functions instead of $args

    #       so method signatures are visible via get-member

    $body = [scriptblock]::Create(@"

        param(`$o, `$i)    

        `$script:t  = `$o.GetType()

        `$script:m  = `$t.GetInterfaceMap(`$i)

        `$script:im = `$m.InterfaceMethods

        `$script:tm = `$m.TargetMethods

        # interface methods $($im.count)

        # target methods $($tm.count)

        $(

            for ($ix = 0; $ix -lt $im.Count; $ix++) {

                $mb = $im[$ix]

                @"

                function $($mb.Name) {

                    `$tm[$ix].Invoke(`$o, `$args)

                }

                $(if (!$mb.IsSpecialName) {

                    @"

                    Export-ModuleMember $($mb.Name)

"@

                })

"@

            }

        )

"@)

   # write-verbose $body.tostring()    

    # create dynamic module

    $module = new-module -ScriptBlock $body -Args $Object, $InterfaceType 

    # generate method proxies - all exported members become scriptmethods

    # however, we are careful not to export getters and setters.

    $custom = $module.AsCustomObject()

    # add property proxies - need to use scriptproperties here.

    # modules cannot expose true properties, only variables and 

    # we cannot intercept variables get/set.

    $InterfaceType.GetProperties() | % {

        $propName = $_.Name

        $getter   = $null

        $setter   = $null

        if ($_.CanRead) {

            # where is the getter methodinfo on the interface map?

            $ix = [array]::indexof($im, $_.GetGetMethod())

            # bind the getter scriptblock to our module's scope

            # and generate script to call target method

            $getter = $module.NewBoundScriptBlock(

                [scriptblock]::create("`$tm[{0}].Invoke(`$o, @())" -f $ix))

        }

        if ($_.CanWrite) {

            # where is the setter methodinfo on the interface map?

            $ix = [array]::indexof($im, $_.GetSetMethod())

            # bind the setter scriptblock to our module's scope

            # and generate script to call target method

            $setter = $module.NewBoundScriptBlock(

                [scriptblock]::create(

                    "param(`$value); `$tm[{0}].Invoke(`$o, `$value)" -f $ix))

        }

        # add our property to the pscustomobject

        $prop = new-object management.automation.psscriptproperty $propName, $getter, $setter

        $custom.psobject.properties.add($prop)

    }

    # insert the interface name at the head of the typename chain (for get-member info)

    $custom.psobject.TypeNames.Insert(0, $InterfaceType.FullName)

    # dump our pscustomobject to pipeline

    $custom

}

Lastly, store these files in a location that you note as you will need to change the configuration for the Plug In in a later step.

Housekeeping:  Configuring PCM “Host” for PowerShell Execution

Prior to moving to setup and execution phase, we need to do two pieces of key changes to your system.  This is because we decided to build this PowerShell using the .NET 4.0 framework rather than 2.0 as well as to have you change the Execution Policy.

Create & Edit x86 PowerShell Configuration File

In order to utilize PowerShell from within the Configuration Manager console, you must create a new configuration file called powershell.exe.config and store it in the following path - C:\Windows\SysWOW64\WindowsPowerShell\v1.0.

<?xml version="1.0"?>

<configuration>

    <startup useLegacyV2RuntimeActivationPolicy="true">

        <supportedRuntime version="v4.0.30319"/>

        <supportedRuntime version="v2.0.50727"/>

    </startup>

</configuration>

This allows you to execute the PowerShell that I’ve provided above.

NOTE:  In order do get SPA to work with the PCM Plugin you will need to configure a few additional things. However, this will be covered in a different blog post.

Change Execution Policy to Unrestricted

In order to execute the PowerShell you’ve created above, you will need to change the value for the default execution-policy.  It is very important to do this with the x86 version of PowerShell.  The easiest method on Windows 2008/7 is to do the following-

1. Click Start
2. In Search box, enter PowerShell
3. It should have Windows PowerShell (x86), right-click and select Run As Administrator
4. Click Yes to elevate

To do this, please open PowerShell and issue the following command-

Set-ExecutionPolicy Unrestricted

This should allow your PowerShell scripts to run when executed within the context of PCM.

NOTE:  These changes are only for the temporary purposes of this blog.  I’d not recommend them in a production environment and you should look into PowerShell script signing capabilities for future plug-in enhancements you make.

Changing Analysis Engine to utilize Plug-In

After you’ve created the plug-in, the next step is to enable the PlugIn to be utilized by the PCM Analysis Engine.  All the configuration such as logging trace levels and plug-in settings are stored in the Configuration Manager Administration Console’s configuration file.  A colleague of mine has put together a good blog post covering this topic here. However, we will delve into what you need to change in this post as well. Navigate to the location you installed your ConfigMgr console. This is normally C:\Program Files (x86)\Microsoft Configuration Manager\AdminConsole\bin, but you may have installed it to a different location.  The configuration file is named Microsoft.ConfigurationManagement.exe.config.

Inside of this file you will need to follow these steps in order to configure the plug-in:

1. Add the following child node to configSections.

<section name="Microsoft.ConfigurationManagement.UserCentric.Workflow.Properties.Settings" 

               type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 

requirePermission="false" />

2. Add in a UserCentric node in the ApplicationSettings section.

<Microsoft.ConfigurationManagement.UserCentric.Workflow.Properties.Settings>

</Microsoft.ConfigurationManagement.UserCentric.Workflow.Properties.Settings>

3. Add the rest of the settings within the UserCentric node just added.

      <setting name="PcmPlugIn" serializeAs="String">

        <!-- <value></value> -->

        <value>powershell.exe E:\PlugIn\PlugInAppModel.ps1</value>

      </setting>

      <setting name="PcmPlugInTimeoutMilliseconds" serializeAs="String">

        <value>90000</value>

      </setting>

      <setting name="PcmPluginExitCode" serializeAs="String">

        <value>0</value>

      </setting>

As you can see, I’ve got an element configuration that is defined in the <value /> setting for PcmPlugIn.  This calls PowerShell and loads the PlugIn.ps1. An example configuration would be <value>powershell.exe "C:\sample\PlugInAppModel.ps1"</value>.

Execution Time:  Changing value to have threshold that accommodates your PlugIn

A key area of focus for you in your plug in is to understand exactly what the time it takes for execution.  There are a lot of variables that are required for you to take into account.  These include the speed of the machine as well whether it is making any network calls and the speed of the external resources.  It is important to note that the PCM analysis engine is spawning this process and will continue to “pause” while it is executing.  Thus, as part of the plugin model, we built functionality to say how long for the engine to “pause” and this is stored in the <value /> setting for PcmPlugInTimeoutMilliseconds.

For our example, I set it at 90000 to allow a 90 seconds for it to complete.  If it doesn’t complete with success and return a blog of data to the analysis engine this PCM will error out.

Copy New Configuration to BIN Directory

You will need to have administrative level access (UAC) to change the configuration file for Configuration Manager.  The simple way to effect this is to copy the file to your desktop (or wherever) and then edit the file.  You can then copy this file to the C:\Program Files (x86)\Microsoft Configuration Manager\AdminConsole\bin directory.

Re-Executing using Plug In & Readiness State Change

The last step is to see the plug in in action.  This requires you to close the console, re-open with the new configuration in place, and then execute analysis.  The end result should be a package completes that was now manual and is instead completely automatic.

Before Plug-In:

This shows the packages/programs in the Manual state…

After Plug-In:

This shows the package/programs after running analyze with our plug-in…

Putting it all Together

Wow.  I can’t believe the length of this blog.  It has almost worn me out and I can’t imagine for those who are reading it.  Is it difficult to actually do the work for a plug-in?  No, but it is lengthy to share with you all the nuisances in a blog.  The goals of today’s blog was to help you better understand all the steps but better yet walk you through using the Plug-In to impact and change the readiness status.  As you should have witnessed, we were able to use a plug-in that interrogated our custom wrapper and pulled the detection method from it.  Before this plug-in, all packages were showing Manual meaning you would need to do them one-by-one.  With a plug-in, do the work once, migrate hundreds or thousands easily!

Enjoy!

Thanks,

Chris

BlogPost.zip

It goes without saying that we would like to have everyone who is working with SP1 to please download the PCM 2.0 bits and give them a test.  In the coming days, I will release several blogs that outline how to effectively test scenarios for PCM allowing you to do so against our 1.0 release or the 2.0 beta release. 

The PCM 2.0 release will release at the same time as the Configuration Manager 2012 SP1 releases and as a PCM user you should follow closely the plans for SP1 Beta.

What’s New in PCM 2.0

For the most part the PCM 2.0 code-base goes unchanged however we have fixed several bugs and they newest functionality is to support Configuration Manager 2012 SP1.  For the SP1 Beta release of PCM, it will only work with the ConfigMgr 2012 SP1 Beta bits and will fail to work if you download it and test against Configuration Manager 2012 RTM.  This is not our long-term plans as we envision 2.0 being a single binary that supports all Configuration Manager 2012 platforms including RTM and SP1.

Getting Started with PCM Learning

To get you started with learning PCM, I wanted to provide you some references that exist now and I will update this blog in the future to support the new ones as they come online.

• ConfigMgr 2012:  Introducing Package Conversion Manager (PCM) for Seamless Migration to the AppModel
• ConfigMgr 2012:  Package Conversion Manager (PCM) & Readiness State
• Using Package Conversion Manager (PCMs) Fix & Convert – Moving Manual Readiness Packages
• Introducing Package Conversion Manager (PCM) Scheduled Package Analyzer
• Package Conversion Manager Readiness States & Rules
• Extending Microsoft System Center Configuration Manager 2012 Package Conversion Manager (PCM)

To learn more from Microsoft TechNet, view the PCM TechNet online documentation.

Downloading PCM 2.0 for System Center Configuration Manager 2012 SP1 Beta

As mentioned above, we’ve provided all testers of SP1 Beta the opportunity to download our PCM 2.0 and to test the scenarios in your environments.  We will provide key scenarios and capabilities to everyone via blogs very soon but for now get started by downloading the bits on the Microsoft Connect site.

Enjoy!

Thanks,

-Chris

After months & months of using VMM 2012, we finally figured out (or this is where I should confuse you with tense and say that, I, figured it out) how to setup libraries correctly for a cloud.  This is what we (Microsoft) thought most administrators would do before they created a cloud & made libraries available.  The breakdown of clouds, libraries, and 2012 I will save for another day but for now let me just explain the nightmare that will exist when you have physical objects (e.g. iso’s, VHDs, etc.) in the VMM database yet the physical files themselves are gone. 

The result:  Your library will fail to refresh.  Again.  Again.  And did I mention again? 

Detecting the Problem:  Error 801 VMM cannot find {Object Type} {Object ID}

It starts with investigating you Jobs wonderbar in the VMM Administration Console.  During the typical 60 minute refresh cycle (60 is the default, but configurable), you will see an entry that says your refresh failed.  In our case, we had a tester who was wanting to utilize a ISO they’d uploaded to the Self-service Library though they couldn’t use it as VMM wasn’t aware of it due to the refresh failing.  Wow.  (In this case, it was easier to use Hyper-V Manager to attach and we did so to unblock the tester but that would kill this blog post

Well, this is easy…let’s remove the object right?  Let’s do it…

Thus, I chased down trying to remove any instance of the VM object in question and I was able to do so by doing the following in SQL Management Studio:

1. Connect to the VirtualManagerDB using credentials with sysadmin permissions
2. Click New Query
3. Select the VirtualManagerDB and enter the following:

Select * from dbo.tbl_WLC_VMInstance where ObjectID = '{Enter Object Id from Jobs Details}'

This should return any instances of this object and the next thing to do is the following:

Delete from dbo.tbl_WLC_VMInstance where ObjectId = '{Enter Object ID}'

This will return that it completed successfully and then re-run the select command and you will see 0 instances and you are set.  Below are complete examples of the commands used -

The last step is to try and refresh the library shares and see if they complete.

Refresh Fails:  What do I do now?

The downside of doing this is that you’ve successfully removed the object yet you don’t have the library happy at this point.  I was *unsuccessful* at determining how to correct this and thus I went the hard route and RTFM (e.g. read documentation) and set things up a bit different like I mentioned above.  The real fun began when you try and remove the library using the VMM Administration Console

Unfortunately, it turns out the library when in this state is also un-removable and there is no method I could determine to correct this.  The error returned was the same as above-

It turns out, I couldn’t remove the library even though I had removed all VM objects in VMM (trust me, I might have missed ‘em in the DB but not for the lack of trying).

Nuke Library in Database, I say…

As a last resort, you can always go straight to the database.  This is not recommended for the faint of heart and I suggest you backup your VMM database immediately – now – before you continue forward.  Let’s get on with forcibly removing your library share.

To remove a library share from your VMM instance that is un-manageable, do the following:

NOTE:  Please stop your VMM Service before proceeding

1. Open SQL Management Studio
2. Select New Query & connect to the VirtualManagerDB
3. The first thing to do is find the LibShareId for the share you’d like to remove.  To do this, use the following command:

Select Name, LibraryShareId from dbo.tbl_IL_LibraryShare

The result set returns to you a list of all the library shares known to this VMM server.  The key thing you want is the Library Share ID which is used in the upcoming steps.

Deleting References & Library Share:  Let’s do this

If you immediately attempt to delete the library share, you will violate a constraint in the VirtualManagerDB between two tables – LibraryShare & PhysicalObject.  To allow the removal, you need to remove the reference to the Library Share found above it in the PhysicalObject’s table using the following command:

Select * from dbo.tbl_WLC_PhysicalObject where LibShareId = '{Insert Library Share ID from step 3}'

If you move forward, you will notice no references and you should not have any problems with the constraint.   

You will now be able to delete the reference in the dbo.tbl_IL_LibraryShare table:

Delete from dbo.tbl_WLC_PhysicalObject where LibShareId = '{Insert Library Share ID from step 3}

You will now be able to confirm that under Library > Library Servers > {Server}  you will no longer have the share you just removed.  We monitored the server for several days but the first thing we did was refresh the library and watched it successfully complete across all our shares.

Summary

This was painful on our end.  It took over 2 weeks to figure out what is going on and make the appropriate changes to allow folks to get back to work.  I personally take credit for screwing up a few things when we set the cloud up and I will not do that again but in the end the work required to figure out, and clean up, was above and beyond anything done before by us in VMM.  Because of this, you’ve hopefully learned a few things around how to go hunting in the VirtualManagerDB for objects and hopefully removing them.  Happy hunting…don’t forget to backup your VMM Database.

Enjoy!

Thanks,

-Chris

On the heels of the 2012 release, our team was quickly focused on enabling the UDI scenario for Windows 8 & 2012 which were soon-to-be-released.  The final “gold” bits were announced for Windows 8 & Windows Server 2012, and with that, I’m super proud that we have released MDT 2012 Update 1 which enables all the key features and support needed to deploy Windows 8 & 2012 with MDT UDI.

In today’s post, I want to make you aware of the key additional features & support added in this release for UDI.  In today’s post, I will not drill-down into the features and will save this for later more in-depth posts but I want you to start playing with them now.

Introducing USMT for Windows 8 Support

The major testing that our team had to do across the various refresh & replace scenarios was focusing on ensuring that we could effectively capture and restore your user’s data.  In Windows 8, a new version of User State Migration Tool (USMT) was released and as part of Update 1 we’ve validated that all UDI-based scenarios using this new USMT is supported.

Full Support for selection, detecting, and re-installing Windows 8 Application Packages (.appx)

Introduced in Windows 8 is the new modern experience for application development.  This development platform is based on the WinRT libraries and will result in a new paradigm for enterprises to develop applications for your users.  With this new paradigm, the deployment team (along with the greater management team such as Configuration Manager) had to enable capabilities for making these new applications discoverable and installable.  If you are using Windows 8 as a individual, or as we call consumer, your new applications are discovered through the new Windows Store.

For corporations, you want your applications to be discoverable using an internal-facing portal such as the one that is part of Configuration Manager 2012 Service Pack 1. 

The key work here for the UDI team is to allow deployment administrators to provide these new applications stored in the corporate portal to be installable as part of the deployment process.  You can now do this easily using the UDI Designer as part of MDT 2012 Update 1.

This is allowed as part of the building of new UDI Wizard experiences but also we’ve enhanced the capabilities of our Application Discovery feature that will detect on Windows 8 devices that applications are installed and will mark them to be re-installed.  As enterprises start taking advantage of the new paradigm, this support is super critical to providing seamless experiences as UDI is the only method to ensure that Windows 8 Application Packages are restored automatically during provisioning.

Introducing Powerful Build your Own Pages Feature

The top request since we released MDT 2010 Update 1 and completely through MDT 2012 is the ability for non-developers to build custom UDI pages.  We are excited to announce that we’ve enabled this capability in MDT 2012 Update 1 and it includes a easy-to-use drag-n-drop experience for creation.  This drag & drop provides grids for making visibly appealing pages, along with a full interface that shows the experience as it would look to the end-user.

You have a fixed list of controls that in this release we support and it includes common types such as Check Box, Combo Box, and Labels.  What does this allow you to do?  It allows you to build simple, verbose pages that takes advantage of custom scenarios not covered in out-of-box pages delivered in MDT 2012 Update 1.

Summary

It is time to usher in Windows 8 & Windows Server 2012.  As announced on the Building Windows 8 blog, Windows 8 is now golden.  As a MSDN subscriber, you can begin working to build your deployments for your enterprise and we hope that you decide to put the end-user or service technicians in control of the deployment experience using MDT 2012 Update 1’s UDI feature. 

To download MDT 2012 Update 1, please use the below link:

Microsoft Deployment Toolkit Update 1

Enjoy!

Thanks,

-Chris

In today’s post, I will walk you through this scenario so you can re-live the unbelievable pain and hopefully in this blog you will enjoy the entertainment value as much as what I hope you learn.  Let’s get started…

Scenario:  Say goodbye to EMC AX4-5 Storage Area Network (SAN) & Hello to NetApp SAN

Our engineering development cluster has ran great for 3+ years and has lived through host decommissions, failed drives, and even expansions of size for CSVs when running low.  We’ve moved data successfully around easily and pulled hosts in & out based on our needs.  The datacenter is an interesting place you see – hardware grows old and begins to show its age though to EMC’s credit we didn’t really see this age.  It was running, and for our needs, running well.  However, it was out of support effective April 2012 and at this point we were putting our business at risk.

Enter NetApp with it’s great integration points with System Center 2012 and we couldn’t say no.  There were other factors but in the end we now ended up with 2 SANs racked side-by-side – one old and one new.  The techie in me couldn’t say no to this and we were excited to get the NetApp into production as it was bigger, faster, and newer.  The LUNs were provisioned and presented to the hosts and now added to our Failover Cluster.

It’s time to migrate…

System Center 2012:  VMM’s Migrate Storage Feature

With System Center 2012’s Virtual Machine Manager, you can easily migrate from one storage to another.  It is an operation you can do manually or automate using PowerShell.  In our case, we decided to move manually and for this post I focus on the manual process for a single VM.

The steps were straight forward:

1. Open the VMM Admin Console
2. Expand the Failover Cluster in VMM’s host group, locate your Virtual Machine (VM)
3. Right-click and choose Migrate Storage
4. Select the storage, or in our case the CSV, location for both the configuration & virtual hard disks (VHDs) and click Next
5. Select the host you’d like to host the VM (this can be the same as it is currently hosted on if you like) and click Next
6. Click Move

NOTE:  In some cases, you have non-highly available Virtual Machines that you’d like to move to your Highly Available infrastructure.  In System Center 2012’s VMM it is possible to do this by using the Migrate Virtual Machine option and check the “Make this VM highly available” and this will migrate the VM to the cluster for the configuration & VHDs.

This job will take time depending on the size of the disks and the number of disks to move.  For some of our VMs it was 8 to 10 minutes while for others they were in the 3 to 4 hours as they were large VMs with multiple disks running System Center 2012 platforms like Configuration Manager and Operations Manager.

For more in-depth information on the migrate storage feature, please review my blog at http://blogs.technet.com/b/chrad/archive/2009/09/07/virtualization-tip-migrating-to-san-s-after-the-fact-with-scvmm-using-r2-s-migrate-storage.aspx?CommentPosted=true that outlined the new feature when it appeared in VMM 2008 R2.

Life was good:  Monday morning was pretty and 3.6 Terabytes had been migrated successfully

On Monday morning after the migration, we were nearly 75% completed with the migration from the EMC to the new NetApp.  We were at 60+ Virtual Machines or so migrated and they were all in their existing state as the team had left them on Friday.

This is the time you’d normally start the day with a meeting and talk about the next steps.  This is exactly what we did at 9:30 and we decided that we needed to provision one more LUN and add to the cluster as an additional CSV to complete the migration off the EMC.  The migration would continue the following weekend.

At 12:36 PM, I heard from some folks on my team that they were unable to access any VMs and the question was something like this -

“What did you do again this weekend, Chris?”

After hearing this enough, I immediately checked the Failover Cluster using the Manager and saw that nearly 75% of our Virtual Machines were offline.  In looking at the event viewer, I recognized that the new CSV showed dismounted at 12:36 and I was shocked.  The first visual indication I got was checking the Cluster Shared Volumes in the Failover Cluster Manager and realizing that the disk showed no indication of the volume:

As you can see, the NetApp CSV-based LUN was seen by the cluster yet had no volumes and the result was that in Disk Management the disk showed offline.  Bring it online led to it asking to initialize the disk which no one should do to an existing volume with data you’d like to retain as this re-writes the partition table for a MBR or GPT-based volume.

Oh heck, what do we do now?

After working all day with the NetApp and internal Microsoft expert named James, I’m happy to say we solved this problem with no data loss whatsoever.  I was @#$#% bullets until late Monday night but I knew that our team would validate in the morning any data problems and we did confirm this.

James determined that on our CSV our LUN’s Sector “0” was blanked and thus had no recognizable data to the operating system.  For some, you might just think this is a problem and decide to re-initialize the disk but when you do this you would blank out Sectors 1 & 2 which are very important in MBR/GPT volumes.  This engineer taught us a lot while we nervously awaited to see if he could re-establish the sectors and cause the cluster to recognize the volume again.

To do this, the engineer sent us a tool called Disk Probe and he started playing with Go To Sector, copy sectors off to file, taking screen shots and overly amazing us while we were praying.  In the end, he found that Sector 0 was blank and didn’t look like it “should” and I’ve provided a sector 0 that isn’t blanked out in the screenshot below-

NOTE:   This is the typical warning I’d like to share.  If you are faint of heart, or pregnant, or whatever I’d recommend you do not get this application and do anything with it.  I will never touch it personally as it allows you to edit sectors directly on the disk.  James was a cool customer and obviously knew what he was doing but for those that don’t, call someone who does.  You should know that James role at Microsoft is currently in our Customer Service & Support group so you might can get lucky and find him.  Consider this your warning.

After he’d done some “stuff”, saved it, the volume returned in our Failover Cluster Manager.  The VM’s, all 53 of them, could effectively start now and be effectively managed which is where we decompressed.

Rebuilding Sector 0:  Disk Signature Changes with Initialize Disk

As part of the exercise, James was capable of pulling key information from Sector 1 & 2 which include the reserved partitions for Microsoft’s MBR/GPT volumes (I think).  James took the appropriate screenshots of Sector 1 & 2 and then he initialized the disk which created a new disk signature.  For your education, prior to the “blanking” of our sector 0 I want to provide you a before after:

Before Sector 0 Corrupt:  {B08C099D-54B4-476B-94A4-3A5B4C5ED03F}

After Sector 0 Corrupt:  {5A038286-1631-40AC-A329-5BA4EC28A9C3}

We noticed a flooding of events getting logged in the cluster that read like the below which indicated to us that the cluster was still unhappy overall.

Although the VM’s were successfully running, we noticed that every Virtual Machine under Services & Applications in the Failover Cluster Manager failed to show the volume resource binding like it normally does.  We were unsure if it impacts anything and since the VMs were running, we decided to worry about it later.

A normal view shows the resources required for the configuration such as drives, etc.  I’ve shown a typical working example below in the graphic -

System Center 2012:  VMM’s Incomplete VM Configuration

Because of the late night hour, and determining that the VMs were functional, we decided that the mission linkage to Cluster Shared Volume wasn’t a problem,.  It was only a few days later we realized that we seem to might have some correlation between the state of the VM’s in the cluster and the VMM state “Incomplete CM Configuration.”  We couldn’t understand if the disk signature was causing an issue or what but thanks to the help of Hector from our VMM team we were able to determine that this in fact was a clustering issue and not a VMM.

I wanted to step you through some of the VMM errors were receiving during this to help you -

As you can see, we have an issue with MSCluster_Resource.Name=”{Guid}” and it was unhappy.  For each VM, the GUID was different but the error 12711 was the same and the until this problem was corrected the VM’s in VMM were unable to be refreshed.

Refreshing Cluster Configuration for Virtual Machines

The magic bullet to get the cluster back to a healthy state was to do an easy exercise of refreshing the virtual machine configuration so that it would drop the cache (which was inaccurate now) and re-build it.  This allows it to verify everything is working.  The major complaint I have is that it is very buried in the Failover Cluster Manager user experience and many will not know it.

To refresh the configuration for a VM, do the following-

1. Open Failover Cluster Manager
2. Expand the clusters Services & Applications and click the Virtual Machine
3. In the middle console, right-click on the virtual machine and select More Actions…
4. Click Refresh virtual machine configuration
5. After it completes, you will be prompted to see if you’d like to see the results – Click Yes or No
6. Click off your VM (or refresh) and come back and you will now see the Disk resource binding

If the refresh was successful, you can view the report and it will look similar to the below.  The result is that you now have a healthy VM in the cluster and you can move to fixing Virtual Machine Manager.

Virtual Machine Manager:  Refresh Your Virtual Machine

The actual action to make the virtual machine in VMM happy is so simple now that you will be happy to know that it is a single right-click experience.  You right-click on the virtual machine and choose refresh and the refresh should now complete successfully.  You should also refresh the entire cluster at this point as it should be healthy now and you are off to the races.

Summary

This blog was one that I hope was a bit entertaining while at the same time informative.  As we continue this migration, we hold hope for no more surprises though there was a lot of learning taking place early this week.  The key takeaways I hope you learned how to effectively understand are -

1. Using System Center 2012’s VMM Migrate Storage feature is super simple and easy – Use It!
2. Sector “0” clearing is a exercise in futility and painful and not for the faint of heart – Find an expert and befriend them until you leave this planet
3. Failover Clusters can be unhealthy and still providing working VMs to end-users
4. Refreshing virtual machine configurations are easy, diagnosing this is the issue not so much

Enjoy!

Thanks,

-Chris

For MDT 2012 UDI, we have several personas who can uniquely contribute to the success of deploying Windows in their environment.  UDI is a user-centric approach to deploying Windows and enables the user to take control of their device running Windows.

The UDI Wizard provides a easy-to-use method for end-users to make common decisions for how Windows is deployed on their corporate device.  This includes selecting applications, choosing a language pack, entering their unique machine name, and many more settings.

However, the UDI Wizard is broken down into a set of pages that execute in a stage group, as well as a stage.  This allows IT professionals to really make key decisions on what they want, don’t want, and customize based on the type of deployment your end-user is doing.

In many cases, the pages used to deploy Windows at places such as Microsoft are too complex or not relevant and this drives IT professionals to seek ways to effectively solve these dynamic challenges.  This is where corporate developers can use Microsoft’s Visual Studio tools to develop pages using UDI’s Software Development Kit (SDK).  This provides maximum flexibility for corporations to ensure that they have the right deployment for the right user each time.

Lastly, the key to bringing this all together is the IT professional who often is the deployment engineer and also has knowledge of Configuration Manager’s OSD feature which UDI is built on top of.  The deployment admin hears from end-users, has a unique understanding of corporate environment, and helps bring together the solution.  This is super important for us at Microsoft is to offer the maximum flexibility – if you use what we provide in-box then we are golden.  If not, we offer you the ability to customize to meet your needs.

A lot of folks are looking for documentation and help in getting up to speed with how they can utilize MDT 2012 UDI.  To facilitate and help customers get up-to-speed, we’ve spent a lot of effort to help educate deployment engineers, and now developers, on how to take advantage of UDI. 

Learn from the Software Development Engineer who architected the extensible UDI Wizard on how to extend and build your own pages as well as how to build extensions for our UDI Designer. 

System Center 2012 Configuration Manager OSD and MDT User-Driven Installation (UDI) work together to deploy Windows. This video shows from a developer perspective how to customize the wizard pages in MDT UDI. Watch this if you would like to code your own customizations into the pages.

System Center 2012 Configuration Manager OSD and MDT User-Driven Installation (UDI) work together to deploy Windows. In this video, see how to build extensions for your deployment to further customize MDT UDI for your environment

Enjoy!

Thanks,

-Chris

After our engineering team spent 9+ months rebuilding the UDI Wizard & Designer from the ground up, we turned focus on helping all of you improve your ability to execute using the UDI pieces in your deployments of Windows.

Understanding UDI in Enterprise Deployment

MDT 2012 UDI now supports all the deployment types commonly associated with enterprises:

• New Computer:  This solution is used to deploy to a bare-metal device with no operating system installed on the hardware
• Refresh:  This solution will install a new operating system on a device with an operating system already install on the hardware
• Replace:  This solution aids the migration from old computer hardware (e.g. out of support) to a new device

For all of these scenarios, and any variation of them, we wanted UDI to be simple to use and highly flexible.  The process of doing Windows deployments can be complex with lots of technologies involved and we wanted to bring these pieces together and simplify as much as possible in MDT 2012 no matter the scenario.

To aid in helping you get started, I’m happy to announce that we currently have 15-minute tutorials helping you get started with UDI in a couple of the scenarios listed above.

Configuring MDT 2012 UDI for Pre-Staged New Computer

Configuring MDT 2012 UDI in Replace Scenario

Configuring MDT 2012 UDI in Refresh Scenario

User-driven Installation (UDI):  Automatically Re-install Applications with Application Discovery

For many MDT users, a great number of are un-aware of the extensive work our team create a solution that leads to end-users having zero work to do when their new OS install is completed.  This includes extending User State Migration Tool (USMT) to support the interrogation of printers and network shares and restoring them in the new OS.  Beyond this, we built functionality to support the rapidly evolving and changing landscape of software deployments. 

In UDI, you can utilize a feature called Application Discovery that executes on your old computer (in Replace Scenario) or your current OS (Refresh scenario) to detect the applications installed that are supported for re-installation by System Center Configuration Manager.  This powerful features allows UDI to ensure that upon completion of the new operating system, the end-user has little or no work to do to return to work.

The UDI engineering team, a part of the MDT team, will continue to invest lots of energy in driving down the time lost due to operating system upgrades by end-users until the day we are at zero.  The more your enterprise does software delivery using Configuration Manager the more robust capabilities we have in putting that software back on your machine.

To help you learn more about Application Discovery, we’ve outlined in a 15-minute video how to set up your deployment using UDI to support application discovery to detect and re-install applications.

Leveraging Application Discovery with MDT 2012 User-Driven Installation

Summary

We are excited by a lot of the features and functionality coming in the upcoming MDT 2012 Update 1, though, we are focused primarily on helping each and every deployment admin in using MDT UDI.  We will continue to invest lots of energy over the coming months with more video’s, hands on labs, and blogs from myself and my teammate Cameron King.

Enough marketing speak – let’s focus a bit on why UDI exist and why we built it.  The enterprise is changing dramatically from yesteryear and the result is a challenge for many deployment admins to keep up with this shift.  In the past, the Windows desktop was a palace of policies, lock downs, and registry settings aimed at having the same “common operating environment”  for all users in the enterprise.  This led to reduced help desk costs and overall satisfaction from end-users.  Not today.  Today’s users aren’t afraid to jump into the bowels of Windows and customize to their liking, and for many out there, the workforce in these enterprises have had computers in their lives since they were children.  The reality is this – if you lock the Windows desktop down too far they will not use it.  They will go elsewhere and our industry has started calling this the consumerization of IT.

UDI is built to bridge this gap.  Out of the box, Configuration Manager provides a robust task sequence engine allowing you to build the perfect Windows desktop for your users.  Unfortunately, this task sequence assumes one thing – IT has all the answers.  For workforces today, this isn’t the case.  For example, at Microsoft or other technology-based companies, the very idea of not allowing you to customize what applications are installed is simply unforgiving.  Furthermore, the focus of allowing the end-user to do things like add additional administrative users (or groups), or to copy their data from one machine to another and restore it is where I feel the enterprise is going.  These new end-users want to run Windows in a safe, comfortable manner and they also want to provide IT the flexibility to ensure that they provide the best experience to do the job.

MMS 2012:  Understanding how UDI provides flexibility for end-users & IT

In our session this week (see below for details), Cameron King & I will focus on ensuring that we help you get the most out of UDI including diving into new scenarios supported by MDT 2012 UDI.  We will walk you through building a robust deployment for the MDT Replace scenario whereby the user captures their data from their “soon to be retired” machine and restores it on their pristine new machine when it arrives.  This is accomplished using a familiar experience and is customize to provide them just the right access to control the deployment and not too much.

Beyond this, we will demonstrate how to effectively navigate our brand new UDI Designer where you will put piece together your flexible deployment(s) for your users.  The UDI designer is where it starts for anyone wanting to use UDI and we will outline how to ensure that all your users applications that are currently installed are automatically re-installed on the new machine using Configuration Manager.  The new designer offers support for Configuration Manager 2012 including new features such as User-device affinity (UDA) and full support for applications (we’ve always supported packages/programs).

For all you Configuration Manager deployment experts, you will certainly want to see our demonstration on how to support the powerful new centralized configuration.  Centralized configuration offers admins the ability to create, then publish using the designer multiple configurations to a central location.  The supported types for central location is UNC (SMB) or HTTP (web service).   During deployment, prior to executing, the end user’s experience is downloaded from this location allowing administrators the flexibility to make a change at 11:37 and it impact users at 11:40.  In the past with MDT 2010 Update 1, you were required to update the Configuration Manager toolkit package and wait for it to be sent to all the Distribution Points (DPs) before the user got the new experience.  Ironically, during this time period, the end-user would often get errors due to policy throwing has mis-match errors.  We will walk you through how to do this step-by-step!

Lastly, you asked us for additional pages and we’ve responded.  In fact, we’ve provided you the best situation possible – you can now build your own pages and customize to your hearts content.  This allows you to replace our pages, or augment the built-in pages with additional end-user pages.  In this session, we will share with you exactly “how” to do this providing you with all the power with UDI, Configuration Manager,  & MDT 2012.

Session Details

Our session should be a lot of fun as we embark on a demo-heavy presentation and beyond this we might even let you play a game or two… but we will see.  The end goal though, not to be mistaken, is to have you walk away with the understanding of how to empower your enterprise users while you provide the right level of management for your Windows deployments.  We want you to be an UDI expert – it starts on Wednesday.

Session Title:  Microsoft Deployment Toolkit 2012 UDI: Deploying Windows and Customizing the End User Deployment Experience

Day:  Tuesday, April 17

Time:  2:15-3:30 PDT

Room:  Veronese 2401

Enjoy!

Thanks,

-Chris