To perform a migration of packages, I’ve setup a Windows 7 virtual machine for hosting the App-V 5.0 Sequencer. This virtual machine is configured in exactly the same way that I’ve been configuring Windows for sequencing with App-V 4.x with the exception of a Q drive as this is no longer needed. For more information on how I recommend configuring a virtual machine, see this article: Delivering Office with App-V – Sequencer Recommendations & Best Practices.

Installing the App-V 5.0 Sequencer is very straight-forward process. Start the Sequencer setup from appv_sequencer_setup.exe:

You’ll need to accept the license agreement and joining the Customer Experience Improvement Program is not optional during the beta. Once the Sequencer is installed, two PowerShell modules are available – AppVPkgConverter and AppVSequencer. AppVPkgConverter is used for converting legacy packages to the new format.

To see the new modules, import the AppVPkgConverter module and list the available commands in that module, run the following commands from a PowerShell prompt:

Get-Module -ListAvailable
Import-Module AppVPkgConverter
Get-Command -Module AppVPkgConverter

Which looks like this:

The AppVPkgConverter module has two commands – ConvertFrom-LegacyAppvPackage and Test-LegacyAppVPackage.

In my test environment, I have a number of legacy packages that I’m going to convert. I have 22 packages, totalling 4.5Gb:

To test these packages before conversion, I can run the following command against a legacy package:

Test-LegacyAppvPackage <path to legacy package>

One of my packages results in a warning when running Test-LegacyAppvPackage against it, in this case an issue that won’t prevent conversion:

To test all of my packages and convert those without errors (but include those with warnings), I can use the following example code:

$Source = "Y:\Packages"
$Dest = "Y:\Packages.v5"
Get-ChildItem -Path $Source | Test-LegacyAppvPackage | Where-Object {$_.Errors.Count -eq 0 } | ConvertFrom-LegacyAppvPackage -Target $Dest

This will result in the packages being converted into the new format in the destination folder. In this example, the conversion process took a little over an hour.

To make this a little cleaner I’ve also added some code to move the converted packages into their own folder, so that each folder contains the APPV, MSI and XML files for a single package. Here’s the full code listing:

## Convert a folder of legacy App-V packages to v5 format

# Source and destination folders
$Source = "Y:\Packages"
$Dest = "Y:\Packages.v5"

# Test legacy packages and convert those without errors to the new format
Get-ChildItem -Path $Source | Test-LegacyAppvPackage | Where-Object {$_.Errors.Count -eq 0 } | ConvertFrom-LegacyAppvPackage -Target $Dest

# Move packages and related files to a sub-folder per-package
$Packages = Get-ChildItem -Path $Dest -Filter "*.appv*"
foreach ($Package in $Packages) {
	$Name = $Package.Name.substring(0,($Package.Name.length - 5))
	$PackageItems = Get-ChildItem -Path $Dest -Filter "$Name*"
	New-Item -Path $Dest\$Name -Type Directory
	For ($n=0; $n -le $PackageItems.Count -1; $n++) { Move-Item $PackageItems[$n].FullName $Dest\$Name }
}

Migrating packages from App-V 4.x to App-V 5.0 is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

I’ve taken the opportunity write something in PowerShell that can perform the configuration via the MDT task sequence. To do that I’ve had to resort to the PowerShell Management Library for Hyper-V. A special thanks to Jeff Wouters for pointing me in the right direction with a couple of the Hyper-V specific commands.

An odd occurrence when deploying Windows Server to these boxes is that the adapter names often change between each deployment. So what might be HP NC373i Multifunction Gigabit Server Adapter #13 today becomes HP NC373i Multifunction Gigabit Server Adapter #14 when I next re-deploy Windows to that box.

Because the New-VMExternalSwitch and Remove-VMSwitchNic commandlets to used configure the virtual networks require the adapter description, I’ve had to come up with a way to grab the description based on some that remains static – the MAC address. List below is a script that contains a list of MAC addresses (you could improve on this by keeping the list in a file) for each target MAC address in each server.

It’s just a simple list, so if I add another server, I just add the new server’s MAC address to the list. The script returns the description of the adapter with that MAC address and then uses that to configure the new virtual network. Enjoy.

## Configures a Hyper-V external virtual network based on a supplied MAC address

## Variables ##
# Path to the PowerShell Management Library for Hyper-V
$HyperVLibrary = "$env:ProgramFiles\modules\HyperV"

# Virtual switch name
$SwitchName = "External"

# List of MAC addresses for the adapter in each server to be bound to a virtual switch
# HV1=00:1C:C4:D8:36:BA; HV2=00:19:BB:C9:63:04;
$MACAddressList = "00:1C:C4:D8:36:BA", "00:19:BB:C9:63:04"

# If the PowerShell Management Library for Hyper-V exists, we're good to go
If (Test-Path $HyperVLibrary) {

    # Match a MAC address to a local adapter and return the adapter description
    $Adapters = get-wmiobject -query "Select * From Win32_NetworkAdapterConfiguration"
    For ($n=0; $n -le $MACAddressList.Count -1; $n++) {
        For ($i=0; $i -le $Adapters.Count -1; $i++) {
            If ($MACAddressList[$n] -eq $Adapters[$i].MACAddress) {
                $AdapterDecription = $Adapters[$i].Description
            }
        }
    }

    # Configure Hyper-V networking with the supplied MAC Address
    If ($AdapterDecription) {

        # Import the PowerShell Management Library for Hyper-V
	    Import-Module $HyperVLibrary

        # Create the Hyper-V network and remove the option 'Allow management operating system to share this network adapter'
        New-VMExternalSwitch -VirtualSwitchName $SwitchName -ExternalEthernet $AdapterDecription -force
        Remove-VMSwitchNic -Name $SwitchName -Force
    }
    Else {
        Write-Warning "Unable to match a local adapter from the list of supplied MAC addresses."
    }
}
Else {
    Write-Warning "'$HyperVLibrary' doesn't exist. Unable to continue without the PowerShell Management Library for Hyper-V."
}

Configuring Hyper-V Virtual Networks with PowerShell is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

What is Login VSI?

If you’re not familiar with Login VSI, it’s essentially the gold standard in vendor independent testing suite for measuring the performance and scalability of desktop virtualization evironments (hosted virtual desktop and session-based desktops).

Login VSI was developed to solve the problem of sizing an environment correctly. Login VSI allows you to test and compare different hardware and software configurations in your environment. The results of those tests will ensure that you can scale your infrastructure confidently as well as understand the impact of changes to your environment.

Client Side Performance Testing

Login Consultants have been working to extend the testing of desktop virtualization environments to the client with the ability to test performance of remoting protocols. This is important because it gives us a full end-to-end picture of the user experience in desktop virtualization environments. Remoting protocols can now be tested for network characteristics like bandwidth and latency and the effects on the performance on the protocol.

The client-side measure launcher can now be used to perform these tests:

• Character response – what’s the response time from pressing a key on the keyboard to that character being displayed on screen
• Desktop filling text – how long does it take to copy text from the local client clipboard and paste that text into a remote application
• Mouse click feedback – how long does it take to register the a mouse click and show that change to the user
• Image quality and loading times – how long does it take for an image to load and what is the resulting quality. This is very interesting because Login VSI can objectively measure the client-side image quality against the original lossless image

Scenarios

With very little between the performance of the most common remoting protocols on the LAN, there are a number of scenarios that will make for interesting tests in your environment, including:

• Testing access from branch offices across the WAN
• Branch access can also be tested using WAN simulator such as WANem
• Check response time – what is the real world response time for your typical work loads?
• Testing without caching enabled on the client for realistic results. Disabling caching enables you to test the raw performance of the remoting protocol

Additional Points

This is the first release of the Client Side Performance Testing module, so there’s a few things to consider:

• Linux clients aren’t yet available – the client-side module is Windows only
• This first version is aimed at typical office and line-of-business applications. Video and audio testing is planned for the next version and will be able to test audio and video sync
• A (beta?) release is planned within 2 weeks
• This module will be included in the Login VSI license

For more info on the Client Side Performance Testing module keep an eye on the Login VSI web site.

Client Side Performance Testing coming to Login VSI is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Creation of successful App-V packages requires building on a solid base – that base is the machine used to perform sequencing. This section details recommendations for creating the perfect sequencing machine. Follow these recommendations for the best chance at creating clean, successful App-V packages.

Obtain background information

Microsoft has made available a number of documents as introductions to App-V and the sequencing of applications.

• Review the product documentation that was included together with App-V. This includes the following documents:
  • Microsoft Application Virtualization Version 4.6 SP1 Trial Guide
  • How to Install the Application Virtualization Sequencer
  • App-V 4.6 Service Pack 1 Sequencing Guide
• Review the “Best practices to use for sequencing in Microsoft App-V ” article. For more information, click the following article number to view the article in the Microsoft Knowledge Base: 932137 (http://support.microsoft.com/kb/932137/)
• Install the Office suites and applications to become familiar with the functionality of the program. Additionally understand the deployment requirements for Office

Do’s and Don’ts

Don’t make the sequencing machine an exact copy of your Standard Operating Environment (SOE) or add the machine to your domain. That is, do not create a sequencing machine directly from your SOE; instead create a new environment that closely matches your SOE. There are several reasons for this:

• Your SOE most likely has many pre-requisites or applications installed that may interfere with sequencing, such as security agents and anti-virus
• Changes to your SOE may break virtual applications – if your SOE has a DLL required by a virtual application, that DLL wouldn’t be captured in the virtual application package. In the event of the SOE changing and the DLL being removed or the version changing, any virtual application package that doesn’t include that DLL may now not work
• Domain computers may have services, process or scheduled tasks that will interfere with sequencing or may cause files or registry settings to be inadvertently captured – changes made by a process that starts during sequencing will be captured in the package
• Domain computers may have policies applied that may be inadvertently captured in the package, causing issues with virtual applications or subsequent changes to those policies to be ignored

Based on my own experiences and those of others that I’ve spoken to, the most successful App-V packages are created on vanilla installations of Windows.

Don’ts

• Don’t add the sequencing VM to the domain, unless sequencing an application that requires it
• Don’t use an exact copy of your SOE
• Don’t install anti-virus applications or other security agents
• If possible, don’t access the Internet directly from the sequencing VM

Do’s

• Do leave Windows in workgroup mode the majority of applications
• Do use the same versions of components used in your SOE
• Do choose carefully which of those components should be installed in the sequencing VM
• Do scan the VM with the Microsoft Windows Malicious Software Removal Tool; optionally mount the VM’s virtual disk on your host machine and scan it with the anti-virus application on the host
• Do create a snapshot of the sequencing VM in a clean state
• Do patch the sequencing VM each month

Hardware

Always use a virtual machine to host the sequencing machine – a virtual machine provides snapshots to allow you to capture a clean image of the sequencing VM and then rollback to that clean snapshot after sequencing an application.When taking a snapshot, ensure that the virtual machine is shutdown – do not leave the Sequencer running when taking a snapshot. Leaving the VM running puts you at risk of creating multiple packages with the same GUID. Every App-V package requires a unique GUID.

If you are using a local PC for sequencing, a second hard drive to host the VMs is recommended so that the sequencing process does not affect the host machine.Virtual machine software or hypervisors available for free include:

• Microsoft Windows Virtual PC (Virtual PC does not support 64-bit guests)
• Microsoft Hyper-V, available as either a stand-alone product or as a component of Windows Server 2008 R2 SP1
• VMware Player (note that Player does not support snapshots)
• VMware vSphere Hypervisor
• Oracle VirtualBox
• Citrix XenServer

Create a new virtual machine with the following virtual hardware:

• 1 x vCPU – the Sequencer is still only single threaded and additional CPUs will make little difference
• A minimum of 1 GB RAM – Windows XP may require less
• Add NICs, a sound card, USB hubs, COM & LPT ports as required
• 2 x vDisks – use fixed size disks if you have the space. Fixed size disks will offer better IO performance. Additionally the App-V 4.6 SP1 Sequencer can automatically create a Q: drive if none already exists; however a second vDisk is a better approach.

If no secondary partition exists, the Sequencer setup will create a substituted drive letter for the virtual drive. A known issue exists where this configuration can cause an issue with new and upgraded packages because the Sequencer resolves the full path instead of the substituted drive letter.

This issue looks to be fixed with Hotfix 3 for the 4.6 SP1 Sequencer; however it is still recommended that you create a second vDisk, rather than let setup create the drive for you.

Windows

Windows XP Professional or Windows 7 Enterprise editions are recommended for client OS deployments. If you are sequencing for both Windows XP/7 and Windows Server, sequence on the lowest common denominator (Windows XP in this example). If issues arise with testing a package on a different operating system, create a new version of the package for that OS.To create a clean Windows VM for sequencing, follow these steps:

• Install Windows via the ISO, or better still, create an unattended deployment using the Microsoft Deployment Toolkit or your software deployment tool of choice, but keep the Windows deployment as vanilla as possible. Use the same Windows version and service pack level as your App-V client machines. This may mean creating multiple sequencing VMs. If you are deploying to both x86 and x64 clients, sequence on an x86 Windows machine, re-sequence the application on 64-bit Windows if required
  • Service Pack deployment is recommended via a slipstreamed Windows ISO (that is the ISO with the latest service pack integrated into it)
• Install the hypervisor tools or additions to install drivers and services required by the hypervisor to support the VM correctly
• Enable Windows Firewall including the File and Printer Sharing rule to prevent remote PCs from connecting to the virtual machine
• Active Windows inside the VM. A KMS will be make this simple; however if you are using a MAK key provided by your TechNet or MSDN subscription, this article is recommended reading: Managing product activation with a TechNet subscription
• Disable System Restore on Windows XP or System Protection on Windows 7
• Disable Windows Defender on Windows 7 (or disable the service)
• If deploying Windows 7, leave the following Optional Components enabled:
  • Windows Search
  • XPS Services
  • XPS Viewer
• If deploying Windows XP, remove the following Windows Components:
  • MSN Explorer
  • Internet Gateway Device Discovery and Control Client
  • Windows Messenger
  • Additionally it’s recommended to remove the Adobe Flash Player that comes with Windows XP: http://kb2.adobe.com/cps/141/tn_14157.html
• If deploying Windows XP or Windows Server 2003, install the following updates from the Microsoft Download Centre: http://microsoft.com/downloads
  • XML Paper Specification Essentials Pack
  • Windows Search 4.0 (available via Windows Update)
  • Windows Media Player 11 (available via Windows Update)
  • Update for Root Certificates (available via Windows Update)
• Install the latest version of Internet Explorer for the target operating system – if you would prefer to match the IE version of your SOE, then stick with that version. Set the home page to about:tabs, this will ensure that if Internet Explorer is started during sequencing it won’t attempt to connect to the Internet
• Install or enable the Microsoft .NET Framework – install the most recent version of the .NET Framework deployed in your environment. Note that .NET Framework 4.0 comes with all previous versions and .NET Framework 3.5 SP1 come with all its previous versions (and so on)
• Install the Visual C++ Redistributables – 2005, 2008 and 2010 redistributables are recommended. Multiple versions of each redistributable may be required depending on application requirements. It is recommended to install these in order of release
• Enable Microsoft Update
• Update Windows with the latest updates – High Priority, Critical and Important updates should be installed at a minimum
  • Do not install Microsoft Silverlight – this important for Microsoft Lync or if you intend to sequence Silverlight
  • Windows Update may need to be run multiple times to ensure all updates have been detected and installed
• Configure the following services (some services are not available on Windows XP):

• At a minimum, run the following built in applications so that they make changes to the local profile and remove first-run dialogs:
  • Control Panel
  • Internet Explorer including the Internet Options Control Panel applet
    • Start Internet Explorer a couple of times
    • Set the home page to about:tabs so that if IE is launched during sequencing, it will not connect to the Internet
  • Windows Media Player
  • Notepad
  • WordPad
• Restart the VM several times and log back on to ensure all first-run dialogs have been acknowledged or do not appear

Additional pre-requisites should only be installed when required by an application. For example, if Office is a pre-requisite of another application (such as SAP products or a plug-in) only install Office when sequencing that application.

At this point you will have a VM that can be used as a sequencing environment as well as an App-V client. It is highly recommended that you create two VMs based on this environment so that you have a second VM to perform testing of packages to confirm that the sequenced applications work at runtime.

Sequencer

Office 2010 is only supported with the 4.5 SP2 and 4.6 SP1 version of the Sequencer. Office 2007 and Office 2003 can be sequenced with earlier versions. Where possible it is recommended to use the latest Sequencer – this often requires the matching version of the client to be deployed as well (although the App-V 4.6 SP1 Sequencer is backwardly compatible with the App-V 4.6 client).

Install the Sequencer into the VM along with the most recent hotfix rollup. At the time of publishing of this document the most recent versions of the Sequencer are:

• App-V 4.6 Service Pack 1 with Hotfix Rollup 3: http://support.microsoft.com/kb/2571168
• App-V 4.5 Service Pack 2: http://support.microsoft.com/kb/980847

Application Install Source

Installing applications from a copy of the setup files located on a local disk inside the VM is recommended. Installation of the application from setup files located on a network share may cause files from that location to be captured during sequencing. Create a local folder inside the VM where application setup files will be copied to before sequencing. For example, use C:\Packages or C:\Source.

To ensure successful sequencing, it is not recommended to run setup applications directly from the networkEnsure that the folder is then added as an exclusion in your sequencing projects – often application setups may write log or temporary files to the same folder.

Snapshots

Once Windows has been configured, shutdown the VM – never take a snapshot of the virtual machine with the App-V Sequencer running. Each App-V package must have a unique GUID and snapshots with the Sequencer running are often a source of duplicate GUIDs. Additionally a VM in a shutdown state will take less room on disk for a snapshot because the VM’s RAM won’t be included in the snapshot.

Periodically rollback the VM to this snapshot to install the latest updates from Windows Update, then re-create the snapshot.

Sequencer Template

The App-V 4.6 SP1 Sequencer supports templates which will allow you to configure project options including exclusions, enabling Windows Update during sequencing and enabling compression when saving the package. Package templates can be used by multiple sequencing engineers or across multiple Office packages to ensure consistency.

Package Options

A number of options can be set in a sequencer template that may be required for an Office package:

• Allow Microsoft Update to run during monitoring – enable updating of an Office package via Windows Update
• Allow all named objects and COM objects to interact with the local system – this enabled LOCAL_INTERACTION_ALLOWED in the OSD file. This will save you from having to set this option manually after sequencing. If you are creating an Office package that will co-exist with other Office packages or locally installed Office, do not enable this option
• Compress Package – Reduce the size of your Office package with compression. Recommended for all Office packages.

Exclusions

The table below lists the recommended exclusions to add when sequencing Office applications.

Using the Sequencer Template

To create a sequencer template, open the Sequencer and choose Tools / Options to set the package options and exclusions. Then choose File / Save As Template to save the file to disk. Save the template to a file and open in a text editor such as Notepad. The new template will have a number of changes over a default templateUnder DEFAULTS, the following options will be set to Yes (if they aren’t change them to Yes):

<DEFAULT Name="AllowMUADuringMonitoring" Value="Yes"/>
<DEFAULT Name="CompressPackage" Value="Yes"/>

Additional exclusions should also be listed, for example:

<EXCLUSION Pattern="Q:\MSOCACHE" Context="VFS_EXC" Type="PSR_DataSystem"/>

The DEFAULTOSD section sets the LOCAL_INTERACTION_ALLOWED option:

<DEFAULTOSD>&lt;SOFTPKG&gt;&lt;IMPLEMENTATION&gt;&lt;CODEBASE HREF="rtsps://%SFT_SOFTGRIDSERVER%:322/"/&gt;&lt;OS VALUE="Win7"/&gt;&lt;VIRTUALENV&gt;&lt;POLICIES&gt;&lt;LOCAL_INTERACTION_ALLOWED&gt;TRUE&lt;/LOCAL_INTERACTION_ALLOWED&gt;&lt;/POLICIES&gt;&lt;/VIRTUALENV&gt;&lt;/IMPLEMENTATION&gt;&lt;/SOFTPKG&gt;
</DEFAULTOSD>

To use the template during sequencing, start the Sequencer and choose File / New from Template, and choose your Sequencer Template file.

Delivering Office with App-V – Sequencer Recommendations & Best Practices is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Microsoft TechNet recently went through a redesign that seems to have removed some content and in particular a list of App-V white papers that was on the previous Application Virtualization TechCenter no longer exists.

A couple of the white papers are currently available on TechNet, but the full list still includes a number of useful documents that are not. Here’s the original list of documents available for download:

App-V White Papers is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

I’ve removed personally identifiable information from the original email.

Question

We have set up Citrix / App-V environment and sequenced Office 2010 Pro Plus and we have installed the MSOffvirt kit [the Office 2010 Deployment Kit for App-V] using the Office Pro Plus Key on the Citrix PVS servers as part of the PVS image. Now our client has decided they also want to be able to deliver Office 2010 Std via app-v as well. Do we now need to change the license key that it is installed with the MSOffvirt kit or is there another way round it? We could of course silo it and have Office Pro Plus on some PVS servers and Office Standard on others.

Answer

My first recommendation would actually be against virtualizing the primary version Office, but I’ll assume that your Office requirements are simple and virtualizing Office with App-V is working OK for you.

It sounds like you’re already aware that App-V doesn’t really allow you to juggle different editions of Office on the same machine, as the Deployment Kit handles licensing, you can only add a single edition (e.g. Standard or Professional Plus) to any single machine. If you’ve already got an existing PVS image, I would recommend cracking it open, uninstalling the Deployment Kit and reinstalling using the product key for the edition you need in each image. That way you can ensure you have a clean image.

My ideal approach to this would be to build the PVS image from an unattended source (such as the Microsoft Deployment Toolkit) where you’ve changed the product key, rather than manually make changes to the image.

From a licensing perspective, Microsoft doesn’t provide you the right to license a device for Office 2010 Professional Plus and then deploy Standard edition to that device. You can read more on licensing in this document: Downgrade Rights – Microsoft Volume Licensing Programs, Original Equipment Manufacturer (OEM) License, and Full Packaged Product (FPP) License, February 2011

Mailbag – Deploying multiple editions of Office 2010 with App-V is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

A critical vulnerability has been identified in Adobe Reader X (10.1.1) and earlier versions for Windows and Macintosh, Adobe Reader 9.4.6 and earlier 9.x versions for UNIX, and Adobe Acrobat X (10.1.1) and earlier versions for Windows and Macintosh. This vulnerability (CVE-2011-2462) could cause a crash and potentially allow an attacker to take control of the affected system. There are reports that the vulnerability is being actively exploited in limited, targeted attacks in the wild against Adobe Reader 9.x on Windows.

Since the release of Reader and Acrobat X, there have been no malware that has been effective against the Protected Mode (sandbox) feature of version X. From Adobe’s blog post on this issue:

I’d like to take this moment to encourage any remaining users still running Adobe Reader or Acrobat 9.x (or worse, older unsupported versions) to PLEASE upgrade to Adobe Reader or Acrobat X. We put a tremendous amount of work into securing Adobe Reader and Acrobat X, and, to date, there has not been a single piece of malware identified that is effective against a version X install. Help us help you by running the latest version of the software!

If you have any version of Adobe Reader other than X deployed, you should seriously consider migrating to the new version as a matter of priority. That’s not “lets consider doing this in the next month” – you should stop reading this post and get started deploying Reader X now.

Furthermore if are deploying or have deployed Reader X, I can’t recommend virtualizing it with application virtualization. The reason for this is that Protected Mode is not compatible and is not supported with application virtualization. It doesn’t work with Citrix App Streaming, Microsoft App-V or VMware ThinApp (it may be possible with the current version of ThinApp, but I haven’t confirmed).

[Update: thanks to prompting from Dan Gough, I've confirmed that Protected Mode in Reader X (10.1.1), works under App-V 4.6.1.30091 (Hotfix 4)]

[Update 2: Protected Mode in Reader X is confirmed to work under ThinApp 4.6.2 and 4.7. You'll have to update your virtual applications and re-enable Protected Mode with the latest releases]

In short – leaving Protected Mode enabled will protect your users and devices and because Protected Mode has been incompatible with the isolation that application virtualisation introduces, I recommend that you do not deploy Reader X with application virtualization solutions unless you are using the very latest versions.

But.. what about those scenarios when a virtualized application needs to call a locally installed Reader X? Until the app virt vendors fully support Protected Mode, the best you can do is ensure that Protected Mode is only disabled when Reader runs within the virtualization environment (using a tool like PolicyPak) and is not completely disabled. Until then, the best we can do is cross our fingers and hope it doesn’t happen to us.

Don’t put yourself at risk by virtualizing Adobe Reader X is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

What you lose by virtualizing Firefox

Virtualizing Firefox with App-V will isolate the application from the OS, so the following features will not be available once Firefox has been sequenced:

• Firefox Jump Lists in the Start Menu and Taskbar
• The ability set the browser as default

Firefox features to disable

There are a couple of features that should be disabled when running Firefox under App-V:

• Automatic updates for Firefox – Options / Advanced / Update – Automatically check for updates to: Firefox. Firefox updates should be delivered via new App-V packages. Updates for Add-ons and Search Engines should be OK as these are written to the user profile
• Default browser check – Options / Advanced / General – Always check to see if Firefox is the default browser on startup. Once Firefox is isolated from the OS, the user won’t be able to make it the default browser

I will cover using a couple of customisation to ensure these features are disabled for any new Firefox profile.

Managing the Firefox profile – virtualize or not?

Firefox stores preferences, extensions and other user data in:

• %APPDATA%\Mozilla (preferences, bookmarks etc.); and
• %LOCALAPPDATA%\Mozilla (browser cache)

The default behaviour of the App-V Sequencer is to exclude %LOCALAPPDATA% – this is a good thing and I don’t recommend removing this exclusion. %APPDATA% will be included by default and whether you leave this location included in the package will depend on your specific deployment requirements; however my recommendation is to exclude this location by adding %CSIDL_APPDATA%\Mozillato the exclusion list in your sequence. On the client, Firefox will then create a new profile in the real file system when the user starts the browser for the first time. There are several reasons why this approach is a good idea:

• Some of the configuration files within the Firefox profile include hard-codes paths – challenging if your App-V virtual drive changes between clients
• Virtualizing the profile increases the complexity of upgrading Firefox packages especially challenging given Mozilla’s new approach to Firefox releases. By storing the Firefox profile on the real file system, Firefox can be deployed via completely unrelated packages – no need to create upgrade versions
• Users can potentially create multiple Firefox profiles, with each stored in the users’ PKG file. The minimum size for a new Firefox profile is 12Mb – the PKG file will grow by 12Mb for each new Firefox profile created

By excluding %APPDATA% and not virtualizing the user profile you will gain some flexibility with your Firefox deployment.

Configuring Firefox Defaults

If a Firefox profile is not virtualized within the package any options set during the monitoring phase won’t be captured. Fortunately Firefox can be configured with defaults for any new profile so that it will contain your required configuration options.

Mozilla has made it easy to deploy custom default settings and preferences – by adding files to %ProgramFiles%\Mozilla Firefox\defaults\profile (change the path to suit your environment), new Firefox profiles will pick up a copy of these files when the profile is created. I will walk through adding a couple of files to this location to ensure that any new Firefox profile receives the required settings. You can find more detailed documentation on these features in the following articles:

• User.js file
• Prefs.js file
• UserChrome.css and Chrome element names and IDs
• Enterprise Build Of Firefox For Deployment

To enforce user settings we can leverage user.js and the use UserChrome.css to remove those user interface elements. Available below is a copy of user.js that disables automatic updates of Firefox and checking whether it is the default browser:

Firefox user.js

A simple approach to extending the options in user.js and prefs.js is to install Firefox and configure it the way you would like. Then open prefs.js from the new profile and use the entries to create custom versions.

Available here is a copy of userChrome.css that will remove from the user interface the options to enable browser updates and set Firefox as the default browser:

Firefox userChrome.css

Sequencing Platform

I have sequenced Firefox 8 on a clean Windows 7 SP1 x86 VM with all current updates and no other applications other than the App-V Sequencer. I’ve configured a Q: drive using a second vDisk, rather than let the Sequencer create a Q: drive for me. I’ve used a VFS install and tested successfully; however if you would prefer a MNT install just change the install folder when installing Firefox

The Firefox version available from Mozilla is an x86 application (x64 build are available from other sources), so I generally recommend sequencing Firefox on Windows 7 x86 virtual machine even though you may be deploying to 64-bit Windows. However confirm this in your own environment and re-sequence for 64-bit platforms if required.

Sequencer Configuration

Before Sequencing, add the following exclusions:

• %CSIDL_APPDATA%\Mozilla
• %CSIDL_COMMON_APPDATA%\Microsoft\RAC
• \REGISTRY\USER\%SFT_SID%\Software\Microsoft\Windows\CurrentVersion\Internet Settings

If you are adding Adobe Flash Player to the package, add these exclusions as well:

• %CSIDL_APPDATA%\Adobe
• %CSIDL_APPDATA%\Macromedia
• %CSIDL_WINDOWS%\Installer

I have included these in a Package Template for Firefox that you can download from here:

App-V Package Template for Firefox

Installing Firefox

Download the Firefox installer in your target language from the Mozilla site. Sequencing Firefox will require the following steps:

• Install Firefox
• Configure profile defaults
• Optionally add global add-ons and install plug-ins such as Adobe Flash Player

Automating this process as much as possible will create a cleaner package and make it faster to re-create a new Firefox package if required.

• Mozilla Firefox installer command line arguments – use the INI file approach to control where Firefox is installed and to prevent the addition of a desktop shortcut, if required
• After installing Firefox, copy user.js to %ProgramFiles%\Mozilla Firefox\defaults\profile
• Copy userChrome.css to %ProgramFiles%\Mozilla Firefox\defaults\profile\chrome
• Firefox also allows you to add global add-ons by adding them to the Extensions sub-folder of the Firefox installation folder
• If you are including Adobe Flash player in the package, be sure to disable the auto-update notification

For an example script that will automate the install and configuration of Firefox, see the script below:

@ECHO OFF
SET SOURCE=%~dp0
SET SOURCE=%SOURCE:~0,-2%

REM Create the Firefox answer file
ECHO [Install] > %SOURCE%\Firefox8.ini
ECHO ; InstallDirectoryName=Firefox8 >> %SOURCE%\Firefox8.ini
ECHO ; InstallDirectoryPath=Q:\MozillaFirefox8_en-GB >> %SOURCE%\Firefox8.ini
ECHO QuickLaunchShortcut=false >> %SOURCE%\Firefox8.ini
ECHO DesktopShortcut=false >> %SOURCE%\Firefox8.ini
ECHO StartMenuShortcuts=true >> %SOURCE%\Firefox8.ini
REM Install Firefox - the START command will not work if the Firefox setup filename includes spaces
START /WAIT FirefoxSetup8.exe /INI=%SOURCE%\Firefox8.ini

REM Configure Firefox profile defaults
MD "%ProgramFiles%\Mozilla Firefox\defaults\profile\chrome"
COPY %SOURCE%\user.js "%ProgramFiles%\Mozilla Firefox\defaults\profile\user.js"
COPY %SOURCE%\userChrome.css "%ProgramFiles%\Mozilla Firefox\defaults\profile\chrome\userChrome.css"

Shortcuts

If the monitoring phase was successful the Sequencer should create a single shortcut for Firefox. If you are including Flash Player, add an additional shortcut for the Flash Player Control Panel applet using “C:\Windows\System32\FlashPlayerCPLApp.cpl” as the target.

First Run Tasks and Primary Feature Block

If the steps above have been followed for exclusions, installation and configuration of Firefox, there will be no first run tasks to complete. Additionally the resultant package will be reasonably small so there is no need to create the Primary Feature Block. Because you don’t need to complete first run tasks or create the Primary Feature Block, you could automate the entire end-to-end process of creating a Firefox package using the App-V Sequencer command-line interface.

Finally

Save your package and deploy. With compression enabled, the package should be around 22Mb.

Sequencing Mozilla Firefox 8 is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

What you lose by virtualizing Chrome

Virtualizing Chrome with App-V will isolate the application from the OS, so the following features will not be available once Chrome has been sequenced:

• Chrome Jump Lists in the Start Menu and Taskbar
• The ability set the browser as default
• The Chrome sandbox (maybe)

Note: Note that disabling the sandbox will reduce the browser security. This is not recommended and as such, I actually do not recommend virtualizing Chrome, if it is to be your regular browser.

Managing the Chrome profile – virtualize or not?

Chrome stores preferences, extensions and other user datain:

• %LOCALAPPDATA%\Google\Chrome\User Data\Default (preferences, bookmarks etc. and browser cache)

I don’t know why Google has chosen this location by default, however I suspect that it may be to encourage users to signup for a Google account to enable the native syncing features of the browser. The Chrome User Data folder can become very large and that’s without the Cache folder. You could potentially hit the limit of the user PKG file size.

Whether you the Chrome user profile in the package will depend on your specific deployment requirements; however my recommendation is to use this sync feature and leave the User Data outside of the App-V package.

There are a couple of reasons why this approach is a good idea:

• Some of the configuration files within the Chrome profile include hard-codes paths – challenging if your App-V virtual drive changes between clients
• Virtualizing the profile increases the complexity of upgrading Chrome packages especially challenging given how often the browser is updated. By storing the Chrome profile on the real file system, Chrome can be deployed via completely unrelated packages – no need to create upgrade versions

By not virtualizing the user profile you will gain some flexibility with your Chrome deployment.

However, if you absolutely must place the Chrome profile in the virtual environment, then here’s a couple of approaches to including the User Data folder in the App-V package:

1. Use the –user-data-dir and –disk-cache-dir command line parameters to specify an alternate location for the User Data and Cache folders
2. Remove the exclusions for the Local AppData location from the Sequencer before sequencing

For the first approach, add the parameters to the command line, placing the User Data folder in the roaming portion of the profile and the browser cache in the local portion:

chrome --user-data-dir=%AppData%\Google\Chrome\User Data --disk-cache-dir=%LocalAppData%\Google\Chrome\User Data

The second approach doesn’t require any command line parameters, but it will require modifying the default Sequencer exclusions and some scripting:

• Remove the default exclusions of %CSIDL_LOCAL_APPDATA% and %CSIDL_PROFILE%\Local Settings
• Add an exclusion for %CSIDL_LOCAL_APPDATA%\Google\Chrome\User Data\Default\Cache or %CSIDL_PROFILE%\Local Settings\Google\Chrome\User Data\Default\Cache, depending on the operating system you are sequencing on
• Post sequencing, set the folder to Merge with Local and add a pre-launch script that creates the Cache folder outside of the virtual environment

The first approach would be the easiest way to go.

Chrome features to disable

There are a couple of features that should be disabled when running Chrome under App-V:

• Browser auto updates. Chrome updates should be delivered via new App-V packages
• Default browser check. Once Chrome is isolated from the OS, the user won’t be able to make it the default browser

Disabling browser auto updates on Windows requires setting a policy. This can be done via Group Policy, delivered post sequence, or placing the policy directly into the package. To deliver the setting via Group Policy, ensure that the Policies key is not captured in the package.

To set the policy during sequencing, run the following command:

REG ADD HKLM\SOFTWARE\Policies\Google\Update /v AutoUpdateCheckPeriodMinutes /d 0 /t REG_SZ /f

Google Update should also be excluded from the package, which I discuss below. The default browser check can be disabled with a couple of approaches including the master preferences file.

Configuring Chrome Defaults

If a Chrome profile is not virtualized within the package any options set during the monitoring phase won’t be captured. Fortunately Chrome can be configured with defaults for any new profile so that it will contain your required configuration options. Google has made it simple to deploy custom default settings and preferences – by adding a preference file to the same folder where Chrome is installed, Chrome will use these master preferences for any new user who runs Chrome.

For information on what these master preferences are, see the Chromium administrators documentation on master preferences. I’ve included a sample master_preferences file in which I have set several defaults including removing the default browser check, preventing Google from adding a shortcut to the user’s desktop on first run and setting a home page.

Google Chrome Master Preferences

Remove the .txt file extension to use

Sequencing Platform

I have sequenced Google Chrome 15.0.874.106 on a clean Windows 7 SP1 x86 VM with all current updates and no other applications other than the App-V Sequencer. I’ve configured a Q: drive using a second vDisk. I’ve used a VFS install because installing Chrome to the Q: drive isn’t an option, unless you want to move the application manually.

Sequencer Configuration

Before Sequencing, add the following exclusions:

• \REGISTRY\USER\%SFT_SID%\Software\Microsoft\Windows\CurrentVersion\Internet Settings
• %CSIDL_COMMON_APPDATA%\Microsoft\RAC
• %CSIDL_WINDOWS%\Microsoft.NET
• %CSIDL_WINDOWS%\Installer
• %CSIDL_PROGRAM_FILES%\Google\Update
• %CSIDL_WINDOWS%\Tasks

The last two exclusions will prevent Google Update related binaries from being captured. Additionally disable the option to “Allow Virtualization of Services” to prevent the capture of the Google Update services.

I have included these options in a Package Template for Chrome that you can download here:

Google Chrome App-V Sequence Template

Sequencing Chrome

Download the Google Chrome Enterprise (or MSI) installer. Sequencing Chrome will require the following steps:

1. Install Chrome using the Windows Installer file
2. Delete the cached copy of the Chrome installer, which won’t be required once delivered with App-V
3. Move chrome.exe to the same folder as the current version’s binaries (or vice-versa).

With the default folder structure, Chrome will execute during sequencing, but won’t execute once delivered to a client. The debug.log file will contain entries similar to this:

[1106/180706:ERROR:client_util.cc(231)] Could not get Chrome DLL version.
[1106/180706:ERROR:client_util.cc(268)] Could not find exported function RelaunchChromeBrowserWithNewCommandLineIfNeeded

4. Copy the master_preferences file to the same location as chrome.exe to configure user profile defaults
5. Disable browser auto updates
6. Prevent the Sequencer from deleting the Chrome application folder once the monitoring phase is finished. To see why the Sequencer may process a reboot task that deletes the Chrome install folder read this article: The Case of the Disappearing Application during Sequencing.

Automating this process as much as possible will create a cleaner package and make it faster to re-create a new Chrome package if required. Here’s an example script that will perform the tasks above:

START /WAIT GoogleChromeStandaloneEnterprise.MSI ALLUSERS=TRUE /QB-
RD /Q /S "%ProgramFiles%\Google\Chrome\Application\15.0.874.106\Installer"
ROBOCOPY "%ProgramFiles%\Google\Chrome\Application\15.0.874.106" "%ProgramFiles%\Google\Chrome\Application" /mov /e
COPY master_preferences "%ProgramFiles%\Google\Chrome\Application\master_preferences
REG ADD HKLM\SOFTWARE\Policies\Google\Update /v AutoUpdateCheckPeriodMinutes /d 0 /t REG_SZ /f
REG ADD "HKLM\System\CurrentControlSet\Control\Session Manager" /v PendingFileRenameOperations /d "" /t REG_MULTI_SZ /f

Shortcuts

For Chrome to run successfully under App-V there are a few additional command line parameters that will need to be added to the Chrome shortcut at the configure applications stage:

• –disable-custom-jumplist: Disables the Windows 7 Jump List, which doesn’t work once Chrome is virtualized any way
• –no-default-browser-check: A further flag to prevent the browser from prompting the user to set it as default
• –in-process-plugins: Run plugins inside the renderer process. May be optional, but has been required in the past when virtualizing Chrome
• –no-sandbox: Not required; however I have found that extensions do not install if this parameter has not been added

For the full list of command-line parameters for Chrome and Chromium see this page: List of Chromium Command Line Switches

With the sandbox running, you will see an error similar to this when attempting to add an extension:

Note: Note that disabling the sandbox will reduce the browser security. I recommend testing the browser functionality and see if you can get away without disabling the sandbox.

The browser will notify you when the sandbox is disabled:

First Run Tasks and Primary Feature Block

If the steps above have been followed for exclusions, installation and configuration of Chrome, there will be no first run tasks to complete. Additionally the resultant package will be reasonably small so there is no need to create the Primary Feature Block. Because you don’t need to complete first run tasks or create the Primary Feature Block, you could automate the entire end-to-end process of creating a Chrome package using the App-V Sequencer command-line interface.

Finally

Save your package and deploy. With compression enabled, the package should be around 36Mb.

Sequencing Google Chrome 15 is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

I thought that that behaviour was a little strange, so decided to test this out myself and to my surprise I could replicate the issue. To track down what was going on, I had to perform some troubleshooting.

I tested this on a virtual machine running Windows 7 SP1 x86 and could see from browsing to the Google installation folder (C:\Program Files\Google\Chrome) that the Application sub-folder was being removed after the monitoring phase was complete. To work out which process was deleting the folder, I’ve used Process Monitor. To see what was going on, I’ve reset my VM back to a clean snapshot, started the App-V Sequencer and Process Monitor and set a filter in Process Monitor for Path beginning with C:\Program Files\Google\Chrome\Application and then re-started the sequencing process.

With this filter, I was able to see that the process that was deleting the folder is the Sequencer itself (SFTSequencer.exe). Click the screenshot for a larger view.

The next most obvious place to look then is the Sequencer log file, hopefully it will hold some information about why the folder is being deleted. To view the Sequencer log, browse to C:\Program Files\Microsoft Application Virtualization Sequencer\Logs and open sft-seq-log.txt.

In this file I can see a number of lines where the Sequencer is attempting to copy files that no longer exist:

[11/03/2011 21:45:34 VRB VFSX] ...failed getting long path name for the file (C:\Program Files\Google\Chrome). Error: 2
[11/03/2011 21:45:34 VRB CORE] GetShortPathName failure using: C:\Program Files\Google\Chrome. Error is: 2
[11/03/2011 21:45:34 VRB CORE] Could not copy C:\Program Files\Google\Chrome to Q:\Google Chrome\VFS\CSIDL_PROGRAM_FILES\Google\Chrome.  Error is: 2.
[11/03/2011 21:45:34 VRB VFSX] ...failed getting long path name for the file (C:\Program Files\Google\Chrome\Application). Error: 3
[11/03/2011 21:45:34 VRB CORE] GetShortPathName failure using: C:\Program Files\Google\Chrome. Error is: 2
[11/03/2011 21:45:34 VRB CORE] Could not copy C:\Program Files\Google\Chrome to Q:\Google Chrome\VFS\CSIDL_PROGRAM_FILES\Google\Chrome.  Error is: 2.
[11/03/2011 21:45:34 VRB CORE] CopyResourceToVFS failed.
[11/03/2011 21:45:34 VRB VFSX] ...failed getting long path name for the file (C:\Program Files\Google\Chrome\Application\15.0.874.106). Error: 3
[11/03/2011 21:45:34 VRB CORE] GetShortPathName failure using: C:\Program Files\Google\Chrome. Error is: 2
[11/03/2011 21:45:34 VRB CORE] Could not copy C:\Program Files\Google\Chrome to Q:\Google Chrome\VFS\CSIDL_PROGRAM_FILES\Google\Chrome.  Error is: 2.
[11/03/2011 21:45:34 VRB CORE] CopyResourceToVFS failed.

A few lines previous to these is this line:

[11/03/2011 21:45:26 VRB RTSK] Reboot processing detected need to delete \??\C:\Program Files\Google\Chrome.

The Sequencer is doing exactly what’s it being told to do – process a reboot task at the end of the monitoring phase and delete the application. Interestingly though, only the Application sub-folder is being deleted, not the entire Chrome parent folder.

To get an idea of why, I’ve used WhyReboot, a fantastic free tool for finding out why a reboot has been requested. How many times have you suspected that an application installer asks to reboot Windows when it’s not actually needed?

Going through the sequencing process again and running WhyReboot before ending monitoring, gives me an idea of why the reboot has been requested:

Note: I could also use PendMoves another Sysinternals tool to query this information as well.

PendingFileRenameOperations is a Registry value that lists file system operations that must be processed during a reboot or shutdown. Generally these types of operations need to be processed on reboot because there are open file handles that are only released once the system shuts down.

So what’s writing this entry to PendingFileRenameOperations and why does this only happen during sequencing? To find out, I’ve reached for Process Monitor again, but unfortunately I haven’t been able find which process is writing to the PendingFileRenameOperations value, as Process Monitor didn’t find any RegSetValue operations.

Circumstantial evidence points to SETUP.EXE, but without Process Monitor giving me more information I can’t say for sure. I do however, have a workaround that allow me to sequence Chrome – before finishing the monitoring phase, I clear the PendingFileRenameOperations data with this command:

REG ADD "HKLM\System\CurrentControlSet\Control\Session Manager" /v PendingFileRenameOperations /d "" /t REG_MULTI_SZ /f

The Case of the Disappearing Application during Sequencing is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

• Prescriptive Guidance for Sequencing Office 2010 in App-V 4.6 SP1
• Prescriptive guidance for sequencing Office 2010 using Microsoft App-V 4.5 or 4.6
• Prescriptive guidance for sequencing 2007 Office programs in Microsoft App-V

you will end up with a package that will include the following folders in the virtualized user profile (those folders captured during sequencing that will end up in the PKG file):

The folders captured under %CSIDL_APPDATA%\Microsoft are those folders that have been created during the first-run tasks – folders created when you launch an Office application and perform some standard tasks.

If you’re familiar with delivering applications with App-V (or any type of application virtualization platform) and managing the user environment, the portions of the user profile for an application will also be virtualized (unless you do something like this) and will end up in the PKG file.

To see what this looks like at runtime, here’s a view of a profile before running Office applications that have been delivered by App-V:

After executing each of the Office applications in the package (I’ve used a package with Office 2010 Professional Plus with Visio and Project) and using just about every feature in those applications:

There’s an additional 10 folders that have been created with 8 of those related to Office. This has left me with the majority of the Office user profile being virtualized and stored in the PKG file, whilst the rest is now stored on the real file system. This probably doesn’t have too much impact to the user if I’m using Roaming Profiles so that Office settings follow the user, but what happens for support?

The service desk now has to manage Office settings for the user in two places. If the aim is repair the Office settings by resetting the App-V package deleting the PKG file, a portion of the Office settings will remain. This is not an ideal solution – the profile for an application should virtualized entirely or not be virtualized at all.

Do that, you will need to add an additional step during sequencing – create those folders that during the monitoring phase. I do this via a script (that also installs and configures Office) that will create the folders listed in the table below. If you do that, the entire Office profile will now be virtualized.

Delivering Office with App-V – The User Profile is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

MSIEXEC /I OffVirt.msi PIDKEYS=XXXXX-XXXXX-XXXXX-XXXXX-XXXXX USEROPERATIONS=1

You might receive the following error:

This is due to the key used on the command line and not actually any pre-existing component of Office, as the message suggests. If you are not using a MAK key – that is a key available for a volume license deployment of Office, then the installation will result in the error above. The only way to fix this issue is to ensure you are using a MAK or KMS key for Office 2010.

Keys from Retail or boxed media, or a TechNet or MSDN subscription cannot be used for deploying Office 2010 via App-V. Making it particularly difficult for those looking to get experience virtualizing Office 2010 with App-V without purchasing a volume license.

(Neither the Office or App-V teams at Microsoft have any control over keys available on TechNet or MSDN)

Delivering Office with App-V – The Deployment Kit and Product Key issues is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

What you lose by virtualizing Firefox

Virtualizing Firefox with App-V will isolate the application from the OS, so the following features will not be available once Firefox has been sequenced:

• Firefox Jump Lists in the Start Menu and Taskbar
• The ability set the browser as default

Managing the Firefox profile – virtualize or not?

Firefox stores preferences, extensions and other user data in:

• %APPDATA%\Mozilla (preferences, bookmarks etc.); and
• %LOCALAPPDATA%\Mozilla (browser cache)

The default behaviour of the App-V Sequencer is to exclude %LOCALAPPDATA% – this is a good thing and I don’t recommend removing this exclusion.

%APPDATA% will be included by default and whether you leave this location included in the package will depend on your specific deployment requirements; however my recommendation is to exclude this location by adding %CSIDL_APPDATA%\Mozilla to the exclusion list in your sequence. On the client, Firefox will then create a new profile in the real file system when the user starts the browser for the first time.

There are several reasons why this approach is a good idea:

• Some of the configuration files within the Firefox profile include hard-codes paths – challenging if your App-V virtual drive changes between clients
• Virtualizing the profile increases the complexity of upgrading Firefox packages especially challenging given Mozilla’s new approach to Firefox releases. By storing the Firefox profile on the real file system, Firefox can be deployed via completely unrelated packages – no need to create upgrade versions
• Users can potentially create multiple Firefox profiles, with each stored in the users’ PKG file. The minimum size for a new Firefox profile is 12Mb – the PKG file will grow by 12Mb for each new Firefox profile created

By excluding %APPDATA% and not virtualizing the user profile you will gain some flexibility with your Firefox deployment.

Configuring Firefox Defaults

If a Firefox profile is not virtualized within the package any options set during the monitoring phase won’t be captured. Fortunately Firefox can be configured with defaults for any new profile so that it will contain your required configuration options.

Mozilla has made it easy to deploy custom default settings and preferences – by adding files to %ProgramFiles%\Mozilla Firefox\defaults\profile, new Firefox profiles will pick up a copy of these files when the profile is created.

I will walk through adding a couple of files to this location for to ensure that any new Firefox profile receives the required ; however you can find more detailed documentation on this feature in the following articles:

• Enterprise Build Of Firefox For Deployment

Firefox features to disable

There are a couple of features that should be disabled when running Firefox under App-V:

• Automatic updates for Firefox – Options / Advanced / Update – Automatically check for updates to: Firefox. Firefox updates should be delivered via new App-V packages. Updates for Add-ons and Search Engines should be OK as these are written to the user profile
• Default browser check – Options / Advanced / General – Always check to see if Firefox is the default browser on startup. Once Firefox is isolated from the OS, the user won’t be able to make it the default browser

user.js is used to configure Firefox options and enforce them and UserChrome.css is used to remove those options from the user interface.

Available below is a copy of user.js that disables automatic updates of Firefox and checking whether it is the default browser:

Firefox user.js

Here is a copy of userChrome.css that will remove updates and default browser options from user interface:

Firefox userChrome.css

Sequencing Platform

The Firefox version available from Mozilla is an x86 application (x64 build are available from other sources), so I recommend sequencing Firefox on Windows 7 x86 virtual machine even though you may be deploying to 64-bit Windows.

I’ve used a VFS install, so I have configured a second virtual hard disk to host the Q: drive. If you would prefer a MNT install just change the install folder when installing Firefox.

Sequencer Configuration

Before Sequencing, add the following exclusions:

• %CSIDL_APPDATA%\Mozilla
• %CSIDL_COMMON_APPDATA%\Microsoft\RAC
• \REGISTRY\USER\%SFT_SID%\Software\Microsoft\Windows\CurrentVersion\Internet Settings

If you are adding Adobe Flash Player to the package, add these exclusions as well:

• %CSIDL_APPDATA%\Adobe
• %CSIDL_APPDATA%\Macromedia
• %CSIDL_WINDOWS%\Installer

I have included these in a Package Template for Firefox that you can download from here:

App-V Package Template for Firefox

Installing Firefox

Download the Firefox installer in your target language from the Mozilla site. Sequencing Firefox will require the following steps:

• Install Firefox
• Configure profile defaults
• Optionally add global add-ons and install plug-ins such as Adobe Flash Player

Automating this process as much as possible will create a cleaner package and make it faster to re-create a new Firefox package if required.

• Mozilla Firefox installer command line arguments – use the INI file approach to control where Firefox is installed and to prevent the addition of a desktop shortcut, if required
• After installing Firefox, copy user.js to %ProgramFiles%\Mozilla Firefox\defaults\profile
• Copy userChrome.css to %ProgramFiles%\Mozilla Firefox\defaults\profile\chrome
• Firefox also allows you to add global add-ons by adding them to the Extensions sub-folder of the Firefox installation folder
• If you are including Adobe Flash player in the package, be sure to disable the auto-update notification

For an example script that will automate the install and configuration of Firefox, see the script below:

Firefox 7 Install Script for App-V

Shortcuts

If the monitoring phase was successful the Sequencer should create a single shortcut for Firefox. If you are including Flash 10.4 or above in the package, add an additional shortcut for the Flash Player Control Panel applet using “C:\Windows\System32\FlashPlayerCPLApp.cpl” as the target.

First Run Tasks and Primary Feature Block

If the steps above have been followed for exclusions, installation and configuration of Firefox, there will be no first run tasks to complete. Additionally the resultant package will be reasonably small so there is no need to create the Primary Feature Block.

Because you don’t need to complete first run tasks or create the Primary Feature Block, you could automate the entire end-to-end process of creating a Firefox package using the App-V Sequencer command-line interface.

Finally

Save your package and deploy. With compression enabled, the package should be around 22Mb.

Sequencing Mozilla Firefox 7 is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

In this post I’m using Office Professional 2010 as an example, where I’ve reduce the size of the package from potentially 2.8GB (uncompressed) to 606Mb (compressed). This screenshot shows a default install left uncompressed:

The default Office installation caches a copy of the Office installation files in the C:\Windows\Installer and the MSOCache folders. These folders are generally required when installing Office so that repair operations can take place and features can be added post-installation. However when virtualizing Office, we won’t want either of those actions taking place – we want consistency and predictability. So when capturing Office with the Sequencer, we configure setup and run applications to ensure they don’t occur.

This then leaves us with a large amount of data in the package that will never be used at execution time, but will most likely still be streamed to each client – waste of disk space and bandwidth. Only when it comes time to update the package do we need those folders.

So instead of leaving them in the package, we could exclude them from the sequencer and copy them out of the Sequencing machine and save them with the package. The process would look something like this:

1. Add an exclusion to your package for %CSIDL_WINDOWS%\Installer and C:\MSOCache or %SFT_MNT%\MSOCache if you are sequencing Office
2. Sequence your application and save the package with compression enabled
3. Save the package to the Content share along with a copy of C:\Windows\Installer and MSOCache, if you are sequencing Office
4. When it comes time to update the package, copy the folders back into the sequencing machine before starting the sequencing process
5. Repeat the process once you’ve saved the updated package

The same Office 2010 package is now 606Mb – 22% of the size of the original package:

Reducing the size of App-V packages is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

I’ve previously talked about virtualizing Apple iTunes with App-V; however after taking a look through the distribution agreements that you’re supposed to accept, I’m under the impression that doing so doesn’t adhere to the agreement.

If you’re looking to distribute iTunes and QuickTime in your environment, Apple requires that you obtain an agreement to do so. There are two agreements – one for universities and another for corporations (uni’s actually have 2 – one for CD distribution, another for distribution from a server).

Here’s a quote from the university CD distribution agreement:

Licensee may not modify or alter the Software, or the Apple End User Agreement that accompanies the Software. The Software must be installed as part of the default installation of the Bundle without any additional action or selection required by the End User, using the installer provided by Apple. Installation must include all files as installed by such installer and Licensee must not interfere with the installer’s placement of the software alias icons on the desktop.

And here’s a quote from the corporate site license:

Licensee may not modify or alter the Software, the Apple installer or the Apple End User Agreement that accompanies the Software as provided by Apple to Licensee. As a condition of the rights granted herein, each installation of the iTunes and QuickTime Software must result in the iTunes and QuickTime Player icon residing on the desktop of each authorised user.

Based on my recipe for iTunes, I understand the process of virtualising the application to be breaking the agreement because we are doing a few things:

• Extracting the MSI’s from the iTunes installer – breaking the Apple installer
• Accepting the End User Agreement during the monitoring phase
• Probably not delivering the iTunes and QuickTime shortcuts to the desktop

I could configure my package such that the user still needs to accept the license agreement, but in a corporate environment do you really want to have to let users do that?

I could also deliver the iTunes and QuickTime shortcuts to the user’s desktop, but most users already have enough shortcuts and files on their desktops, I’m not going to force more on them. Forcing desktop shortcuts on users isn’t great user experience and quite frankly, Apple’s not going to dictate the user experience in my environment.

But ultimately it’s point 1 that has me concerned – if you interpret the agreement to the letter, then it sounds like application virtualization is breaking that agreement.

What do you think?

Is it legal to virtualize Apple iTunes? is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Articles that detail limitations and workarounds that have been updated recently include:

• Click-to-Run: Known issues
• In Office Click-to-Run 2010, some functionality is unavailable, or an Office add-in does not run correctly
• When Office Click-to-Run 2010 is installed, Microsoft Word is not listed as an application when you right-click an .htm file or an .mhtml file and then click “Open with”
• You cannot use the “send to” feature of an external application together with Office Click-to-Run for Outlook 2010
• Office 2010 Click-to-Run compatibility with add-ins
• “This product must be installed to Q:” error message when you try to install Office 2010 that is delivered by Click-to-Run
• How to use command-line switches in Office Click-to-Run for Office 2010

There’s even an article on getting into the virtual environment (which is good for a laugh):

• How to access the registry information of Office 2010 that is delivered by Click-to-Run

For even more articles on Click-to-Run, start with this search on the Microsoft Support site.

Although some of the same limitation don’t apply if you are creating your own App-V package for Office, these articles are still worthwhile resources.

Microsoft Office Click-to-Run for Office 2010 KB articles help explain how Office runs under App-V is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Additionally, in an effort to remove the lock on the file, you can’t use POWERCFG to disable hibernation after Hyper-V is installed:

While there’s a work-around to get hibernation working,  there’s not much to gain with hibernation enabled on a fast SSD drive. Especially when dual-booting puts space at a premium and the hibernation file is 8GB.

Just remember to disable hibernation before enabling Hyper-V with:

POWERCFG -H OFF

Disable Hibernation before enabling Hyper-V on a laptop is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

What you lose by virtualizing Firefox

Virtualizing Firefox with App-V will isolate the application from the OS, so the following features will not be available once Firefox has been sequenced:

• Firefox Jump Lists in the Start Menu and Taskbar
• The ability set the browser as default

Managing the Firefox profile – virtualize or not?

Firefox stores preferences, extensions and other user data in:

• %APPDATA%\Mozilla (preferences, bookmarks etc.); and
• %LOCALAPPDATA%\Mozilla (browser cache)

The default behaviour of the App-V Sequencer is to exclude %LOCALAPPDATA% – this is a good thing and I don’t recommend removing this exclusion.

%APPDATA% will be included by default and whether you leave this location included in the package will depend on your specific deployment requirements; however my recommendation is to exclude this location by adding %CSIDL_APPDATA%\Mozilla to the exclusion list in your sequence. On the client, Firefox will then create a new profile in the real file system when the user starts the browser for the first time.

There are several reasons why this approach is a good idea:

• Some of the configuration files within the Firefox profile include hard-codes paths – challenging if your App-V virtual drive changes between clients
• Virtualizing the profile increases the complexity of upgrading Firefox packages especially challenging given Mozilla’s new approach to Firefox releases. By storing the Firefox profile on the real file system, Firefox can be deployed via completely unrelated packages – no need to create upgrade versions
• Users can potentially create multiple Firefox profiles, with each stored in the users’ PKG file. The minimum size for a new Firefox profile is 12Mb – the PKG file will grow by 12Mb for each new Firefox profile created

By excluding %APPDATA% and not virtualizing the user profile you will gain some flexibility with your Firefox deployment.

Configuring Firefox Defaults

If a Firefox profile is not virtualized within the package any options set during the monitoring phase won’t be captured. Fortunately Firefox can be configured with defaults for any new profile so that it will contain your required configuration options.

Mozilla has made it easy to deploy custom default settings and preferences – by adding files to %ProgramFiles%\Mozilla Firefox\defaults\profile, new Firefox profiles will pick up a copy of these files when the profile is created.

I will walk through adding a couple of files to this location for to ensure that any new Firefox profile receives the required ; however you can find more detailed documentation on this feature in the following articles:

• Enterprise Build Of Firefox For Deployment

Firefox features to disable

There are a couple of features that should be disabled when running Firefox under App-V:

• Automatic updates for Firefox – Options / Advanced / Update – Automatically check for updates to: Firefox. Firefox updates should be delivered via new App-V packages. Updates for Add-ons and Search Engines should be OK as these are written to the user profile
• Default browser check – Options / Advanced / General – Always check to see if Firefox is the default browser on startup. Once Firefox is isolated from the OS, the user won’t be able to make it the default browser

user.js is used to configure Firefox options and enforce them and UserChrome.css is used to remove those options from the user interface.

Available below is a copy of user.js that disables automatic updates of Firefox and checking whether it is the default browser:

Firefox user.js

Here is a copy of userChrome.css that will remove updates and default browser options from user interface:

Firefox userChrome.css

Sequencing Platform

The Firefox version available from Mozilla is an x86 application (x64 build are available from other sources), so I recommend sequencing Firefox on Windows 7 x86 virtual machine even though you may be deploying to 64-bit Windows.

I’ve used a VFS install, so I have configured a second virtual hard disk to host the Q: drive. If you would prefer a MNT install just change the install folder when installing Firefox.

Sequencer Configuration

Before Sequencing, add the following exclusions:

• %CSIDL_APPDATA%\Mozilla
• %CSIDL_COMMON_APPDATA%\Microsoft\RAC
• \REGISTRY\USER\%SFT_SID%\Software\Microsoft\Windows\CurrentVersion\Internet Settings

If you are adding Adobe Flash Player to the package, add these exclusions as well:

• %CSIDL_APPDATA%\Adobe
• %CSIDL_APPDATA%\Macromedia
• %CSIDL_WINDOWS%\Installer

I have included these in a Package Template for Firefox that you can download from here:

App-V Package Template for Firefox

Installing Firefox

Download the Firefox installer in your target language from the Mozilla site. Sequencing Firefox will require the following steps:

• Install Firefox
• Configure profile defaults
• Optionally add global add-ons and install plug-ins such as Adobe Flash Player

Automating this process as much as possible will create a cleaner package and make it faster to re-create a new Firefox package if required.

• Mozilla Firefox installer command line arguments – use the INI file approach to control where Firefox is installed and to prevent the addition of a desktop shortcut, if required
• After installing Firefox, copy user.js to %ProgramFiles%\Mozilla Firefox\defaults\profile
• Copy userChrome.css to %ProgramFiles%\Mozilla Firefox\defaults\profile\chrome
• Firefox also allows you to add global add-ons by adding them to the Extensions sub-folder of the Firefox installation folder
• If you are including Adobe Flash player in the package, be sure to disable the auto-update notification

For an example script that will automate the install and configuration of Firefox, see the script below:

Firefox Install Script

Shortcuts

If the monitoring phase was successful the Sequencer should create a single shortcut for Firefox. If you are including Flash 10.3 or above in the package, add an additional shortcut for the Flash Player Control Panel applet using “C:\Windows\System32\FlashPlayerCPLApp.cpl” as the target.

First Run Tasks and Primary Feature Block

If the steps above have been followed for exclusions, installation and configuration of Firefox, there will be no first run tasks to complete. Additionally the resultant package will be reasonably small so there is no need to create the Primary Feature Block.

Because you don’t need to complete first run tasks or create the Primary Feature Block, you could automate the entire end-to-end process of creating a Firefox package using the App-V Sequencer command-line interface.

Finally

Save your package and deploy.

Resources

• App-V Package Accelerator for Mozilla Firefox 5.0 (x86 en-US) and Adobe Flash Player 10.3.181.26 (en-US)

Sequencing Mozilla Firefox 5 is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

What you lose by virtualizing iTunes

Because virtualizing iTunes with App-V will isolate the application from the OS, the following features will not be available once iTunes has been sequenced:

• The iTunes Jump List
• The iTunes toolbar integration into the Taskbar
• Windows Firewall exclusions (manual changes will be required to support media sharing)

iTunes Components

To start at the beginning requires taking a look at the components of iTunes. Note that iTunes comes in 32-bit and 64-bit versions, so be sure to download and sequence the correct version for your target platform. I tested this sequence using iTunes 10.3.1 x86 on 32-bit Windows; however the same approach will apply for the 64-bit version and (presumably) future versions of 10.x.

Extracting the iTunes installer results in several files:

• AppleSoftwareUpdate.msi – Software Update is used to download and Apple software and updates
• SetupAdmin.exe – the setup wrapper application
• AppleApplicationSupport.msi – all Apple applications on Windows require this as a dependency
• AppleMobileDeviceSupport.msi – required for Apple mobile device support (iPhone, iPad etc.). This installer includes the drivers for Apple’s devices
• QuickTime.msi – iTunes uses QuickTime for video codec support
• Bonjour.msi – iTunes uses Bonjour to find shared music libraries, to find AirPort Express devices for streaming music to, and to find Apple TVs
• iTunes.msi – the iTunes installer itself

It is important that Apple Software Update is not included in the App-V package – allowing the applications in the package to update will at best fail and at worst, most likely bloat the package if it were allowed to run after deployment. Before copying the iTunes setup files into your sequencing VM, delete AppleSoftwareUpdate.msi and SetupAdmin.exe. This will prevent the iTunes installer from automatically installing Software Update during sequencing.

Prepare the Sequencing VM

I have successfully created an iTunes package using a virtual machine running 32-bit Windows 7 SP1 with Internet Explorer 9 and all current updates.

I used a VFS install, so I have configured a second virtual hard disk to host the Q: drive to avoid this bug. If you would prefer a MNT install, just add the INSTALLDIR to the command line for each Windows Installer file.

Before starting the Sequencer, three steps must be completed:

1. Install Apple Application Support – I have not included this in the package because I had issues connecting a mobile device when it including it. However I did include it in this previous QuickTime package, so it may very well be possible to include this component in the package.
2. Install Apple Mobile Device Support – this is required to be installed outside of the package because it contains the mobile device drivers
3. Create an iTunes folder structure in the user profile under %AppData%

These same steps will need to be followed on the App-V client computer that will run iTunes. Fortunately Apple Application Support and the Mobile Device Support come as Windows Installer files, so they will be easy to deploy.

What to do about AppData

iTunes is a excellent example of an application written by developers who appear to have absolutely no idea about how Windows profiles work. Take a look at the size of the AppData\Roaming\Apple Computer folder in my profile on an existing computer with iTunes installed:

With logs, a back-up of two devices and two copies of iOS 4.3.3 (one for an iPhone and one for an iPad), this folder is a whopping 8.41 GB and contains over 17000 files. Just imagine enabling Roaming Profiles with that in your profile – that’s a lot of coffee waiting for logon to complete.

To be fair, I don’t think that iTunes was intended to be used in an environment with Roaming Profiles; but the amount of data that iTunes stores in this location highlights one of the challenges we face when developers make questionable decisions.

There are two ways of getting around this problem:

1. Do not virtualize the user profile at all – iTunes will create the AppData folder structure in the user profile at launch just like it would for any new user account
2. Virtualize only those portions of the user profile that contain iTunes preferences – you might like to take this approach if you want to preconfigure iTunes

In this article I will demonstrate how to take approach number 2. If you would prefer approach 1, ensure that %CSIDL_APPDATA% has been added to the exclusions list before sequencing.

Before Sequencing – Create the AppData folders

To work around the large amount of data that iTunes stores in the profile, create the following folders before sequencing:

• %AppData%\Apple Computer\iTunes\iPad Software Updates
• %AppData%\Apple Computer\iTunes\iPad Updater Logs
• %AppData%\Apple Computer\iTunes\iPhone Carrier Support
• %AppData%\Apple Computer\iTunes\iPhone Software Updates
• %AppData%\Apple Computer\iTunes\iPhone Updater Logs
• %AppData%\Apple Computer\iTunes\iPod Software Updates
• %AppData%\Apple Computer\iTunes\iPod Updater Logs
• %AppData%\Apple Computer\WebKit
• %AppData%\Apple Computer\iTunes\Apple Mobile Device Sync Diagnostics Logs
• %AppData%\Apple Computer\Logs
• %AppData%\Apple Computer\MobileSync
• %AppData%\Apple Computer\SyncServices\Local

By creating these folder before sequencing will make it simpler to set Merge with Local attributes on the captured folders. The paths above will then also be excluded from the package and must be created on the App-V client computer at runtime.

Installing iTunes

Sequencing is as simple as capturing the installation of the following files and configuring iTunes the way we want:

• QuickTime.msi
• Bonjour.msi
• iTunes.msi

However, iTunes and QuickTime store preferences in less than ideal locations. Here are the default locations for those preferences:

• Most iTunes preferences are stored here: %AppData%\Apple Computer\iTunes\iTunesPrefs.xml
• Some computer specific preferences are stored here: %LocalAppData%\Apple Computer\iTunes\iTunesPrefs.xml
• QuickTime preferences are stored here: %LocalAppData%Low\Apple Computer\QuickTime\QuickTime.qtp
• QuickTime Player preferences are stored here: %LocalAppData%\Apple Computer\QuickTime\QTPlayerSession.xml

Ideally these would all be located under %AppData%. Unfortunately the only preference file that we can move is for QuickTime (%LocalAppData%Low\Apple Computer\QuickTime\QuickTime.qtp).

To change the QuickTime preferences location, change the path under the following Registry value:

• HKCU\Software\Apple Computer, Inc.\QuickTime\LocalUserPreferences\FolderPath

I do not recommend attempting to include the %LocalAppData% or %LocalAppData%Low locations as these end up containing cache files which we need to avoid capturing to keep the package size to a minimum.

Automating the iTunes install

There’s no reason why you couldn’t install and configure QuickTime and iTunes during sequencing manually; however I think that scripting the process as much as possible will help create a more successful package. I have a script that performs the following:

• Installs QuickTime and iTunes with updates and desktop shortcuts disabled
• Installs Bonjour
• Perform some clean-up actions including removing unneeded shortcuts
• Changes the QuickTime configuration file location to %AppData% (instead of the AppData\LocalLow folder)
• Copy in a pre-configured QuickTime configuration file
• Create the folders in %AppData% that we want to capture in the package
• Start QuickTime Player and then iTunes to provide an opportunity to configure each application (first-run tasks)

You can download the script here:

iTunes App-V Install Script

Place the script into the same folder as the iTunes Windows Installer files as it will attempt to run the MSI files from the same location.

Sequencer Exclusions

There are a number of locations that we need to exclude from capture during sequencing:

• %CSIDL_APPDATA%\Apple Computer\iTunes\iPad Software Updates
• %CSIDL_APPDATA%\Apple Computer\iTunes\iPad Updater Logs
• %CSIDL_APPDATA%\Apple Computer\iTunes\iPhone Carrier Support
• %CSIDL_APPDATA%\Apple Computer\iTunes\iPhone Software Updates
• %CSIDL_APPDATA%\Apple Computer\iTunes\iPhone Updater Logs
• %CSIDL_APPDATA%\Apple Computer\iTunes\Apple Mobile Device Sync Diagnostics Logs
• %CSIDL_APPDATA%\Apple Computer\Logs
• %CSIDL_APPDATA%\Apple Computer\MobileSync
• %CSIDL_APPDATA%\Apple Computer\SyncServices
• \REGISTRY\USER\%SFT_SID%\Software\Microsoft\Windows\CurrentVersion\Internet Settings
• \REGISTRY\USER\%SFT_SID%_Classes\Local Settings\Software\Microsoft\Windows\Shell
• %CSIDL_PROFILE%\Music

I have included these in a Package Template for iTunes that you can download from here:

iTunes App-V Package Template

Sequencing iTunes

To sequence iTunes, follow the basic outline here:

1. Start the Sequencer and create a new package from the iTunes template available above

2. Create a Standard Application package

3. Package installer – select either the iTunes scripted install command listed above or C:\Windows\System32\cmd.exe

4. Add a package name – I have used Apple iTunes 10 x86

5. Start the installation. You can run iTunes and QuickTime during this step to perform first run tasks.

6. First Run tasks

• QuickTime – follow the recommendations for configuration in this article: Virtualising Apple QuickTime 7.x
• iTunes – iTunes will prompt to make itself the default for media files – set this if required and be sure to disable the option ‘Warn me if iTunes is not the default player for audio files’

7. Customize shortcuts

• Remove the About Bonjour & PictureViewer shortcuts (I recommend removing all shortcuts, leaving only QuickTime and iTunes)
• Remove QuickTime shortcut unless required
• Place all shortcuts under \Programs\iTunes in the Start Menu

8. Primary Feature block

• Run iTunes, you may have to force exit of child processes if required
• No need to run QuickTime Player unless required

Post-Sequencing

There are a few post-sequencing tasks to perform:

AppData: Check that Merge with Local has been applied to folders captured in AppData correctly. The image below shows the Apple Computer and Apple Computer\iTunes folders have been set to Merge with Local. If the pre-sequence steps that create the AppData folder structure are followed (or you are excluding AppData), then no manual action should be required.

Add a script to the iTunes OSD file to create the AppData folder structure that should exist on the real file system:

For an example of what to add to the OSD file, download the example here:

iTunes App-V OSD AppData script

iPod Service: Set the iPod Service to Automatic. This will ensure that the service is ready as soon as iTunes starts.

Child Processes: when iTunes launches, several processes with also be started – AppleMobileDeviceHelper.exe, distnoted.exe (both installed instead of in the iTunes package), iPodService.exe and mDNSResponder.exe (The iPod and Bonjour services respectively).

On occasion these processes may remain running after iTunes has exited, if this is the case (and you may have already seen this behaviour when building the Primary Feature block) set TERMINATECHILDREN to True in the iTunes OSD.

Compression: The package should weigh in at around 290Mb, so depending on your deployment method you could compress it to save bandwidth.

Running iTunes

Deploying the iTunes package will require the deployment of Apple Application Support and Apple Mobile Device Support to the client computers first. Without Apple Application Support the following will be the result of launching iTunes:

While I’ve been able to test iTunes successfully running on an App-V Client, there appears (at this stage at least) to be only one issue – when plugging in a mobile device, the following error is displayed, twice:

Although iTunes reports this error and I can confirm that the service is started (it’s running natively, not within the package), once acknowledged device sync works anyway. I’ve tested with LOCALINTERACTIONALLOWED which hasn’t helped. I’ll update this post if I find a solution.

Last, but not least, for media sharing to work, firewall exceptions will be required for the following processes:

• iTunes – Q:\Apple iTunes 10 x86\VFS\CSIDL_PROGRAM_FILES\iTunes\iTunes.exe
• Bonjour service – Q:\Apple iTunes 10 x86\VFS\CSIDL_PROGRAM_FILES\Bonjour\mDNSResponder.exe

The path to the processes may change depending where you install iTunes and dependent components.

Sequencing Apple iTunes 10 is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Caveats

There are several caveats to keep in mind:

• By default, App-V only adds file type associations so that you can double click on a file to open it in a virtual package. This approach is not changing that behaviour
• This will only work for file or folder right-click menu options, it won’t get other shell integration working
• As we are editing the package Windows Installer file, your App-V deployment must use the MSI file to install the package. You could use an OSD script to integrate these changes, but the user would need to run the package at least once for the script to execute

Right-click Items for WinRAR

In this example, I’m using WinRAR (just like the ThinApp example), so I’ve had to determine the command line passed to WinRAR by each right-click item. To do that I’ve used Process Explorer with an installed version of WinRAR.

In this example, I will add the following right-click options:

• Add to archive… to folders
• Compress and email… to folders
• Extract files… to .RAR files

Viewing the properties of the WINRAR.EXE process displays the command line used for each item:

Editing the MSI

To add these right-click items, I’m using my favourite MSI editor InstEd to open the MSI that the App-V Sequencer generated when I sequenced WinRAR. Making these edits was a manual process for me, but depending on which MSI editor you use there are probably simpler ways of achieving the same thing.

There are four tables in the MSI where I need to make changes:

• Component
• Registry
• FeatureComponents
• InstallExecuteSequence

Component Table

Go to the Component table and create a new entry. This will require a unique name (I’ve used AppVShellValues) and GUID – your MSI editor should be able to generate the GUID for you.

Registry Table

The Registry table, which is empty by default, will require one entry per addition to the Registry. In this example I have three entries:

The entries will each need to use the following items:

• Registry: this requires a unique value
• Root: the value corresponds to HKLM
• Key: the key path will be dependent on the menu item; however each key will require the \Command path
• Name: this is the Registry value being added, in this example we are editing the default value, so leave this as null
• Value: the command that the item will run. This passes command line arguments to SFTTRAY which will launch the application and then pass the command line to WinRAR.
• Component_: use the component name created in the previous step

The command stored in the Value column must launch the application via the App-V Client and pass parameters to that application:

• I can reference the App-V Client install folder as [SGINSTALLPATH] as this is a property in the MSI
• I need to use the application name as listed in the App-V shortcut. In my example I can use [ProductName] because the App-V package name and the application name are the same; however this may not be the case for all packages. The application name may need to be hard coded into the MSI here. You could create a new entry in the Property table for the application name and reference it here
• The rest of the command is what is passed to the application by SFTTRAY.EXE

FeatureComponents Table

Add a new entry to the FeatureComponents table – use VirtualApp in the Feature_ column and select the same component used in the previous tables in the Component_ column

InstallExecuteSequence Table

The last step is to ensure that the Registry entries added to the MSI are installed in the correct order. As the MSI file is really just a wrapper for the SFTMIME command, the Registry entries could be overwritten when the SFTMIME command adds the package.

To change the sequence find the WriteRegistryValues entry which will have a Sequence value of 5000. Change this value to 6580 which will ensure that our custom Registry entries are added after the package is added and loaded but before the installer completes its finalize tasks.

Install the Package

If the modifications to the MSI have been completed correctly, you should see your right-click menu options from within Windows Explorer:

Adding Shell Extensions to App-V Packages is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

No, this isn’t an April Fools joke – I wanted to see if I could sequence Microsoft Comic Chat using App-V. After seeing Raymond Chen’s latest post on Comic Chat, I had to take a look.

Comic Chat is a radically different kind of internet chat program, released by Microsoft in 1996. Instead of representing chat dialogs as text, like the majority of internet chat programs, or as graphical worlds like some emerging chat programs, Comic Chat visually represents conversations as sequences of comic panels.

Using App-V to deliver this application is actually a great example of the power of using any application virtualization product to deliver your legacy applications. The first version of Comic Chat was release in 1996 when we were all running Windows 95, even to run our businesses. Running Comic Chat today under Windows 7 will result in this error:

Comic Chat is expecting to be able to write to the HKEY_LOCAL_MACHINE key in the Registry. App-V solves this issue two ways – capturing the writes at first launch and optional allowing standard users to write to protected locations because the writes occur within the virtual environment.

Getting ready to sequence Comic Chat

You can download Microsoft Comic Chat 2.5 from David Kurlander’s site (Kurlander is the designer of Comic Chat). See the Getting Started page for installation and usage instructions.

Although Comic Chat installs OK on Windows 7, during sequencing Setup produces this error:

Fortunately, there’s an easy fix – before starting the monitoring phase, configure mschat25.exe to start in Windows XP Compatibility Mode:

Sequencing Comic Chat

I sequenced Comic Chat on Windows 7 using the App-V 4.6 SP1 Sequencer. Sequencing is simple enough – just install to the default folder. During first run, you can choose to enable the Comic Strip view:

You might also like to remove the extra shortcut created by Setup in Start Menu\Programs\Internet Explorer:

And that’s about it. I’ve tested execution on a Windows 7 SP1 64-bit installation. Other than taking some time to connect to an IRC server, Comic Chat works under App-V on Windows 7.

Comic Chat Package Accelerator

If you’d like to sequence Comic Chat yourself, I’ve uploaded a Package Accelerator to the TechNet Gallery – App-V Package Accelerator for Microsoft Comic Chat 2.5

Sequencing Microsoft Comic Chat is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

If you’re a seasoned sequencing engineer the Sequencer has some major UI changes, but let me show you why I think that once you’ve had an opportunity to use the new Sequencer, you’ll be smiling. (Minimise during sequencing is back too which will make plenty of people even happier)

Sequencer Installation

Built-in best practices are implemented right from installation – the first change you’ll see is during the installation of the Sequencer. Setup will ask for the virtual drive letter:

If this drive letter does not already exist as an actual partition or volume within your sequencing computer, Setup will create a drive substitution for you. (The substitution is to %ProgramData%\Microsoft\Application Virtualization Sequencer\Package Root\).

Another best practice is implemented during installation – the creation of a dummy ODBC connection. Both a system DSN and a user DSN for the current user are created:

Sequencer Templates

App-V 4.6 SP1 introduces Sequencer Templates which can be used to standardise commonly applied settings when you create new virtual application packages. This will help streamline the process of creating virtual application packages, especially if your own best practices differ from the default settings.

Sequencer Templates (.sprt files) are single XML files than can be copied into your sequencing VM and applied to new packages. These will become an important part of any packaging team’s methods for standardising their packages.

Sequencer Templates can include the following settings:

• Advanced Monitoring Options (e.g. allow Windows Update during monitoring, Rebasing DLLs)
• Package Deployment Settings (e.g. the default server hostname and protocol)
• General Options (e.g. creating an MSI package)
• Parse Items
• Exclusion Items

A master template or templates for specific application types can be used to ensure everyone is using the same settings for their sequences.

Preparing for Sequencing

When sequencing an application the Sequencer will now ensure that the sequencing computer has been prepared correctly. In the example below you can see four issues that the Sequencer has detected:

• Windows Defender is running
• The Windows Search service is running
• Some applications are open before starting the sequencing process
• My virtual machine has not been reverted to a clean state before starting wizard

The Sequencer is recommending a solution for each issue before proceeding:

Getting this type of information directly from the Sequencer is a fantastic feature because it will assist in creating successful and cleaner packages.

Creating Packages

The SP1 Sequencer now directly assists in capturing the type of application you are sequencing. Making a decision at this point about the type of application changes the sequencing workflow so that the Sequencer can guide you through the capture process.

Getting this process correct is especially important for add-ons or middleware components that you might link to a primary application using Dynamic Suite Composition.

Editing Packages

The same approach has been taken when editing packages:

By choosing the package edit task within the Sequencer, you will be guided through an edit or update task, making it simpler to generate a new version of a package. The workflow will change depending on the task that you choose.

Install Phase

During the installation phase, the Sequencer will prompt for a package name. You’ll notice here that the Sequencer is auto-creating the Primary Virtual Application Directory and using a name that does not adhere to a previous best practice of using an 8.3 naming convention:

Behind the scenes the Sequencer is taking care of the 8.3 folder for you, making sequencing that one step simpler. You can however, continue using your existing naming conventions if you have them by using the Edit (Advanced) check box.

At this point, the Sequencer will also remind you to where to install the application you are sequencing:

A small UI change, but a simple one that will assist those new to the sequencing process.

First Run Tasks

In previous versions of the Sequencer, it wasn’t very clear that you should perform first run tasks after installing an application. First run tasks are now placed front and centre in a separate step during the sequencing process:

Identifying potential virtualization issues

How do you record excluded files and registry keys or even features that won’t work once an application has been virtualised and isolated from the OS today? It’s not simple and I would guess that for many organisations this information is not documented. Thankfully the new Sequencer exposes much of this information with package reports – excluded files and unsupported application features (such as shell extensions) are recorded and listed and the end of the sequencing process.

The screenshot below shows a couple of examples when sequencing Adobe Reader – shell extensions that won’t be available once Reader has been virtualised and files that have been excluded from the package:

Opening these items will display detailed information:

This information is then saved for each package in a new file named report.xml:

Summary

The App-V 4.6 SP1 Sequencer is available now and because packages generated from this version will work with the RTM release of the 4.6 client and above, you can start using it today.

For some additional resources on App-V best practices, see these articles:

• Microsoft Application Virtualization Version 4.6 Trial Guide
• Best practices to use for sequencing in Microsoft App-V

Other App-V MVPs are blogging about App-V 4.6 SP1 as well:

• Kevin Kaminski on How the App-V 4.6 SP1 Sequencer Makes Packaging Easier, Faster and More Predictable
• Tim Mangan on The New App-V Package Accelerator
• Kalle Saunamäki on What are the Package Accelerators?
• Ment van der Plas on Diagnostics in the App-V 4.6 SP1 Sequencer

How the App-V 4.6 Service Pack 1 Sequencer helps you implement best practices is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

I’ve spent some time working out how folder and Registry exclusions and Merge/Override settings impact the package at runtime and this post is based on my findings. Although I believe that the details in this post are correct, I recommend testing out these behaviours for yourself.

Why Exclude?

When virtualising an application, we may need to avoid capturing specific paths for several reasons:

• Reduce the size of the package (installers often put files down that aren’t required for an application to execute, such as cached setup files)
• Prevent conflicts with data already on the client (preventing a virtualised view of specific paths so that a virtualised application does not see different data to application running outside of App-V)
• When running an operating system component such as Internet Explorer inside the bubble, we may want to ensure that the application sees the same data inside and outside the bubble

Exclusions Apply at Sequencing Time Only

Exclusions are only used to prevent certain paths from being captured during sequencing; it does not necessarily mean that those paths will then not be virtualised at runtime.

Understanding how an application interacts with the operating system and other applications is important for knowing which paths to add as exclusions. In most cases if a path exists both inside and outside of the package it won’t affect execution; however depending on your requirements, some locations should never appear inside the virtual environment.

These paths might include, but are not limited to:

• MAPI profiles (the Windows Messaging Subsystem key)
• Printers (stored in the HKCU\Printers)
• ODBC connections (stored in HKCU\Software\ODBC)
• Windows 7 Libraries (%APPDATA%\Microsoft\Windows\Libraries)

I’ll discuss some of these in more detail later.

Creating a Package for Testing

To perform some tests and to illustrate what happens during sequencing and execution, I’ve created a very simple package that contains some Registry keys and folders. I turned the following script into an App-V package:

REG ADD "HKEY_CURRENT_USER\Software\MergeTest1" /v InsideTheBubble /t REG_SZ /d "True"
REG ADD "HKEY_CURRENT_USER\Software\MergeTest1\Key" /v InsideTheBubble /t REG_SZ /d "True"
REG ADD "HKEY_CURRENT_USER\Software\MergeTest2" /v InsideTheBubble /t REG_SZ /d "True"
REG ADD "HKEY_CURRENT_USER\Software\MergeTest3" /v InsideTheBubble /t REG_SZ /d "True"
MD "%APPDATA%\MyApplication1"
MD "%APPDATA%\MyApplication2\InsideSub-folder"
ECHO txt > "%APPDATA%\MyApplication1\InsideTheBubble.txt"
ECHO txt > "%APPDATA%\MyApplication2\InsideTheBubble.txt"
ECHO txt > "%APPDATA%\MyApplication2\InsideSub-folder\InsideTheBubble.txt"

How the Virtual File System interacts with the Real File System

Excluded folder paths in an App-V package works just the way you would expect – the folder is not captured in the package. I then may choose to control how the folder is handled at execution time by setting the path to Override the Local Directory (preventing the package from see the real file system) or Merge with the Local Directory (the application sees a merged view of the virtual and real file systems).

In my example package I’ve added the path %APPDATA%\MyApplication2\InsideSub-folder as an exclusion. In the screenshot below, you can see that the parent folder %APPDATA%\MyApplication2 was captured but InsideSub-folder was not:

To perform some specific testing at execution time, I’ve then set this folder to Merge with Local Directory. Let’s see what happens on the client:

On the real file system I’ve created the folder %APPDATA%\MyApplication2. The screenshot below shows a directory listing outside of the bubble:

If I see the same %APPDATA% location within the package I should see the merged view of %APPDATA%\MyApplication2:

If I create a sub-folder of the MyApplication2 folder:

I can see that the sub-folder has fallen through the virtual environment to the real file system:

I can also create a file or folder outside of those paths that were captured during sequencing and any path marked Override Local Directory and they will be created in the real file system. In this package %APPDATA% was not captured during sequencing, so I can create a sub-folder (or file):

That is written to the real file system:

Bottom line: Exclusions ensure specified file data isn’t captured at sequencing time and Merge with Local means that anything that doesn’t already exist in the package will be written to the real file system. So file system virtualization is straight-forward and for the most part works the way we would expect.

How the Virtual Registry interacts with the Real Registry

The virtual Registry is quite different to the virtual file system – writes to the Registry at execution time will always end up in the virtual Registry. In my example package I have several Registry keys: HKCU\Software\MergeTest1 and HKCU\Software\MergeTest2, while HKCU\Software\MergeTest3 was excluded. The key HKCU\Software\MergeTest2 has been configured for Merge with the Local Key.

On the client in the real Registry I’ve created HKCU\Software\MergeTest2 with a value (OutsideTheBubble) inside it:

Within the virtual Registry I can create other keys at the same levels MergeTest1 and MergeTest2 (MergeTest3) and I can make an edit to a value that exists outside of the virtual Registry.

All of these changes have been captured inside the virtual Registry. This means that while I get a merged view of the virtual and real Registry’s, any changes made by the virtual application will only persist inside the virtual registry. Here’s a look again at the real Registry after I’ve closed the virtual application:

When you take a closer look at a package, you’ll start to see why this is the case. In this screenshot you can see that the Registry root (REGISTRY) is set to Merge with Local Key.

Bottom line: Exclusions ensure specified Registry data isn’t captured at sequencing time and Merge with Local, means just that: merge with any existing local keys; however any new writes to the Registry will be captured in the virtual Registry (a copy on write action).

In the majority of scenarios the behaviour of the virtual Registry is exactly the way we need it to be; however what happens if you absolutely, positively need a Registry write to make it into the real Registry? (i.e. how do you force an exclude at runtime?)

Why write to the Real Registry?

I’ll draw on my earlier examples to explain why I would want a Registry write to make into the real Registry.

MAPI profiles (HKCU\Software\Microsoft\Windows NT\CurrentVersion\Windows Messaging Subsystem): your user environment management approach may necessitate managing MAPI profiles outside of the virtual environment. See the Prescriptive guidance for sequencing Office 2010 in Microsoft App-V for different approaches to this key depending whether you are deploying to App-V 4.5 or 4.6.

ODBC connections (HKCU\Software\ODBC): virtualising ODBC connections can be useful; however if they connection can be edited in-application, then the changes would be saved to the user’s PKG file. If you are deploying ODBC connections with a tool such as Group Policy Preferences, you can’t deploy those changes inside a package, because GPP only applies before the application launches.

Printers (HKCU\Printers): the user could change their default printer inside an application via the print dialog – the application will have one default printer, while the system will see another default printer. This could be a good or bad consequence depending on how savvy your users are.

These are just a few examples and I’m sure there are plenty more.

How to write to the Real Registry

The App-V client includes a Registry key at HKLM\SOFTWARE\Wow6432Node\Microsoft\SoftGrid\4.5\SystemGuard\Overrides with a couple of interesting values – VirtualRegistryPassthrough and VirtualRegistryPassthroughEx.

VirtualRegistryPassthrough is used to allow a local process pass up into the virtual Registry. You can read more about this value in this knowledgebase article: How to print to an Adobe PDF writer printer from SoftGrid-enabled applications. Any detailed documentation beyond this article does not appear to be publically available.

The second value of interest VirtualRegistryPassthroughEx, can be used in the opposite way. It can be used to ensure a specific key will always pass through to the real Registry. A web search draws a complete blank on this one, so until Microsoft comes out with better documentation on TechNet, I recommend testing this value carefully.

There are a couple of caveats with this approach:

1. You must ensure that the key or keys that you want to pass through to the real Registry do not exist inside your App-V package but they should be created in the real Registry. In fact, the key must be initially created outside of the package – you won’t be able to create the key at execution time inside the virtual Registry.

2. This is a global setting; it can’t be used on a per-package basis.

VirtualRegistryPassthroughEx is a multi-string value (REG_MULTI_SZ) to which you add Registry keys to, one for each line. The default keys included here are:

• HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\WINEVT
• HKEY_LOCAL_MACHINE\System\CurrentControlSet\services\eventlog\Application
• HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\WMI\Autologger
• HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Internet Settings
• HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Perflib

Add the key or keys that you want to exclude from the bubble. No restart is required for this to take effect.

In my example I’ve added HKEY_CURRENT_USER\Software\MergeTest3. I can now create values and sub-keys and be certain that they will end up in the real Registry.

Where to from here?

The lack of available documentation on this setting deter you from using it; however based on my findings I’m reasonably confident in the way this works. I do recommend performing your own in-depth testing before using this to address challenges you may have with the virtual Registry.

In a related post I should have ready in a couple of weeks, I’ll post my list of recommended file system and Registry exclusions to add to your App-V projects before sequencing.

Just how do Exclusions in App-V packages work? is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

With my post on virtualising the App-V Management Console last week, this list has hit 200 links.

In this list you’ll find completed recipes plus numerous other resources such as forum threads and knowledgebase articles that solve problems people have faced when virtualising their applications.

We’ll continue to add links as we find them, so if you’d like to keep up to date, you can subscribe to the App-V Recipes and Tips feed or you can view the complete list in my App-V Recipe Delicious Bookmarks.

Enjoy.

200 App-V Recipes, Tips and Tricks to keep you busy is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Prerequisites

The Application Virtualization Management Console requires the Microsoft Management Console (MMC) 3.0 or later and the .NET Framework 2.0 SP2. MMC 3.0 comes with all of the current Windows releases and the .NET Framework comes with Windows Vista and above, so you should only need to install the .NET Framework if you are targeting Windows XP or Windows Server 2003. MMC is an operating system component, so you won’t be able to sequence it.

Preparing the Sequencer

I have used the 4.6 Sequencer and Windows 7 x86 for this sequence, so the prerequisites are already installed; however I have run the MMC at least once to ensure any Registry and AppData locations have been written prior to sequencing.

Important: Stick with the x86 version of Windows because when sequencing on 64-bit Windows the snap-in does not appear to register during sequencing and this error is received when starting SftMMC.msc:

I have successfully sequenced on 32-bit Windows 7 and run the package on 64-bit Windows.

Exclusion Items

I found that I need to add Q:\System Volume Information to the list of exclusion items, as this was captured during monitoring.

Configuring the Console Install

I am using the setup source for the Management Server (not the Streaming Server) and I have chosen to install only the Management Console (we don’t want to capture the Management Server or web service). I am installing into a folder on the Q: drive; however this isn’t a requirement – you can install to the default Program Files location if you like.

Setup requests a reboot when finished, but the Sequencer will handle the reboot automatically.

To ensure that my sequence can be replicated quickly and easily, I have used the following command line to perform a silent installation of the console during the monitoring phase:

MSIEXEC /I setup.msi ADDLOCAL=Release_SoftGrid_Management_Console INSTALLDIR=Q:\APPVMMC.001\Console REBOOT=SUPPRESS OPTIN=FALSE /QB-

The complete list of command line options for the Console installer can be found in this knowledgebase article: Supported command line options for the Microsoft App-V 4.5 Management Server installer.

Sequencing the Console

Follow the recommendations outlined in the Microsoft Application Virtualization 4.6 Sequencing Guide.

Monitoring phase – install the Console during the Sequencing phase. Open MMC and check that the App Virt Management Console snap-in is available or start the Application Virtualization Management Console shortcut. There is no need to connect to a Management Server during sequencing.

Configure Applications phase – the default shortcut will point directly to the SftMMC.MSC file. In my case this was “Q:\APPVMMC.001\Console\App Virt Management Console\SftMMC.msc”. Change the Application Path to read “C:\Windows\System32\MMC.EXE” “Q:\APPVMMC.001\Console\App Virt Management Console\SftMMC.msc” instead (change the install path to suit your own environment). Change the Version and OSD File Name default text to suit your standards.

Once the package is saved, the CODEBASE line in the OSD file will include FILENAME and PARAMETERS elements that will look something like this:

PARAMETERS=""%SFT_MNT%\appvmmc.001\Console\App Virt Management Console\SftMMC.msc"" FILENAME="%CSIDL_SYSTEM%\MMC.EXE"

Launch Applications phase – you can build Feature Block 1 if you require it, but the final package size is very small.

Saving the Package

There are no additional changes that need to be made to the package. I saved my package with the following properties:

• Operating Systems Selected: none
• Enforce Security Descriptors: enabled
• Generate Microsoft Windows Installer Package: enabled
• Compress Package: enabled

Running the Package

The default requested execution level for the Microsoft Management Console is RunAsHighest. This means that if you are running MMC as an account that is in the local Administrators group, UAC will prompt for elevation. This is a problem when running under App-V because the App-V client components do not request a higher token.

When you start the virtualised Management Console the following error will be produced:

You can get around this issue three ways:

1. Run as a standard user only (the console allows you to connect to a remote system with alternate credentials)
2. Right-clicking the shortcut and choosing Run as administrator; or
3. Force the package to run with the user’s current execution level using the __COMPAT_LAYER environment variable.

Option 3 is probably the simplest method. To prevent MMC from requesting higher privileges, add the following lines to the OSD file inside the VIRTUALENV tag:

<ENVLIST>

<ENVIRONMENT VARIABLE="__COMPAT_LAYER">RunAsInvoker</ENVIRONMENT>

</ENVLIST>

However this works great for 32-bit Windows only, using this method on a 64-bit platform results in these errors:

Then:

I haven’t found a root cause, but the issue looks to be related to the App-V client. When using the RunAsInvoker trick outside of the client, MMC works as expected.

If you are deploying the package to 64-bit Windows, the Run as administrator option will be required to launch the console.

Resources

• Elevation and Run-As Considerations in Microsoft App-V Environments

Sequencing the App-V Management Console is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Provider Policies are ‘rules’ that apply when users launch virtual applications from a Microsoft App-V Management Server using RTSP(s). Other App-V infrastructure scenarios or the use of the HTTP(s) protocol don’t support the use of Provider Policies.

The ‘rules’ allow App-V administrators to control the following settings:

• Server access – The Active Directory group that can connect to the server through the Provider Policy.
• Authentication – If authentication is required to connect to the server or the use of applications.
• Logging – Record application usage data in the App-V data store.
• Licensing – Whether or not to audit or enforce application licenses.
• Client refresh behaviour – At which interval and events the client checks with the server for application changes. For example new applications and shortcuts, removed or disabled applications. At a refresh, the client will also communicate the application usage logging with the server if configured.

Why would I use them?

Besides the Provider Policy created by the installation process of the App-V Management Server, called the Default Provider, you would basically need multiple Provider Policies if you require maintaining different configurations of the settings mentioned in the previous paragraph. For example different Provider Policies are required for auditing AND enforcing licensing: If you have one or more applications where you want to enforce licensing and monitor license usage for some other applications you will need two different Provider Policies. Another example would be a separate Provider Policy which doesn’t require authentication for specific applications for contractors.

How do I use them?

Only the App-V Management Server offers the use of Provider Policies which itself requires Active Directory and Microsoft SQL to hold the App-V data store.

When installing the App-V Management Server one Provider Policy is created by default, called Default Provider. This Provider Policy is tied to the default created server group which is named Default Server Group, if no other name was specified during the App-V Management Server setup.

To create a new Provider Policy right click the Provider Policies node in the App-V Management Console and choose: New Provider Policy. The Properties screen allows for naming the new Provider Policy and the configuration of the client refresh behaviour. The minimum interval for a scheduled refresh is 30 minutes.

In the Group Assignment screen select the Active Directory groups that have access to the App-V server through this Provider Policy. A minimum of one group is required. The user has to be a member of this group when the Authentication checkbox is set on the Provider Pipeline screen.

The Provider Pipeline screen allows the following options to be set:

Authentication: This checkbox forces authentication in the session. If the App-V client can’t use the current user’s credentials, a login box is shown to the user to provide them. Disabling this checkbox allows any user to launch applications from the App-V server through this Provider Policy. The Authentication dropdown box only has one option: Windows Authentication.

With the Enforce Access Permission Settings checkbox enabled the user can only launch an application if he is a member of an Active Directory group specified on the Access Permissions tab under the Properties of an Application.

Log Usage Information: With this checkbox selected, application usage data is stored in the App-V data store. This allows administrators to generate a basic report from the Management Console or extract this information by other means.

Licensing: When enabled this setting allows for monitoring (auditing) or enforcing application licenses. Auditing still allows the use of applications even when the license count would exceed. Licenses are created in the Application Licenses node of the Management Console and an application is assigned to a license.

After creating the Provider Policy, the Provider Pipeline tab under Properties shows an Advanced button. Under this button the corresponding modules (.dll files) to the checkboxes are shown.

There are two ways to control which Provider Policy applies in a session between the client and the server:

1. The default Provider Policy configured for the Server Group: On the General tab of the Server Group properties specify the default Provider Policy to use:

In this case the Provider Policy applies when users connect to a server from this Server Group.

2. With the Policy specified in the Application’s OSD file: In the CODEBASE tag add the Provider Policy to the HREF value by appending .SFT file name with the following text: ?Customer=ProviderPolicyName. For example:

HREF="RTSPS://%SFT_SOFTGRIDSERVER%:322/WINZIP.001/WINZIP.001.sft?Customer=MyProviderPolicy"

Any Provider Policy specifically assigned in an OSD file will overrule the Provider Policy configured at on the Server Group.

Additional Resources

• How to Customize an Application Virtualization System in the Server Management Console
• For more information on App-V infrastructure scenarios take a look at the App-V FAQ #20
• The Ultimate Guide to Application Licensing and Provider Policies for Application Virtualization 4.5

For more information on streaming, publishing and client configuration when using HTTP take a look at these links:

• A guide to App-V publishing and streaming using IIS
• HTTP Publishing in App-V (Part 1)
• Support for Client Reporting over HTTP

App-V FAQ: What are Providers Policies? is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

The .NET Framework and Visual C++ Redistributables are components or application dependencies that have started to be considered as operating system components and the question of whether to include the .NET Framework and/or the Visual C++ Redistributables has been revisited quite a few times by Microsoft.

Since the release of App-V 4.5 it has been recommended that all versions of the .NET Framework are installed natively, however since the release of App-V 4.5 Cumulative Update 1 this was subsequently revised for Windows XP and this allowed versions earlier than the .NET Framework 3.5 Service Pack 1 to be part the package.

As a good practice any sequencing machine should be setup in a similar way as the client and therefore its key to synchronize the levels of the .NET Framework and Visual C++ Redistributables on both the sequencer and client computers. Visual C++ Redistributable are prerequisites for both the client and the Sequencer, however the current level is different depending on which version you are installing.

Microsoft have not explicitly stated that it is not possible to include the Visual C++ Redistributables within a virtualized application; however an older Knowledgebase article (939084) states that they should be available locally on a client computer.

As illustrated on the official .NET Framework support statement, the .NET Frameworks are included in all newer operating systems (Windows 7 includes .NET Framework 3.5 Service Pack 1 and below). Windows XP Service Pack 2 (and thereby we can also presume Windows Server 2003) is the only platform that would successfully execute a virtualized package containing .NET Framework while not having it available natively. The Application Virtualization 4.5 Cumulative Update 1 client would allow this due to a new mini-filter driver introduced in the update.

Regardless of whether it is possible to virtualize certain versions of .NET Framework on older platforms – it seems to be an more scalable and future-proof strategy to ensure that .NET Framework and Visual C++ Redistributables are available on any target machines for any virtualized application to use.

Normally the following can be recommended to be setup both on the sequencer and the client; (32-bit versions only linked below. 64-bit versions in case of availability are recommended also in case of having a 64-bit target environment)

Visual C++ 2005 SP1

• http://www.microsoft.com/downloads/en/details.aspx?familyid=200b2fd9-ae1a-4a14-984d-389c36f85647&displaylang=en
• http://www.microsoft.com/downloads/en/details.aspx?familyid=766a6af7-ec73-40ff-b072-9112bab119c2&displaylang=en

Visual C++ 2008 SP1

• http://www.microsoft.com/downloads/en/details.aspx?familyid=2051a0c1-c9b5-4b0a-a8f5-770a549fd78c&displaylang=en
• http://www.microsoft.com/downloads/en/details.aspx?FamilyID=a5c84275-3b97-4ab7-a40d-3802b2af5fc2&displaylang=en

Visual C++ 2010

• http://www.microsoft.com/downloads/en/details.aspx?familyid=A7B7A05E-6DE6-4D3A-A423-37BF0912DB84&displaylang=en

.NET Framework 1.1 / 2.0 / 3.0 / 3.5 / 4.0

• http://www.microsoft.com/downloads/en/details.aspx?FamilyID=0a391abd-25c1-4fc0-919f-b21f31ab88b7&displaylang=en
• http://www.microsoft.com/downloads/en/details.aspx?FamilyID=ab99342f-5d1a-413d-8319-81da479ab0d7&displaylang=en
• http://support.microsoft.com/kb/959209
• http://www.microsoft.com/downloads/en/details.aspx?FamilyId=262D25E3-F589-4842-8157-034D1E7CF3A3&displaylang=en

The Application Virtualization Client requires Visual C++ 2005 SP1 along with the ATL security update and the Visual C++ 2008 SP1 along with its ATL security update; however the Sequencer only installs Visual C++ 2005 SP1 along with its ATL security update.  This of course requires the manual tasks of assuring that both are aligned on the same level in prerequisites.

Reading section 3.2 from the 4.6 sequencing whitepaper gives some specific examples how to resolve possible SxS issues when sequencing on a 64-bit sequencer – something which can be avoided if being prepared and already natively offering both 32-bit and 64-bit redistributables on both sequencer and client machine.

Not documented anywhere and purely untested, normally these following redistributables can also be recommended in maintaining natively;

Visual J#

• http://www.microsoft.com/downloads/en/details.aspx?FamilyID=E3CF70A9-84CA-4FEA-9E7D-7D674D2C7CA1
• http://www.microsoft.com/downloads/en/details.aspx?familyid=f72c74b3-ed0e-4af8-ae63-2f0e42501be1&displaylang=en

Visual Studio 2010 F# Runtime 2.0

• http://www.microsoft.com/downloads/en/details.aspx?FamilyID=5f0a79f8-925f-4297-9ae2-86e2fdcff33c&displaylang=en

Further reading and resources

• Application Virtualization 4.5 Release Notes
• Guide to sequencing .NET 4.0 with App-V 4.6 SP1
• Support for .NET in Microsoft Application Virtualization (4.5) and 4.5 Cumulative Update 1
• Support for .NET in Microsoft Application Virtualization 4.5 (App-V)
• Error message when you try to start a sequenced application in the Microsoft App-V (SoftGrid) client: “Error code: xxxxxx-xxxxxx2C-800736B1″
• Microsoft Application Virtualization 4.6 Sequencing Guide
• Visual C++ Libraries as Shared Side-by-Side Assemblies
• Howto: Deploy VC2008 apps without installing vcredist_x86.exe

App-V FAQ: Can I virtualize the .NET Framework or Visual C++ Redistributables? is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

Don’t Virtualize Reader

Before I get to the details I would like you to first consider the implications of virtualising Reader. Adobe Reader is often a common component of any desktop deployment and like Microsoft Office and Internet Explorer, it usually becomes a core application on which other applications depend.

If you are using a virtualisation solution that isolates an application from other applications and the operating system, integration can be a challenge. Let me illustrate with a couple of examples:

Internet Explorer: if Reader is isolated from Windows, Internet Explorer will be able to download PDFs which can then be opened with the virtualised Reader; however IE will have no knowledge of any application that is handling the PDF file type or MIME type. Launching Reader inside IE or viewing a PDF embedded in a web page will not be possible.

You could solve this my launching Internet Explorer inside the Reader package, but this will require covering all of the ways a user can launch Internet Explorer. If you do that, what happens when you want IE to launch inside the environment of another package? App-V doesn’t handle integration with these entry points elegantly today.

Virtualised applications: Additionally, if you need to provide other virtualised applications with Reader support, you will need to maintain Dynamic Suite Composition links to the Reader package for each primary package that requires it. Because Reader is used so often, managing DSC links is something that could get out of hand very quickly.

In most cases I do not recommend virtualizing Reader – your mileage may vary, but because of the additional administrative overhead and the change in the user experience, you should invest your time in other areas.

Configuring the Adobe Reader installation

If I haven’t convinced you that virtualizing Reader is more trouble that it’s worth, then here’s how to do it:

I’ve previously covered how to create a customised deployment of Reader X to suit your environment. If you have read that article yet, I recommend that you do before proceeding further. Automating the installation and configuration of Reader during sequencing will make it easier to re-create the package and will simplify documentation.

Here’s my recommendations for settings that you should configure when creating a transform to install Reader during sequencing:

• Personalisation Options: change the install path if required. You can choose to install to the virtual drive; however a VFS install will work as well
• Installation Options: disable the caching of the Reader installer files to reduce the size of the package. Choose an unattended install and supress reboot
• Files and Folders: add the JavaScript (HideItems.js) to disable additional toolbar buttons and menu items
• Registry: add the bProtectedMode value to the Policies key to disable Protected Mode (more on that below)
• Shortcuts: disable the shortcut added to the Desktop
• Server Locations: additional server locations should not be required when virtualising Reader
• EULA: ensure that the End User License Agreement is suppressed
• Online and Acrobat.com Features: disabling the Adobe Updater is important so that user’s can’t attempt to update Reader after deployment
• Direct Editor: you can edit the Transform directly to prevent the installation of Adobe Updater (although you can just delete the ARM folder during sequencing).

Reader X 10.1 introduces a new Adobe Acrobat Updater Service, you can use the Direct Editor to prevent the service from being installed, because it won’t be required once virtualized.

Create a script to perform the installation. Here’s a sample script that will install Reader, perform some additional actions that can be done in the transform file instead and will then launch Reader after setup has completed.

@ECHO OFF
START /WAIT MSIEXEC /I AcroRead.MSI TRANSFORMS=VirtualisedReaderX.MSI ALLUSERS=TRUE /QB-
IF "%PROCESSOR_ARCHITECTURE%"=="AMD64" RD /Q /S "%CommonProgramFiles(x86)%\Adobe\ARM"
IF "%PROCESSOR_ARCHITECTURE%"=="x86" RD /Q /S "%CommonProgramFiles%\Adobe\ARM"
REG ADD "HKLM\SOFTWARE\Policies\Adobe\Acrobat Reader\10.0\FeatureLockDown" /v bProtectedMode /d 0 /f
REG ADD "HKLM\SOFTWARE\Policies\Adobe\Acrobat Reader\10.0\FeatureLockDown" /v bUpdater /d 0 /f
IF EXIST "%PUBLIC%\Desktop\Adobe Reader X.lnk" DEL /F "%PUBLIC%\Desktop\Adobe Reader X.lnk"
IF "%PROCESSOR_ARCHITECTURE%"=="AMD64" START /D "%ProgramFiles(x86)%\Adobe\Reader 10.0\Reader" AcroRd32.exe
IF "%PROCESSOR_ARCHITECTURE%"=="x86" START /D "%ProgramFiles%\Adobe\Reader 10.0\Reader" AcroRd32.exe

Copy the Reader setup files, the Windows Installer transform and the script into your sequencing machine before capturing. I generally use a folder named C:\Packages and add this location to the excludes for the package.

Virtualizing Adobe Reader

There are no additional requirements or dependencies for virtualizing Reader X and I have successfully created an App-V package on Windows 7 x86 and deployed to both x86 and x64 platforms using the custom installation and script outlined above.

I have provided here a copy of the App-V 4.6 SP1 Package Template which includes a number of exclusions that do not need to be captured in a Reader package.

Adobe Reader X App-V Package Template

There is one issue though – the Adobe Reader Protected Mode doesn’t like running under App-V. During the monitoring phase the application may not launch on first run and on the second launch the following dialog box will be displayed:

Choosing the option ‘Always open with Protected Mode disabled’ will save the setting in HKCU in the Registry, but until a fix is found (either by Adobe or Microsoft) you can disable Protected Mode using the following Registry key:

• Key: HKLM\SOFTWARE\Policies\Adobe\Acrobat Reader\10.0\FeatureLockDown
• Value: bProtectedMode
• Type: REG_DWORD
• Data: 0

The script listed above includes a REG command to disable Protected Mode, however this can be done in the transform file instead.

If Protected Mode is not disabled when Reader is virtualized or when it is running inside an App-V bubble via another package, it will crash with the following error: Error in Microsoft Visual C++ Runtime Library. Disable Protected Mode to avoid this issue.

Conclusion

Virtualizing Reader is straightforward and it performs well under App-V, although I would consider the implications of isolating Reader from the OS, even before you start the Sequencer. A virtualized Reader will require managing DSC links and you’ll need ensure that users understand the difference in behaviour with IE integration.

Hopefully an update of either Reader or App-V in the future will enable Protected Mode support to improve security.

Resources

To make the job of sequencing Reader X easier, the following App-V 4.6 SP1 Package Accelerators are available.

• App-V 4.6 SP1 Package Accelerator for Adobe Reader X 10.1
• App-V 4.6 SP1 Package Accelerator for Adobe Reader X 10.0

Virtualizing Adobe Reader X is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

RemoteApp

Creating the connection on the client computer is easy – setup a new connection via RemoteApp and Desktop Connections in Control Panel or ask users to double click on a connection file that you’ve created on the RD Connection Broker.

The wizard is simple enough, just click the Next and Finish buttons when prompted, the wizard will do the rest:

But what if you want to deliver the connection silently? Fortunately that’s easy, but it’s one of those things that just isn’t documented. Here’s how to do it.

Creating the RemoteApp and Desktop Connections Configuration File

There are some excellent resources for setting up RemoteApp sources, Remote Desktop Web Access and publishing applications, so there’s no need to cover those again. If you haven’t already configured the Remote Desktop Session Host servers, Remote Desktop Virtualization Host servers (for publishing virtual desktops) and the Remote Desktop Connection Broker see these step-by-step guides first:

• Deploying Remote Desktop Web Access with Remote Desktop Connection Broker Step-by-Step Guide
• Deploying Personal Virtual Desktops by Using Remote Desktop Web Access Step-by-Step Guide
• Deploying Virtual Desktop Pools by Using Remote Desktop Web Access Step-by-Step Guide
• Deploying RemoteApp Programs to the Start Menu by Using RemoteApp and Desktop Connection Step-by-Step Guide

Now that you’ve configured your RemoteApp and Desktop sources and RD Web Access and confirmed that you can manually add a RemoteApp and Desktop Connection source to your client machine, you’ll need to create the RemoteApp and Desktop Connections Configuration File.

Open the Remote Desktop Connection Manager tool on the Remote Desktop Connection Broker and choose Create Configuration File. Enter the URL to the RAD Connection feed, in my case this is https://home.stealthpuppy.com/RDWeb/Feed/webfeed.aspx

Click the Save button and save the configuration file to a location that you can also access from the client machine. The configuration file is just simple XML, so open it in Notepad to view the contents.

Adding the RemoteApp and Desktop Connection

Adding the connection is simple, but you will need to do this in the users’ context, so you’ll have to use a logon script or similar to run the command. The machine on which the command is run must also be connected to the network (it will fail silently if a connection can’t be made) and be able to make a connection to the Remote Desktop Connection Broker. To add the workspace silently run this command:

rundll32.exe tsworkspace,WorkspaceSilentSetup <path>\connection-file.wcx

That’s it. If the connection already exists and the command is run again, it will fail silently.

Advanced Configuration

A PowerShell script is available from Microsoft that can check whether the connection already exists before running the setup command and will log an event if the setup fails. The script can be found here: Configure RemoteApp and Desktop Connection on Windows 7 Clients

More Reading

• Windows 7 / Windows Server 2008 R2: RemoteApp and Desktop Connection

How to silently deploy RemoteApp Programs to the Start Menu is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.

The client log settings are managed in the Application Virtualization Client console (SFTCMC.MSC) – start the console and the logging settings can be viewed on the General tab:

There are actually two places to which the the client will log errors – the Application event log (shown in the image under System Log Level) and the client log file; however the log file is generally the easiest to use when troubleshooting because it’s a flat text file.

Using the client log file

The default location for the log file is %ProgramData%\Microsoft\Application Virtualization Client\sftlog.txt. To view the log you can use something as simple as Notepad, but if you want to view it in real time, use SMS Trace (Trace32) from the ConfigMgr 2007 Toolkit.

To get more information out of the client, enable verbose mode, which will enable you to better identify the cause.

1. Open the client console and view the client properties
2. Set the Log Level to Verbose
3. Click the Reset Log button to start with a clean log file

Resetting the log will rename the existing file and start a new one:

Note: once you have finished troubleshooting, don’t forget to set the logging level back to Information.

Here’s an example

In my test environment, I have a client machine (WIN71) and an App-V Management Server (APPV). I’ve imported a virtualised copy of Adobe Reader and assigned it to a set of users. On the client I have configured APPV as a publishing server; however when refreshing the client no shortcuts for Reader are created.

Viewing the App-V client log, I’ve narrowed down the following lines that show what’s going on during the refresh:

[09/23/2010 22:03:50:885 SWAP WRN] {tid=B60:usr=aaron}
Could not load OSD file \\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd

[09/23/2010 22:03:50:900 AMGR INF] {tid=B60:usr=aaron}
The app manager could not create an application from '\\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd' (rc 0C405564-00000002).

If I set the log to verbose and try the refresh action again, I get more detail:

[09/23/2010 22:45:28:684 AMGR VRB] {tid=B14:usr=woody}CreateApp(osd=\\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd, icon=\\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9_x86 Icons\AdobeReader9.ico)

[09/23/2010 22:45:28:685 AMGR VRB] {tid=B14:usr=woody}
Parsing type from url \\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd

[09/23/2010 22:45:28:686 SWAP VRB] {tid=B14:usr=woody}
Initialize(osd=\\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd, origUrl=NULL)

[09/23/2010 22:45:28:687 OMGR VRB] {tid=B14:usr=woody}
GetOsdFile(url=\\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd, origUrl=NULL name=NULL, ver=NULL)

[09/23/2010 22:45:28:688 OSDF VRB] {tid=B14:usr=woody}
SWOsdFile(url=\\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd, origUrl=NULL, name=NULL, ver=NULL)

[09/23/2010 22:45:28:710 OSDF VRB] {tid=B14:usr=woody}
~SWOsdFile()

[09/23/2010 22:45:28:712 OSDF VRB] {tid=B14:usr=woody}
~SWOsdFile() complete

[09/23/2010 22:45:28:726 SWAP WRN] {tid=B14:usr=woody}
Could not load OSD file \\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd

[09/23/2010 22:45:28:727 AMGR INF] {tid=B14:usr=woody}
The app manager could not create an application from '\\domain.local\Public\Apps\AdobeReader9_x86\AdobeReader9.osd' (rc 0C405564-00000002).

If check the actual location of the OSD file, I can see that the package is not in the correct path (its actually located at \\domain.local\Public\Apps\Adobe\AdobeReader9_x86):

To fix this issue, I need to update the application properties in the App-V Management console, I can then refresh the client again and the application will be published correctly.

Error Codes

This was a very simple example and the fix was quite obvious. In all cases though, the client log will include an error code – the same code will often be displayed in a dialog box:

If the problem is not immediately apparent in the log, start looking for a solution by using the error code. Falko Gräfe has an excellent article that explains how to interpret these error codes. In most cases, there will be an associated Microsoft knowledgebase article that should give a solution for the error.

Resources

• Log File for the Application Virtualization Client
• How to Configure the Client Log File
• Troubleshooting App-V with log files
• How to use the Process Monitor tool to generate a log file for an application in the App-V virtual environment
• System Center Configuration Manager 2007 Toolkit V2
• Application Virtualization Client Log Parser Utility (and how to use it)
• App-V Application Publishing and Client Interaction
• App-V Client Error Codes
• App-V Error Codes search on Microsoft Support

App-V FAQ: My virtual application won’t start. Where do I start troubleshooting? is post from stealthpuppy.com. Except as noted otherwise, this work is © 2005-2012 Aaron Parker and is licensed under a Creative Commons Attribution-Noncommercial-Share Alike 3.0 Unported License.