Querying .APPV Package Properties Part 2

powershell_appv_logoFollowing on from Part 1, we can also query the properties of an App-V 5.0 .APPV package with another cmdlet included in the Virtual Engine App-V 5.0 .APPV PowerShell CmdLets; Get-AppV5FilePackage.  The main difference with this cmdlet (when compared to Get-AppV5FileXml and Get-AppV5FileXmlPackage) is that it returns a custom PSObject with a simpler property namespace and additional package information.

To populate our object we can run this:

[code]C:\PS> $AppVPackage = Get-AppV5FilePackage –AppV C:\Mozilla_Firefox_v17.0.appv[/code]

Going back to our example in Part 1, we can then query this object for both the VersionId and PVAD like so:

[code]C:\PS> $AppVPackage | Select-Object VersionId,FileSystemRoot | Format-List

VersionId      : fd215f39-f317-447d-aa79-7fe6c35e73f6
FileSystemRoot : C:\Program Files\Mozilla Firefox[/code]

Our custom PSObject also includes details of all the files in package and the uncompressed size. If you want to know how much space a package will take when loaded into the App-V 5 client cache, then this is the command for you!

To return the uncompressed package size we could run:

[code]$AppVPackage.UncompressedSize
43738570[/code]

If you want this in MB, easy:

[code]C:\PS> ($AppVPackage.UncompressedSize/1MB).ToString(“N2”)
41.71[/code]

Want the total number of files in the package?

[code]C:\PS> $AppVPackage.Files.Count
85[/code]

Need a list of all the files in the .APPV package?

[code]C:\PS> $AppVPackage.Files | Select-Object FullName

FullName
——–
Registry.dat
Root/components/binary.manifest
Root/components/browsercomps.dll
Root/defaults/pref/channel-prefs.js
Root/defaults/pref/local-settings.js
Root/dictionaries/en-US.aff
Root/dictionaries/en-US.dic
Root/extensions/%7B972ce4c6-7e08-4474-a285-3208198ce6fd%7D/icon.png
Root/extensions/%7B972ce4c6-7e08-4474-a285-3208198ce6fd%7D/install.rdf
Root/modules/services-aitc/.mkdir.done
Root/modules/services-common/.mkdir.done
Root/modules/services-crypto/.mkdir.done
Root/modules/services-notifications/.mkdir.done
Root/modules/services-sync/.mkdir.done
Root/modules/services-sync/engines/.mkdir.done
Root/modules/sessionstore/.mkdir.done
Root/searchplugins/amazondotcom.xml
Root/searchplugins/bing.xml
Root/searchplugins/eBay.xml
Root/searchplugins/google.xml
Root/searchplugins/twitter.xml
Root/searchplugins/wikipedia.xml
Root/searchplugins/yahoo.xml
Root/webapprt/omni.ja
Root/webapprt/webapprt.ini
Root/override.ini
Root/mozilla.cfg
Root/install.log
Root/AccessibleMarshal.dll
Root/application.ini
Root/blocklist.xml
Root/breakpadinjector.dll
Root/chrome.manifest
Root/crashreporter-override.ini
Root/crashreporter.exe
Root/crashreporter.ini
Root/D3DCompiler_43.dll
Root/d3dx9_43.dll
Root/dependentlibs.list
Root/firefox.exe
Root/freebl3.chk
Root/freebl3.dll
Root/gkmedias.dll
Root/libEGL.dll
Root/libGLESv2.dll
Root/maintenanceservice.exe
Root/maintenanceservice_installer.exe
Root/mozalloc.dll
Root/mozglue.dll
Root/mozjs.dll
Root/mozsqlite3.dll
Root/msvcp100.dll
Root/msvcr100.dll
Root/nspr4.dll
Root/nss3.dll
Root/nssckbi.dll
Root/nssdbm3.chk
Root/nssdbm3.dll
Root/nssutil3.dll
Root/omni.ja
Root/platform.ini
Root/plc4.dll
Root/plds4.dll
Root/plugin-container.exe
Root/precomplete
Root/removed-files
Root/smime3.dll
Root/softokn3.chk
Root/softokn3.dll
Root/ssl3.dll
Root/update-settings.ini
Root/updater.exe
Root/updater.ini
Root/webapp-uninstaller.exe
Root/webapprt-stub.exe
Root/xpcom.dll
Root/xul.dll
Root/firefox.exe.0.ico
Root/firefox.exe.1.ico
FilesystemMetadata.xml
StreamMap.xml
PackageHistory.xml
AppxManifest.xml
AppxBlockMap.xml
[Content_Types].xml[/code]

Hopefully, these cmdlets will be useful? As an example, we’ve used the Get-AppV5FilePackage cmdlet to create HTML .APPV package reports. Happy PoShing Open-mouthed smile

RES Workspace Manager Training Dates

Virtual Engine are pleased to announce that we’re running official RES Workspace Manager 2012 training courses in July 2013, in London. The following courses are available:

  • 3 day RES Workspace Manager 2012 Bronze RWMBC-510 course (details) between July 15 – 17 2013
  • 4 day RES Workspace Manager 2012 Silver/Gold RWMBC-510, 520 and 530 courses (details) from 15 – 18 July 2013.

If you would like to attend either of these training courses or require pricing information then please get in contact. Places are allocated on a first-come, first-served basis!

RES Workspace Manager 2012 Integration with Configuration Manager 2012 SP1 (SCCM)

This blog contains the ramblings of a man who has just installed System Center Configuration Manager 2012 SP1 in our RES Demo Showcase, to show how the integration works with RES Workspace Manager 2012.

The first thing I’d like to point out is why anyone would prefer to use Configuration Manager over RES Automation Manager is beyond me, but that’s probably left for another blog post. One thing I will say is that “simplicity” is not something I’d ever use to describe Configuration Manager! Enough of the drivel; lets get on with the real reason for this post.

Configuration Manager is used by many customers as a software delivery tool to deploy and install applications across their organisation. These applications can be targeted at devices or users and installed when required, i.e. when the user requests them or in a mandatory fashion; say when a new version of Microsoft Office is rolled out. Now this is all fine and dandy but there is no context awareness behind these deployment mechanisms. By context I mean Who they are, What type of device they are using, Where they are located and When they initiated the installation. Configuration Manager does now try and address this short coming by introducing the new “Applications” feature and “Rules”, but its limited in what it can do.

Those of you reading this blog post will hopefully already understand that RES Workspace Manager has been built around this ethos from before the dinosaurs (not quite, but you get my point). With that in mind you’d be correct in asking, “wouldn’t it be a great idea if RES Workspace Manager could integrate with Configuration Manager?” This would bring context awareness to application installs as well as delivering these applications “Just-In-Time,” i.e. when the user attempts to launch an application shortcut (if the application wasn’t already present). Well you might have guessed it by now, you can, and I’m going to show you how and what kind of things to look out for. I’m assuming you already know how to install and configure Configuration Manager (and its running ever so sweetly on your site servers consuming resources like there going out of fashion) so I’m not going to cover that bit!!

Configuration Manager “Applications”

One important point I’d like to mention here is that Workspace Manager does not yet support the new “Applications” feature in Configuration Manager 2012. When I say “support” I mean it will not work at all in Workspace Manager 2012 SR2. Whether that’s something RES will add at a later  date I’m not entirely sure, but for the sake of this blog it doesn’t. That means you have to continue to create and use the old style “Packages” and “Programs” that everyone knew and loved in previous versions of Configuration Manager.

Configuration Manager “Advertisements”

Another important point that might be worth mentioning at this time, from my testing, it doesn’t seem you actually have to create the “Deployment” (aka “Advertisement” in older versions) for the Programs that will be integrated with RES Workspace Manager. From the testing I’ve been doing, what actually seems to happen is RES Workspace Manager creates a temporary collection and advertisement/deployment on the fly, and deletes these once the application has been deployed and installed. The collection is named after the device where you initiated the installation from and if you’re quick enough you can see these objects being created in Configuration Manager console.

Configuration Manager “Administrative User”

You need to supply RES Workspace Manager, with a user that’s been defined in Configuration Manage and has sufficient privileges to carry out certain tasks; namely manage collections and create deployments. Configuration Manager 2012 has various security roles predefined but from my testing the minimum role that can be used is the “Application Administrator”. So I’d create a new user in Active Directory, could be a service account, add them as an administrative user in Configuration Manager i.e. RESWM and assign them that role – if you not bothered about security, you can grant them the “Full Administrator” role Surprised smile.

The first thing we need to do is enable the integration in RES Workspace Manager; which is relatively straight forward and is split into two phases.

Phase 1

  1. Start the RES Workspace Manager console, under the Setup menu select Microsoft System Center…
  2. Select the check box Enable Microsoft System Center ConfigMgr Integration.
  3. You will need to enter the the Configuration Manager server that has the Management Point role installed, i.e. Primary Site server and check the Autodetect management server on client. This can be useful if you have a large Configuration Manager implementation and multiple Site Servers etc.
  4. The credentials you supply will need to have sufficient privileges to the Configuration Manager environment – as I’ve pointed out previously.
  5. When you click the Test Now… button for the first time, the version will automatically be enumerated for you and set accordingly.Enable Configuration Manager Integration
  6. The next step in the process is to click the Test Now… button again. If successful you should be presented with a list of your defined Packages. As you can see from the screen shot below my list is not particularly exhaustive. This test also gives you the first indication that RES Workspace Management does not work with the new Applications feature as they aren’t listed.Test Configuration Manager Settings
  7. At this stage remember to click the Save Settings from the menu bar to commit your changes.

This concludes the first phase. We’re now in a position to use these Packages to install applications with the RES Workspace Manager integration; either at a global level or behind the configuration of an application – which is where I’d see it as most useful and what I’ve described below.

Phase 2

  1. Within the RES Workspace Manager console edit the managed application where you’re going to add the Configuration Manager integration; in my example I’m going to use WinRAR.
  2. From the Configuration tab add the Microsoft ConfigMgr action (shown below).Select Microsoft ConfigMgr Action
  3. You’ll see the Edit software distribution dialogue displayed.
  4. The first thing you probably want to do here is select the Program you’re going to deploy/install when this application is launched. You do this by clicking (…) in the Program field. What’s actually occurring here is: the Management Server that was defined in Phase 1 is being contacted to retrieve a list of Packages and Programs. The result should look something like this; hopefully your list contains more than my paltry set of programs.Select ConfigMgr Program
  5. Simply select the program you want to deploy and click OK. In my example I’m using WinRAR Archiver.
  6. You’ll need to fill in the rest of the fields as shown below (obviously changing WinRAR to something that matches you application!).New software distribution
  7. I probably need to explain some of my choices I’ve made here to avoid any confusion.
      • The Package name is automatically completed upon selecting the program;
      • I’ve checked the Skip if application executable was found ‘cos why would you want to try and deploy/install an application again if its already present? Makes sense I hope?!;
      • Now I’ve left the The Run Once as No ; using this setting in conjunction with the previous setting means should anyone uninstall the application is will instruct Configuration Manager to redeploy and reinstall the application again (because the executable will be missing);
      • For the Custom status message I’d certainly recommend mentioning its being installed by Configuration Manager. It’s not like we live in a “no blame culture” and someone would never, ever blame RES Workspace Manager if the installation was taking a long time, is it!? Anyway, there’s nothing more a user likes than a bit of feedback as to what’s happening.
      • Wait for task to finish before continuing is pretty obvious along with Run before other actions; you can’t launch the application if its not installed right?
  8. Finally make sure the Hide application if executable was not found is unchecked in the application Settings tab (shown below). Obviously the user needs to see the shortcut to actually invoke the application deployment and installation. Application Settings

Now that you have finished with the RES Workspace Manager setup give yourself a good pat on the back and keep your fingers crossed that Configuration Manager continues to play ball! In theory we’re now in a good position to login and launch our application from the shortcut, RES Workspace Manager will determine if the application executable is present and if not it will instruct the Configuration Manager client (CcmExec.exe) to contact the Management Point too deploy and install the application from the Distribution Point. When this magic occurs (as you can see from the screen shot) you’re presented with a very informative message box from RES Workspace Manager, just above the system tray, letting you know that something is happening.

System Tray Message

At this point you’re at the mercy of Configuration Manager which can potentially take a while to deploy and install the application. It goes without saying that should this part be successful, the application will launch. You might have noticed from the screenshot above that there weren’t any Configuration Manager notifications and that’s simply because I supressed the notifications. Within the program definition in Configuration Manager (as you can see below) simply check the Suppress program notifications checkbox. In your environment you might want these turned on, I just don’t like too many system tray notifications popping out at the users.

Program Properties

There are a couple of places in RES Workspace Manager that you can look to see when a Configuration Manager task was invoked and the outcome for troubleshooting purposes or just because you’re nosey! The first place too take a look at is the Log tab under the Setup menu select Microsoft System Center…

Logs

This gives a good overview of each task invoked. You can also use the Diagnostics > Event Logs to view the outcome per user session as seen here:

Event Logs

Now if for any reason the installation fails you’ll probably need to go and have a chat with the Configuration Manager “guru” (maybe that lucky person is you?) and look at the myriad of Configuration Manager logs to see why it failed.

Some Takeaways (Indian Please :D)

  1. Using RES Workspace Manager with Configuration Manager allows you to bring Context Awareness to your application deployments and install them Just-in-Time;
  2. Have a friendly word with your Configuration Manager “guru” before you begin, so he understands why you’re doing this and how it can benefit them too;
  3. You’ll need the Configuration Manager server details that have the Management Point role installed;
  4. Make sure you have the details or created an account that has correct Security Role defined in Configuration Manager;
  5. RES Workspace Manager 2012 SR2 can’t presently integrate with the new Applications feature in Configuration Manager 2012;
  6. You don’t need to create Deployments/Advertisements or Collections beforehand in Configuration Manager for the integration to work with RES Workspace Manager;

I’ve tried to be as factually correct as possible but I confess that I’m no Configuration Manager “guru.” Please do leave a comment if I’ve got something horribly wrong and I hope you’ve found this blog post useful.

Enjoy!!

Nathan

App-V 5 Configuration Editor User Guide

ACEWe’ve been working hard getting the App-V 5 Configuration Editor (ACE) ready for a BETA release; take a look at the ACE page for a bit more information about why it was developed.

With any new application it’s great to have some user guides, right (RTFM)?!? Rest assured that will come when it’s officially released, in the mean time we wanted to create this short blog to guide you through the ACE interface. There is also an assumption here you have an understanding of the App-V 5 Dynamic Configuration files and how they are used, if not you might want to take a look at this technet article.

USER INTERFACE

Main Toolbar:

You will notice there are three main buttons in the tool bar as shown below:

SNAGHTML105760e

image Opens an App-V XML file, i.e. a UserConfig.xml or DeploymentConfig.xml file. Once the file has been opened the contents will be parsed and displayed under the various tabs within the GUI.

image Saves the current App-V XML file, including any changes that have been made. You can give it a new name and Save As a different file, keeping your original one as is if necessary.

image Previews the changes that will be made to the App-V XML file before saving. This gives you the ability to check out the structure of the generated XML. It’s probably a good idea to point out here that you don’t need to preview the changes prior to performing a save.

Package Details:

This sections displays the Package Display Name, Package ID and Type of XML file opened, i.e. DeploymentConfig or UserConfig. Here is an example DeploymentConfig.xml opened below:

SNAGHTML10a6c4e

MAIN CONFIGURATION TABS

Once an App-V 5 configuration XML file has been opened you can then begin to make changes as required using the tabs set out below.

User Configuration

Under the User Configuration tab you can change and view various options and configurations:

SNAGHTML1151fa5

Options

Various global options change be changed here if you so desire, e.g. altering the COM integration mode.

Shortcuts

This tab allows you to view all the defined Shortcuts within the package.

NOTE: at this time its Read Only but is great for getting an overview of all the Shortcuts available.

SNAGHTML123eb5d

Scripts (User Context)

This is really where ACE starts to make life simple Smile. You can easily define which scripts you’d like to add and to which actions, e.g. PublishPackage, UnpublishPackage, StartVirtualEnvironment, TerminateVirtualEnvironment, StartProcess and ExitProcess. There is no need to worry about getting the syntax in the XML file right. There are are some excellent blogs out there talking about using scripts in App-V 5.0, so I suggest you take a look here at one from Tim Murgent and Microsoft’s own Steve Thompson if you need some further background information.

NOTE: You might have noticed that not all the script actions are available under this tab, that’s simply because those excluded aren’t permitted to run under the User Configuration section of the XML file.

I think most of the options are self explanatory but, it’s good to point out that leaving the Timeout value at 0 means no timeout period will be set, i.e. it will wait indefinitely for it to finish so use with caution.

SNAGHTML137e66e

Machine Configuration

Under the Machine Configuration tab you can alter global options, configure scripts and control the termination of processes.

NOTE: this tab will only be available when you open a DeploymentConfig.xml file. This is because machine configuration items cannot be set in the UserConfig.xml file.

SNAGHTML144b2d1

Options

Here you’ll find any options that can be changed if you so desire.

Terminate Child Processes

You can define the path to an executable, that when closed, will terminate any child process running within the virtual environment.

SNAGHTML14d302a

Scripts (System Context)

Very much like the Scripts tab under User Configuration you can define which scripts you’d like to add to which actions, e.g. AddPackage, RemovePackage, PublishPackage and UnpublishPackage.

NOTE: You might have noticed that not all the script actions are available under this tab, that’s simply because those excluded aren’t permitted to run under the Machine Configuration section of the XML file.

SNAGHTML1522226

XML

You can view both the source (original) XML and/or preview the generated XML under this tab.

SNAGHTML18ecc7a

Source XML

This is simply where you can view your source App-V XML file as it was when you opened it.

Generated XML

Once you click the Preview button image this pane will display any changes that will be made to the App-V XML file, giving you the ability to check out the structure of the XML before saving if you wish.

NOTE: You don’t have to preview the changes prior to performing a save.

The example below (highlighted in yellow) shows the changes made by ACE in the generated XML format.

SNAGHTML19082ed

Hopefully this brief guide has given you a good overview of how to use ACE. Hopefully you’ll agree its pretty intuitive to use and should make editing the App-V 5 Dynamic Configuration files a lot, lot easier (well we think so anyway!) 🙂

DISCLAIMER: THE APP-V CONFIGURATION EDITOR IS FREE TO USE AT YOUR OWN RISK, WE CANNOT BE HELD RESPONSIBLE FOR ANY DAMAGE IT MIGHT CAUSE.

Updating and Writing XML Files with PowerShell

Manipulating XML files with PowerShell is something that we’re having to accomplish more and more internally. Microsoft App-V 5.0 and RES Workspace Manager utilise XML files extensively. Whilst we can manually tweak them, there’s nothing like automating things for consistency and speed!

I have seen a lot of “rip and replace” and “find and replace” script examples, but ensuring that the correct elements/nodes are added in the correct place can be troublesome. The only real option is to utilise the built-in .Net Framework XML objects. Hopefully this post will lay the basis for some more App-V 5.0 focused blogs in the future Open-mouthed smile.

There are lots of forum posts out there that detail snippets of information, but a lot of it is trial and error. As a starting point you might want to read up here first. Reading XML files is one thing, but as the previous article mentions, inserting (multiple) elements can be quite convoluted. Note: I’m using the XmlDocument .Net object here but it is possible to utilise other .Net classes, e.g. XPath and/or XDocument.

Here is the example we’ll use in this post. Apologies; the XML formatting is stripped by the plugin:

<!-- employees.xml -->
<employees>
  <employee id="101">
    <name>Frankie Johnny</name>
    <age>36</age>
  </employee>
  <employee id="102">
    <name>Elvis Presley</name>
    <age>79</age>
  </employee>
  <employee id="301">
    <name>Ella Fitzgerald</name>
    <age>102</age>
  </employee>
</employees>

Creating XML Elements

If we wish to add a new employee record to the above document, we need to create a new XML element (or node). Firstly we need to load the XML document:

$fileName = “employees.xml”;
$xmlDoc = [System.Xml.XmlDocument](Get-Content $fileName);

Now we can create our new element/node, append it to the parent reference and save it:

$newXmlEmployeeElement = $xmlDoc.CreateElement("employee");
$newXmlEmployee = $xmlDoc.employees.AppendChild($newXmlEmployeeElement);
$xmlDoc.Save($fileName);

To shorten this we can just use this (see here for more information on the CreateElement method):

$newXmlEmployee = $xmlDoc.employees.AppendChild($xmlDoc.CreateElement("employee"));
$xmlDoc.Save($fileName);

If we examine the resulting XML file we’ll find the following (note the new empty element):

<!-- employees.xml -->
<employees>
  <employee id="101">
    <name>Frankie Johnny</name>
    <age>36</age>
  </employee>
  <employee id="102">
    <name>Elvis Presley</name>
    <age>79</age>
  </employee>
  <employee id="301">
    <name>Ella Fitzgerald</name>
    <age>102</age>
  </employee>
  <employee />
</employees>

 Adding XML Attributes

To add the ID attribute tag in the XML document, we need to create a new XmlDocument Attribute and then attach it to our newly created element. We can create an XmlDocument attribute on our element with the following code:

$newXmlEmployee = $xmlDoc.employees.AppendChild($xmlDoc.CreateElement("employee"));
$newXmlEmployee.SetAttribute(“id”,”111”);
$xmlDoc.Save($fileName);

Now our resulting XML file looks like this:

<!-- employees.xml -->
<employees>
  <employee id="101">
    <name>Frankie Johnny</name>
    <age>36</age>
  </employee>
  <employee id="102">
    <name>Elvis Presley</name>
    <age>79</age>
  </employee>
  <employee id="301">
    <name>Ella Fitzgerald</name>
    <age>102</age>
  </employee>
  <employee id="111">
</employees>[/code]

Adding Nested XML Elements

Knowing how to add elements we can simply create our sub elements and attach them to our newly created parent reference:

$newXmlNameElement = $newXmlEmployee.AppendChild($xmlDoc.CreateElement("name"));
$newXmlAgeElement = $newXmlEmployee.AppendChild($xmlDoc.CreateElement("age"));

The resulting XML file now looks like:

<!-- employees.xml -->
<employees>
  <employee id="101">
    <name>Frankie Johnny</name>
    <age>36</age>
  </employee>
  <employee id="102">
    <name>Elvis Presley</name>
    <age>79</age>
  </employee>
  <employee id="301">
    <name>Ella Fitzgerald</name>
    <age>102</age>
  </employee>
  <employee id="111">
    <name />
    <age />
  </employee>
</employees>

Adding XML Text Nodes

Unbeknownst to me, when you have text within an element tag, i.e. <name>Iain Brighton</name>, this is known as a text node (at least in XDocument speak). This is probably the bit that took longest to work out.

To add the text node we can use the following code:

$newXmlNameElement = $newXmlEmployee.AppendChild($xmlDoc.CreateElement("name"));
$newXmlNameTextNode = $newXmlNameElement.AppendChild($xmlDoc.CreateTextNode("Iain Brighton"));

$newXmlAgeElement = $newXmlEmployee.AppendChild($xmlDoc.CreateElement("age"));
$newXmlAgeTextNode = $newXmlAgeElement.AppendChild($xmlDoc.CreateTextNode("37"));

Et voilà!

<!-- employees.xml -->
<employees>
  <employee id="101">
    <name>Frankie Johnny</name>
    <age>36</age>
  </employee>
  <employee id="102">
    <name>Elvis Presley</name>
    <age>79</age>
  </employee>
  <employee id="301">
    <name>Ella Fitzgerald</name>
    <age>102</age>
  </employee>
  <employee id="111">
    <name>Iain Brighton</name>
    <age>37</age>
  </employee>
</employees>

 Full PowerShell Code Snippet

Here is the full code listing:

$fileName = “employees.xml”;
$xmlDoc = [System.Xml.XmlDocument](Get-Content $fileName);

$newXmlEmployee = $xmlDoc.employees.AppendChild($xmlDoc.CreateElement("employee"));
$newXmlEmployee.SetAttribute("id","111");

$newXmlNameElement = $newXmlEmployee.AppendChild($xmlDoc.CreateElement("name"));
$newXmlNameTextNode = $newXmlNameElement.AppendChild($xmlDoc.CreateTextNode("Iain Brighton"));

$newXmlAgeElement = $newXmlEmployee.AppendChild($xmlDoc.CreateElement("age"));
$newXmlAgeTextNode = $newXmlAgeElement.AppendChild($xmlDoc.CreateTextNode("37"));

$xmlDoc.Save($fileName);

Documenting App-V 5.0 Packages

Continuing our series of posts on the Virtual Engine App-V 5.0 .APPV PowerShell CmdLets, this one will show you how to quickly document your .APPV packages’ contents. The Save-AppV5FileReport cmdlet generates a HTML report of information contained within the .APPV package contents. Here’s an example summary report (detailed reports are also available):

Generating Single Reports

Generating summary reports (such as the one above) simply requires running the following command:

[code]C:\PS> Save-AppV5FileReport –AppV C:\Mozilla_Firefox_v17.0\Mozilla_Firefox_v17.0.appv[/code]

This will generate a Mozilla_Firefox_V17.0_Report.html file in the source C:\Mozilla_Firefox_v17.0\ directory. If we wanted a detailed report instead we could run:

[code]C:\PS> Save-AppV5FileReport –AppV C:\Mozilla_Firefox_v17.0\Mozilla_Firefox_v17.0.appv –Detailed[/code]

Documenting Multiple Packages

Creating a report for a single package is fine, but what if we wanted to document all packages on a share or in a folder? Fortunately this is simple. If you wanted each package report in the source package directory, we can do so like this:

[code]C:\PS> Get-ChildItem C:\Packages\ -Include *.appv -Recurse | % { Save-AppV5FileReport -AppV $_.FullName }

Directory: C:\Packages\GoogleChrome_v23.0.1271.91

Mode                LastWriteTime     Length Name
—-                ————-     —— —-
-a—        02/05/2013     12:36       8884 GoogleChrome_v23.0.1271.91_Report.html

Directory: C:\Packages\Mozilla_Firefox_v17.0

Mode                LastWriteTime     Length Name
—-                ————-     —— —-
-a—        02/05/2013     12:36       8802 Mozilla_Firefox_v17.0_Report.html

Directory: C:\Packages\Paint.Net_v3.5.10

Mode                LastWriteTime     Length Name
—-                ————-     —— —-
-a—        02/05/2013     12:36       8770 Paint.NET_v3.5.10_Report.html[/code]

What about if we wanted all the reports in a single location? Again, pretty straight forward. The Save-AppV5FileReport cmdlet has a –FilePath parameter that we can specify the output location. Note: this folder is not automatically created so make sure it exists! Our command to achieve this is:

[code]C:\PS> Get-ChildItem C:\Packages\ -Include *.appv -Recurse | % { Save-AppV5FileReport -AppV $_.FullName -FilePath C:\Packages\Reports\ }

Directory: C:\Packages\Reports

Mode                LastWriteTime     Length Name
—-                ————-     —— —-
-a—        02/05/2013     12:40       8884 GoogleChrome_v23.0.1271.91_Report.html
-a—        02/05/2013     12:40       8802 Mozilla_Firefox_v17.0_Report.html
-a—        02/05/2013     12:40       8770 Paint.NET_v3.5.10_Report.html[/code]

Hopefully you’ll find these HTML reports useful. We are planning to add sequencer reports into this module in the near future too, so stay tuned! Happy PoShing 😀

Extracting files from an .APPV file with PowerShell

Whilst doing a lot of work with App-V 5.0 we have come across the requirement to look inside the .appv file with PowerShell. In our particular instance we’re after the package VersionId which is contained in the AppxManifest.xml file. As previously championed, we love automating and this should be easy!

The .appv file extension is a compressed archive and therefore, should be simple to crack open. After scouring the interweb, there is very little information on how to achieve this in code. We could use the built-in Shell32.dll functionality but this requires us to rename the file to .zip first. Ideally we want to avoid copying or renaming the source files. I did find one reference over on the Login Consultants forum which pointed me in the right direction.

Disclaimer: the following code requires the .Net Framework 4.5. The System.IO.Compression.FileSystem object is not available in previous releases. You can check in the C:\Windows\Microsoft.NET\assembly\GAC_MSIL\ folder and if you have the System.IO.Compression.FileSystem folder you should be good to go Smile with tongue out.

To get this new .Net functionality to work within PowerShell we will be calling the .Net assemblies directly and therefore need to create a couple of references. In our example we’ll be using both the System.IO.Compression and System.IO.Compression.FileSystem assemblies (two different DLLs hence the two references):

[code]### The System.IO.Compression.FileSystem requires at least .Net Framework 4.5
[System.Reflection.Assembly]::LoadWithPartialName(“System.IO.Compression”) | Out-Null;
[System.Reflection.Assembly]::LoadWithPartialName(“System.IO.Compression.FileSystem”) | Out-Null;[/code]

Next we can create our FileStream object (with read only access) required by the ZipArchive object class.

[code]### Open the ZipArchive with read access
$FileStream = New-Object System.IO.FileStream($SourceAppV5Archive, [System.IO.FileMode]::Open);
$AppV5Archive = New-Object System.IO.Compression.ZipArchive($FileStream);[/code]

In fact we can shorten this down to a single line:

[code]### Open the ZipArchive with read access
$AppV5Archive = New-Object System.IO.Compression.ZipArchive(New-Object System.IO.FileStream($SourceAppV, [System.IO.FileMode]::Open));[/code]

Once we have opened our .ZIP (.appv) file we can retrieve the AppXManifest.xml file entry:

[code]### Locate the AppxManifest.xml file
$AppxManifestEntry = $AppV5Archive.GetEntry(“AppxManifest.xml”);[/code]

Having the ZipArchiveEntry object we can extract it with the ExtractToFile method:

[code]### Extract the $ZipArchiveEntry
$ZipArchiveEntry.ExtractToFile($SaveAs);[/code]

Unfortunately this does work and reports the following error:

[code]Method invocation failed because [System.IO.Compression.ZipArchiveEntry] doesn’t contain a method named ‘ExtractToFile’.[/code]

Eh!? WT… Looking on the ZipArchiveEntry reference page on MSDN, the ExtractToFile is an Extension Method. Therefore, we need to utilise the underlying object method, the ZipFileExtensions.ExtractToFile method. For more information on Extension Methods in PowerShell see here and here. Now our code should look like this:

[code]### Extract the ZipArchiveEntry (ZipArchiveEntry.ExtractToFile is an extension method)
[System.IO.Compression.ZipFileExtensions]::ExtractToFile($AppxManifestEntry, $SaveAs, $Overwrite);[/code]

Finally we need to ensure that we correctly dispose of the ZipArchive object otherwise we’ll leave it open:

[code]### Ensure we close the file handle otherwise the file will be left open
$AppV5Archive.Dispose();[/code]

That’s it! It you want a simpler way of doing this, just download the Virtual Engine App-V 5.0 Package PowerShell CmdLets. You can achieve all this in just a single command:

[code]Save-AppV5FileXml -AppV c:\package.appv -XML AppxManifest[/code]

Full PowerShell Code Snippet

Here is the full code listing:

[code]### The System.IO.Compression.FileSystem requires at least .Net Framework 4.5
[System.Reflection.Assembly]::LoadWithPartialName(“System.IO.Compression”) | Out-Null;
[System.Reflection.Assembly]::LoadWithPartialName(“System.IO.Compression.FileSystem”) | Out-Null;

### Open the ZipArchive with read access
$AppV5Archive = New-Object System.IO.Compression.ZipArchive(New-Object System.IO.FileStream($SourceAppV5Archive, [System.IO.FileMode]::Open));

### Locate the AppxManifest.xml file
$AppxManifestEntry = $AppV5Archive.GetEntry(“AppxManifest.xml”);
### ZipArchiveEntry.ExtractToFile is an extension method
[System.IO.Compression.ZipFileExtensions]::ExtractToFile($AppxManifestEntry, $SaveAs, $true);

### Ensure we close the file handle otherwise the file will be left open
$AppV5Archive.Dispose();[/code]

VET v1.3 Released!

Virtual Engine are pleased to announce the general availability of version 1.3 of the Virtual Engine Toolkit (VET). The latest Windows installer and documentation is available for download now on the Virtual Engine web site. New in this release is the addition of the WSUS Integration Management Pack (WiMP).

There’s no “What’s New” video this time but to view existing videos on the Virtual Engine Toolkit, please check out our YouTube channel.