How to dynamically suite two packages using App-V 4.5 and DSC

Article
09/24/2008

<Updated 08/03/2009>

If you're familiar with all the cool new features we've put into Microsoft Application Virtualization 4.5 then you're probably already aware of Dynamic Suite Composition (DSC) and how it can really streamline your virtualization projects. Whether you consider yourself a DSC expert or not, check out John Behneman's overview and example below. He does a great job of explaining what it is, why it's so cool and how to use it:

========

Description

Dynamic Suite Composition (DSC) provides a method for administrators to control which virtual applications will be combined to create a unified, virtual working environment for a single application set. To do this, DSC provides a way for the admin to specify mandatory or optional dependencies between separate virtual applications that allows each app to run within the same virtual space, or "bubble" as we call it. When this is used, when the primary virtual application is run on the client it will also launch the dependent virtual application within the same bubble, allowing the combination to run together in the same virtual environment.

DSC enables a "one-to-many" scenario for middleware applications. An example of this would be applications that require the Java Runtime Environment (JRE). The first step would be to sequence the JRE into its own virtual application, then in a separate process sequence the dependent application on a sequencer machine with the JRE locally installed. A dependency could then be created between the single virtual JRE package and the other virtual dependent application package allowing them to run together in the same bubble on the client. The big benefit here is that once the JRE is virtualized it can be used with any other app that also needed the JRE. This "one-to-many" scenario allows multiple virtual applications to share the same virtual JRE package. DSC reduces the sequencing overhead as only one JRE needs to be sequenced instead of re-sequencing the JRE into each individual package. Updates are also simplified as the single JRE package would be updated instead of multiple packages.

Dynamic Suiting Architecture

Dynamic Suiting provides a solution for enabling virtual environment sharing between sequenced packages. It is a "light" solution because it shares the environment rather than having controlled interaction between virtual environments. When an application is sequenced, the SystemGuard collects the proper registry and file system information for that app and saves it in OSGuard.cp. When the client runs the virtual application, it restores the virtualized user and OS specific registry values to run in its virtual OS. This allows the application to run without affecting the Operating System. This is the basic SoftGrid concept. Any user specific changes to the registry in the client machine are saved locally in the client machine in the Settings.cp. This keeps track all of registry changes made in the client that differ from the original setting recorded during sequencing.

In contrast, Dynamic Suiting will maintain the OSGuard.cp for each application which will keep all application specific settings but it will share the Settings.cp between the primary and secondary packages. The primary package Settings.cp is shared with the secondary packages, meaning that state separation for the secondary packages is not preserved. If you have a plug-in that can run standalone from the main application, it will not save a Settings.cp, so any client settings will not be restored when the application is used on its own.

DSC Example

Below are the basic steps necessary to create 2 packages that can interact via DSC. This example is based on Office 2007 and an Office 2007 Live Add-in:

1. To configure DSC between two components, sequence each one separately. First, create a sequence of the primary application, which in this case would be Office 2007, on clean sequencer workstation.

2. Next, save the package and then revert the sequencer back to a clean state.

3. Install and configure Office 2007 locally.

4. Next, install and open the Sequencer and then install the Office Live Add-in to create the package.

5. The next step is to modify the OSD’s to define the dependencies.

a. Open the OSD file for the Office Live Add-in and copy the CODEBASE tag.

b. Open the OSD for one of the Office 2007 applications.

c. After the </POLICIES> tag, insert the following tag: <DEPENDENCIES>.

Note: If your OSD does not have a <POLICIES> tag, insert the <DEPENDENCIES> tag above the line that says </VIRTUALENV> (see https://download.microsoft.com/download/f/7/8/f784a197-73be-48ff-83da-4102c05a6d44/App-45_Sequencing_Guide_Final.docx page 24, section 9, number 4).

d. Paste the CODEBASE tag that was copied from the Office Live Add-in OSD.

e. Remove the PARAMETERS and SIZE elements. If the Add-in will be required to use the primary application, add MANDATORY="TRUE" to the end of the CODEBASE tag.

f. Close the DEPENDENCIES tag by adding </DEPENDENCIES>.

6.Deploy both packages following the normal procedures for publishing applications. If the secondary package will not be available to all users, use AD groups to limit the users who have access to the add-in, which can be independent of which users have access to the primary application, Office 2007 in this example.

Dynamic Suiting "Plug-In Applications"

Another example of Dynamic Suiting involves the use of applications that involve plug-ins. In this particular example, we have an Excel Plug-in that needs to work with a virtualized copy of Excel. Now suppose you have multiple plug-ins for Excel that not every user needs access to or different plug-ins for different groups of employees. With DSC you can leverage the same Excel virtual application with multiple plug-ins that are sequenced separately. This is also helps if one plug-in of the group requires an update. The one plug-in can be updated without having to open for upgrade the entire Office Suite.

For this scenario, follow these steps to dynamically suite a primary application and a plug-in.

Phase 1 - Sequence the primary application

Start with a clean sequencing workstation
Install the Sequencer
Sequence the primary application using the Best Practices Guidelines
Save the sequence
Import the application into your Application Virtualization Server environment and grant the appropriate permissions to the user groups that will need access.

Phase 2 - Sequence the Plug-in

Start with a clean sequencing workstation
Install the MS Office Excel application locally
Install the Sequencer
Sequence the Excel plug-in
Save the sequence
Import the application into your Application Virtualization Server environment and grant the appropriate permissions to the user groups that will need access. For a dependent application like this there is no need to publish a shortcut for this application as it will not be launched by itself.

Phase 3 - Define the dependency

Open the Excel plug-in OSD as a text file
Open the primary application's (Excel) OSD as a text file
Inside the primary OSD add both a <DEPENDENCIES> and a </DEPENDENCIES> tags. These need to reside between the <VIRTUALENV> tags
Copy the <CODEBASE> tag from the plug-in’s OSD.
Paste this in between the <DEPENDENCIES> tags.
From the <CODEBASE> tag you can remove all elements except: HREF, GUID, and SYSGAURD and their accompanying values.
Optionally you can add another element to the <CODEBASE> tag, it is MANDATORY with a value of TRUE (FALSE if not specified). If MANDATORY=TRUE then the dependent application is required in order to run the primary app. If not available then the primary app will not launch. It would be used to make sure the JRE or other required middleware was available in order to run the app. It is also used to allow configuring a single OSD for various combos of plug-ins. If you set MANDATORY=FALSE (or omit this tag entirely) then permissions decide which plug-ins should be loaded for a particular user.

Here's an example of a primary application's OSD (in this case Excel) that has a dependency declared for a plug-in package:

Dynamic Suiting Composition DSC References

=======

Thanks John!

J.C. Hornbeck | Manageability Knowledge Engineer

How to dynamically suite two packages using App-V 4.5 and DSC

Additional resources