Kateryna's Blog

Web PI APIs: Visualize Product Hierarchy with DGML

kateroh — Sat, 20 Mar 2010 06:21:00 GMT

Today, I was checking one of my favorite blogs by Tess Fernandez, which is a great source of discussions, tips and tricks around debugging. One of the latest blogs is about GCRootToDGML tool written by Chris Lovett to generate a visual representation (DGML graph) of the runtime objects graphs. Running Visual Studio 2010 RC for already a couple of weeks, I haven’t even heard about this new feature. It comes as no surprise, since Visual Studio 2010 has tons of great features and it will take some time to discover them all. My immediate thought was to finally realize my long-due project at low cost – generating a diagram of Web PI product dependencies. So, once this idea came to my mind, a blocking thread was spawned stopping me from doing anything else until the goal was reached. What I thought before was going to take at least a day to write, with DGML and VS 2010 turned out to be just a couple of hours including the initial research and playing around with the feature.

About DGML

DGML stands for Directed Graph Markup Language and is a subset of XML with rules that Visual Studio 2010 uses to generate its architecture graphs. The format is very easy to use to get started, but it contains way more than it is going to be shown in this post.

Goal

The goal is to

get all the products available in Web PI through all the feeds (product, applications, media, tools and enterprise feeds)
filter them by what is available on the current machine (checking OS and architecture) and what is not yet installed
generate an XML/DGML of what is available with all dependencies and related products
open the generated DGML file with VS 2010
not forget to say “wow, VS, cool!”

The format that is going to represent the product dependency hierarchy is very simple:

<DirectedGraph xmlns="http://schemas.microsoft.com/vs/2009/dgml">
  <Links>
    <Link Source="Product1" Target="DependencyProduct1" />
    <Link Source="Product1" Target="DependencyProduct2" />
    <Link Source="Product2" Target="DependencyProduct3" />
  </Links>
</DirectedGraph>

Each DGML file has to be rooted with “DirectedGraph” and have links defined exactly as shown above with “Source” and “Target” attributes. This xml saved with “.dgml” extension and opened with Visual Studio 2010 will yield the following visual result:

Wow, VS, cool!!

Details

In my previous post, I showed how to load all the products regardless of the current platform and architecture, so I’m not going to show the full source code for this project here as it is pretty-straight-forward, but you can download the project here.

The only addition to Program.cs in the project is Link.cs, which contains the Link class, that defines a relationship between two products.

    public class Link
    {
        public enum RelationshipType
        {
            Dependency,
            RelatedProduct
        }

        private string _source;
        private string _target;
        private RelationshipType _relationshipType;

       // the rest of the class...
    }

Both _target and _source will hold ProductIds to identify objects in the graph. You can use anything else instead of ProductId to identify products in the graph, but I’m using ProductId because it is a concise, descriptive and unique identifier of a product. If you cannot identify a product by the ProductId displayed in the graph, you can look it up in a corresponding feed or use ProductManager.GetProduct(”ProductId”) method to find the product.

RelationshipType will be used to indicate the link between two products, so that the relationship can be displayed differently in the graph (different arrow color). Once the feeds are loaded, I traverse ProductManager.Products property and define all the links. Finally, I use XmlWriter to create a dgml file.

You can tweak the code as much as you want to generate different views of Web PI product world. For example, you can see:

products available in just one particular feed – filter products by Product.FeedLocation property
products that are not yet installed – filter using Product.IsInstalled method
products with dependencies (must-have with this product) and related products (nice-to-have)
products available for a particular architecture or platform
any combination of the above and/or your own filters

Graphs

Here is a couple of graphs I generated tweaking the code here and there (red arrow = dependency, black arrow = related product).

1. All products available from just the Tools feed (if currentProduct.FeedLocation.Contains(“Tools”))

2. All products and applications not yet installed on my machine (Win 7 Ultimate) with only dependencies shown (no related products) and no feeds loaded (load the main feed with filterByArchitectureAndOs==true, no calls to Productmanager.LoadExternalFile and no product.RelatedProducts)

3. All available (not yet installed on the current machine) products regardless of the platform and architecture.

4. All applications with dependencies and related products that are not yet installed on my machine

Links

You can read more about DGML in the following blogs:

Web PI APIs: Download Latest Web Stack Products for Any Platform

kateroh — Sat, 27 Feb 2010 00:06:00 GMT

Suppose you have a central Internet faced server and multiple backend servers not connected to the Internet. To insure that your Internet faced server is always up-to-date with the latest Microsoft Web Stack products and updates, you can use Web Platform Installer. You can either use Web PI UI to set up your main server or you can automate the setup process by interfacing with Web PI APIs through Microsoft.Web.PlatformInstaller.dll. It was already shown in my previous blog post how to load and install specific products for the current machine through the APIs. In this blog, I will show how to download products for any Web PI supported platform using APIs. This solution might help you in setting up your load balancer that can download and cache products for its backend servers regardless of their OS and architecture. This solution is by no means perfect and final and is given as a sample.

Overview

From this post you will learn how to use WebPI APIs to:

- load the main product and application feeds

- filter products by any OS and architecture

- pull products with their dependencies

- manage installers locally in the installer cache

- avoid a dependency check for downloaded products

Details

When dealing with Web PI APIs, you will deal mostly with ProductManager and InstallManager classes. ProductManager is responsible for loading and filtering product information from the xml feeds, where all product information is stored. And InstallManager is responsible for actually downloading and installing the products (and applications, and updates – basically everything that is available through the Web PI feeds).

ProductManager has several overloads for Load method that loads the main feed with all its enclosures (other product feeds like application feed). The overload that will be used in the sample accepts more parameters than his other overloaded counterparts. With this overload you can make Web PI filter products by any OS and architecture. If you use the overload that does not accept parameters for the OS and architecture, it means that Web PI will filter products by version, type and architecture of your current platform. Thus, for the overload that we will be using, you will need to specify the architecture (x86 or x64), the major and minor OS versions, major and minor SP versions and OS type. Here is a small table that shows the major and minor versions of some OSes.

OS	Major Version	Minor Version
Windows 7/ Windows Server 2008 R2	6	1
Vista/Windows Server 2008	6	0
Windows Server 2003	5	2
Windows XP	5	1

Finally, ProductManager can find you a Product based on its ProductId (can be looked up directly in the xml feed), which will contain all information available for this product including information about its installers. From a product object you just need to pick the right installer you want to use to install this product. The right installer might be based not only on the specific platform you want to install this product on, but also on the language of the installers, if the product is available in that language.

InstallManager can cache products without installing them. The only catch in this case is that while loading products (ProductManager.Load), Web PI will perform a dependency check for the products you are trying to load against your current platform and will throw an exception if you try to load something incompatible with your current platform. That’s fine. You can pragmatically download the installers yourself using the links that each installer object carries along (Installer.InstallerFile.InstallerUrl). The disadvantage of downloading the files yourself is that you don’t use the following goodies that Web PI provides you with in the background when downloading the installers itself:

installer management in central location, aka Installer Cache (%LocalAppData%\Microsoft\Web Platform Installer\installers) with different paths for different installers of the same product (based on the installer signature)
order of installers – Web PI installs products in a smart way, because some products have to be installed after their dependencies are installed
retry logic for download failures
figuring out the installer’s extension (can be msi or exe or msu (for updates), etc)

On the other hand, the advantage of using Web PI APIs in this case is still great. You are guaranteed to get "the latest and greatest" products and updates in one central location and Web PI provides you with powerful APIs to leverage this feature in the easy-to-use way that can also be automated!
Take a look yourself…

Code

You can grab the full project (with only this file in it) here.

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using Microsoft.Web.PlatformInstaller;

namespace ProductCacher
{
    class Program
    {
        protected readonly static string MainXml = "https://go.microsoft.com/fwlink/?LinkId=158722";
        
        static void Main(string[] args)
        {
            ProductManager productManager = new ProductManager();

            // 1. Load main product feeds
            // overload documentation: http://msdn.microsoft.com/en-us/library/ee255981.aspx
            productManager.Load
                (
                    new Uri(MainXml),                    // location of the main feed 
                    false,                               // do not filter products by the current architecture and OS
                    true,                                // load enclosures (eg WebApplicationList.xml)
                    false,                               // no cache yet, so do not use cached directory
                    @"d:\MyCache",                       // where to cache XML feeds (the folder should exist)

                    // get only products available for 
                    //      a. x86 architecture (and those available for both x86 AND x64)
                    //      b. the current OS (major and minor OS versions)
                    //      c. up to service pack 2 (major and minor sevice pack versions)
                    //      d. any product types (e.g. Home, Professional, Ultimate, Web Server, etc)
                    Architecture.x86,                    // arch
                    Environment.OSVersion.Version.Major, // current major version
                    Environment.OSVersion.Version.Minor, // current minor version
                    2,                                   // current major SP
                    0,                                   // current minor SP
                    0  // OsType as defined in this list: http://msdn.microsoft.com/en-us/library/ms724358(VS.85).aspx
                       // 0 if don't want to filter products by OSType
                );

            // 2. Find all the products to cache: .NET Fx 3.5 SP1, SQL Expess, PHP, MySQL, UrlRewrite and SEOToolkit
            Product netFramework35Sp1 = productManager.GetProduct("NETFramework35");
            Product sqlExpress = productManager.GetProduct("SQLExpress");
            Product php = productManager.GetProduct("PHP");
            Product mySql = productManager.GetProduct("MySQL");
            Product SEOtoolkit = productManager.GetProduct("SEOToolkit");
            Product urlRewrite = productManager.GetProduct("UrlRewrite");
            Product webDeploy = productManager.GetProduct("WDeploy");

            // 3. Add all products with the dependencies to the install list
            List<Product> productsToInstall = new List<Product>();
            AddProductWithDependencies(netFramework35Sp1, productsToInstall);
            AddProductWithDependencies(sqlExpress, productsToInstall);
            AddProductWithDependencies(php, productsToInstall);
            AddProductWithDependencies(mySql, productsToInstall);
            AddProductWithDependencies(SEOtoolkit, productsToInstall);
            AddProductWithDependencies(urlRewrite, productsToInstall);
            AddProductWithDependencies(webDeploy, productsToInstall);
            
            // 4. For each product pick the installers (can choose a language of each installer if localized installer is available)
            List<Installer> installersToUse = new List<Installer>();
            Language english = productManager.GetLanguage("en");
            foreach (Product productToInstall in productsToInstall)
            {
                Installer currentInstaller = productToInstall.GetInstaller(english);
                
                // if current product has installer to download (it might be an installer-less Windows component)
                if (currentInstaller != null && currentInstaller.InstallerFile != null)
                {
                    installersToUse.Add(currentInstaller);
                }
            }

            // ***********************************************************************//
            // NOTE: if you use this code, to make WebPI download the installers,
            // WebPI will perform a dependency check against your CURRENT platform.
            // For example, if you are trying to download something incompatible with your
            // current OS, WebPI will throw
            // ***********************************************************************//
            /*
             
            // 5. Prepare installers
            InstallManager installManager = new InstallManager();
            installManager.Load(installersToUse);

            // 6. Download products without installing them
            foreach (InstallerContext installerContext in installManager.InstallerContexts)
            {
                // each installer will be cached under %LocalAppData%\Microsoft\Web Platform Installer\installers\<product Id>\<installer's SHA1>\
                string failureReason;
                installManager.DownloadInstallerFile(installerContext, out failureReason);
                if (!string.IsNullOrEmpty(failureReason))
                {
                    Console.Error.WriteLine("Web PI download failure: " + failureReason);
                }
                    
            }
            // ***********************************************************************/

            // 5. Download the installers in the same folder Web PI does, aka Installer Cache
            string WebPIinstallersFolder = Environment.ExpandEnvironmentVariables(@"%LocalAppData%\Microsoft\Web Platform Installer\installers");
            if (!Directory.Exists(WebPIinstallersFolder)) 
            {
                Directory.CreateDirectory(WebPIinstallersFolder);
            }
            foreach (Installer installer in  installersToUse) 
            {
                // re-create WebPI behavior: download each installer 
                // under %LocalAppData%\Microsoft\Web Platform Installer\installers\<product Id>\<installer's SHA1>\
                string currentInstallerDirectory = 
                    Path.Combine(WebPIinstallersFolder, installer.Product.ProductId) + 
                    "\\" + installer.InstallerFile.SHA1Hash;
                
                // if the directory <productId>\<installer's hash> doesn't exist, create it
                if (!Directory.Exists(currentInstallerDirectory)) 
                {
                    Directory.CreateDirectory(currentInstallerDirectory);
                }    
            
                WebClient downloadClient = new WebClient();
                downloadClient.DownloadFile
                    (
                        installer.InstallerFile.InstallerUrl,
                        Path.Combine(currentInstallerDirectory, installer.Product.ProductId + 
                        // NOTE: by far not the best method to get a file extension, 
                        // consider the case where your absolute URL does not contain file extension
                        Path.GetExtension(installer.InstallerFile.InstallerUrl.AbsolutePath))
                    );
            }
        }

        private static void AddProductWithDependencies(Product product, List<Product> productsToInstall)
        {
            // avoid duplicates 
            if (!productsToInstall.Contains(product))
            {
                productsToInstall.Add(product);
            }

            // GetMissingDependencies will check whether any dependencies are not installed for the product
            // AND are not already added to the install list (productsToInstall)
            ICollection<Product> missingDependencies = product.GetMissingDependencies(productsToInstall);
            if (missingDependencies != null)
            {
                foreach (Product dependency in missingDependencies)
                {
                    AddProductWithDependencies(dependency, productsToInstall);
                }
            }
        }
    }
}

Acknowledgements

Thanks to Bilal Alam for the original idea.

Web PI APIs: Install a product from a custom feed

kateroh — Thu, 11 Feb 2010 17:55:00 GMT

In my previous blog posts, I described how to create custom feeds for Web Platform Installer to install custom products and applications. There are many uses to these custom feeds from automatically setting up your environment with custom products in addition to products already offered in WebPI to testing your applications for inclusion to Windows Web App Gallery. With the last use in mind, automating the process of testing the application can be very useful.

From this post you will learn how to use WebPI APIs to:

load an existing custom feed
install a product with all its dependencies
install an application with dependencies and tweak its parameters
select a language of your install

Resources

Download the solution with the driver below from here.

Refer to MSDN documentation for the full list and description of WebPI APIs: Microsoft.Web.PlatformInstaller Namespace.

Details

The program below should be pretty self-descriptive. I’m using a custom feed used in this blog that contains one product and one application in it - http://blogs.iis.net/blogs/kateroh/SIR/SIRWebPIFeed.xml.

Reference to Microsoft.Web.PlatformInstaller.dll is required, which is GAC’ed during installation of WebPI.

First, we need to make WebPI load the main product feed and only then our custom feed. The reason for this is that our custom feed can refer to some products from the main feed as dependencies. For example, the application defines a dependency on Web Deploy tool, the tool that WebPI uses to install all Application Gallery applications. If this tool is not installed, it should be installed before that application can be deployed.

Once all feeds are loaded, we find the products we need to install by its productId (defined as <productId /> in the feeds). The method to find a product and application is the same, though the method to install them is a bit different. There are two major APIs to install products – InstallManager.StartInstallation() and InstallManager.StartApplicationInstallation(). There are two reasons why applications should be installed separately from the products:

To successfully deploy and run applications, the environment should be setup correctly with the requirements. For example, in addition to Web Deploy that all applications require, a certain application might require a certain version of framework to be install, a database engine, UrlRewrite to name just a few.
In order to set parameters on the application (step 9), the application has to be downloaded first. In step 8, in installManager.StartInstallation() WebPI not only installs all products added to ProductManager, but also downloads all applications added to ProductManager in the same way. Thus, after this step, the parameters can be set and application installation can start.

The driver also signs up for two major WebPI installation events – InstallerStatusUpdated and InstallCompleted and simply outputs progress to the screen.

using System;
using System.Collections.Generic;
using Microsoft.Web.PlatformInstaller;

namespace CustomProductInstaller
{
    class Program
    {
        protected readonly static string MainXml = "https://go.microsoft.com/fwlink/?LinkId=158722";
        protected readonly static string CustomXml = "http://blogs.iis.net/blogs/kateroh/SIR/SIRWebPIFeed.xml";

        protected readonly static string CustomProductId = "AppGallerySIRBinaries";
        protected readonly static string CustomAppId = "AppGallerySIRApp";

        private static bool _installCompleted = false;

        static void Main(string[] args)
        {
            ProductManager productManager = new ProductManager();

            // 1. Load main product feeds
            productManager.Load
                (
                    new Uri(MainXml), // location of the main feed 
                    false,            // load products for all architectures and platforms
                    true              // load enclosures (eg WebApplicationList.xml)
                );

            // 2. Load custom feed
            productManager.LoadExternalFile(new Uri(CustomXml));

            // 3. Find the custom product by product Id
            Product customProduct = productManager.GetProduct(CustomProductId);
            Product customApp = productManager.GetProduct(CustomAppId);

            // 4. Find all products to install (custom product + its dependencies)
            List<Product> productsToInstall = new List<Product>();
            AddProductWithDependencies(customProduct, productsToInstall);
            AddProductWithDependencies(customApp, productsToInstall);

            // 5. Pick the right installers - for the chosen language, if such is not available, fall back to English
            List<Installer> installersToUse = new List<Installer>();
            Language languageOfInstallers = productManager.GetLanguage("fr");
            Language english = productManager.GetLanguage("en");

            foreach (Product productToInstall in productsToInstall)
            {
                Installer currentInstaller = productToInstall.GetInstaller(languageOfInstallers);
                if (currentInstaller == null)
                {
                    currentInstaller = productToInstall.GetInstaller(english); ;
                }
                installersToUse.Add(currentInstaller);
            }

            // 6. Prepare installers
            InstallManager installManager = new InstallManager();
            installManager.Load(installersToUse);

            // 7. Sign up for installation events
            installManager.InstallerStatusUpdated += new EventHandler<InstallStatusEventArgs>(InstallManager_InstallerStatusUpdated);
            installManager.InstallCompleted += new EventHandler<EventArgs>(InstallManager_InstallCompleted);

            foreach (InstallerContext installerContext in installManager.InstallerContexts)
            {
                string failureReason;
                installManager.DownloadInstallerFile(installerContext, out failureReason);
            }

            // 8. Install products first
            installManager.StartInstallation();
            while (!_installCompleted) ;
            _installCompleted = false;

            // 9. At this point all products in ProductManager are downloaded, so we can set parameters on the application
            // NOTE: you cannot set application parameters, before it is downloaded
            // in this case, the language of the Web Deploy package does not matter, since it is not displayed in the UI
            Installer appInstaller = customApp.GetInstaller(english);
            foreach (DeclaredParameter declaredParameter in appInstaller.MSDeployPackage.DeclaredParameters)
            {
                // set values of parameters that do not have default values
                if (string.IsNullOrEmpty(declaredParameter.DefaultValue))
                {
                    appInstaller.MSDeployPackage.SetParameters[declaredParameter.Name] = "New Value";
                }
            }

            // 10. Then install applications (because application might have product dependencies, but not vice versa)
            installManager.StartApplicationInstallation();
            while (!_installCompleted) ;

            Console.ReadKey();
        }

        private static void AddProductWithDependencies(Product product, List<Product> productsToInstall)
        {
            // avoid duplicates 
            if (!productsToInstall.Contains(product))
            {
                productsToInstall.Add(product);
            }

            // GetMissingDependencies will check whether any dependencies are not installed for the product
            // AND are not already added to the install list (productsToInstall)
            ICollection<Product> missingDependencies = product.GetMissingDependencies(productsToInstall);
            if (missingDependencies != null)
            {
                foreach (Product dependency in missingDependencies)
                {
                    AddProductWithDependencies(dependency, productsToInstall);
                }
            }
        }

        private static void InstallManager_InstallerStatusUpdated(object sender, InstallStatusEventArgs e)
        {
            Console.WriteLine(e.InstallerContext.ProductName + ": " +
                              e.InstallerContext.InstallationState + ". " +
                              e.InstallerContext.ReturnCode.DetailedInformation +
                              "Progress: " + e.ProgressValue.ToString());
        }

        private static void InstallManager_InstallCompleted(object sender, EventArgs e)
        {
            Console.WriteLine("Installation completed");
            _installCompleted = true;
        }
    }
}

Sniffer.Installer.Reporter (SIR) for Application Gallery

kateroh — Mon, 25 Jan 2010 22:15:00 GMT

SIR stands for Sniffer, Installer and Reporter which comprise the three components of the tool’s validation workflow.

Application Gallery SIR is a tool that can be used to validate Application Gallery packages, which have to be valid Web Deploy packages and also comply with Requirements before submission to Application Gallery using the submission form. The steps to package an application for Windows Web Application Gallery are listed here. When a developer wants to submit a Web Application to the Application Gallery, SIR would help validate the package.

Download

The SIR command-line executable requires the Microsoft Web Deployment Tool RTW version to be installed on the machine. A machine running IIS is required if you would like SIR to install the application package using Web Deploy. SIR web application requires .NET Framework 3.5.

Here is the list of all the resources used in this blog:

AppGallerySIR.dll (zip) – API library for extensible solutions
SIR command line tool (msi) – command line tool
SIR web application (Web Deploy zip package) – ASP.NET web application
Web PI custom feed to install web application and command line tool (xml)

For any issues in using this tool, please contact Web Application Gallery Tools – SIR.

Feature Highlights of SIR

SIR comprises of the following features

Validation Conformance to Application Gallery Guidelines

Validates the package for a common set of Web Deploy providers used in all application gallery packages.
Validates the package for a valid set of tags for each parameter.

Support for Features NOT in Web Deploy

Validation of the hand-created Web Deploy parameters.xml file against a schema file.
Validation of parameter entries inside of parameters.xml. Web Deploy applies parameter values at package install time. SIR provides validation of parameter entries before installation.

Other Cool Features

Generation of the humongous Web Deploy command-line automatically based on the package content so users can run the install directly using Web Deploy.
Installation of an actual valid package if IIS is present on the box. This can be configured to be skipped.
SIR can work against multiple packages in a folder and generate corresponding reports.
SIR can also work against a zip package specified by a URL.
SIR generates a detailed xml report with corresponding success or failure messages to help the package creator fix errors in his package before submission to the Application Gallery.

Implementation

The core functionality of SIR is implemented in AppGallerySIR.SIR namespace inside AppGallerySIR.dll that ships inside the SIR installer.

AppGallery.SIR namespace contains a couple of essential API functions in PackageValidationManager class
public int ValidatePackage(string packagePath)
ValidatePackage expects either a physical path to the package to test or a URL. If a URL is passed, the package will be downloaded to a temporary location. Then the package will be unzipped to a temporary location and validated.
public int ValidatePackages(string folderPath)
ValidatePackages expects a path to a folder containing zip packages. This method will validate all files with a .zip extension for validity.

ValidatePackages internally calls ValidatePackage which does the following operations in sequence

Sniff

(i) Initializes the package using the Microsoft Web Deployment Object

(ii) Unzips the package to %temp% directory on disk.

(iii) Verifies if parameters.xml file is present and if it is consistent with parameters.xsd schema

Verifies if parameters.xml contains valid Web Deploy recognized tags.
Validates each parameter entry for correct declaration and proper substitution before install.

(v) Verifies if manifest.xml file exists

Install

Once the Sniffer returns successfully, ValidatePackage does the following

(i) The package is installed on a machine running IIS.

(ii) Dump ACLs on the package.

Report

(i) Finally, a report is generated as an xml file. This report contains elements like the SHA-1, MD5 hash of the package as well as a command-line to install the package.

Cleanup

The temporary files and directories are deleted.

SIR Command Line (SIRCommandLine.exe)

The SIR installer contains an implementation of the command line tool, which is a simple console application, that uses the AppGallerySIR dll. Here, all the settings can be set either through the application configuration file or directly through command line arguments. Here is a set of examples that can help get started with validating a package using the SIRCommandLine.exe

a) Display command-line help

SIRCommandLine.exe /?

b) Validate a package

SIRCommandLine.exe –source:"d:\package.zip"

The command unzips package to a temporary location (%temp%, configurable in SIRCommandLine.exe.config) on disk, validates the package and writes a report in the form of an xml in the current folder (eg. Joomla_11-41_AM.xml)

c) Skip installation of the package to IIS

SIRCommandLine.exe –source:"d:\package.zip"” –skipInstallation:true

d) Change the file name and folder of the report generated

SIRCommandLine.exe –source:"d:\package.zip" –reportFileName:"report.xml" –reportFolder:"d:\FolderName"

e) You can configure the above and many other parameters using configuration SIRCommandLine.exe.config.

f) SIRCommandLine.exe also returns the following error codes.

(i) 1 – if package is valid

(ii) 0 – if package has some errors

(iii) -1 – if there application/setting error

SIR Web Application

The SIR Web application is a sample application that also runs over AppGallerySIR.dll and validates package(s). The main page provides controls for validating packages and reporting results.

For the ease of installing the application, here is a Web PI custom feed that will help you install the web application. Here is a separate blog with a step-by-step instructions on how to install SIR web application and command line tool using this Web PI custom feed.

Below is a screenshot of the SIR web application with a sample report.

SIR APIs

You can perform custom validation of a package using AppGallerySIR.dll. An example is provided below.

using System;
using AppGallery.SIR;

namespace SampleSIRValidation
{
    class Program
    {
        static void Main(string[] args)
        {
            PackageValidationManager packageValidationManager = new PackageValidationManager();

            // 1. point location of parameters.xsd
            packageValidationManager.ParameterSchemaFile = @"%systemdrive%\inetpub\wwwroot\SIR\Parameters.xsd";

            // 2. location of xml report to generate
            packageValidationManager.Reporter.ReportFolder = @"d:\Reports";

            // 3. skip installation on IIS
            packageValidationManager.SkipInstallation = true;

            // 4. sign up for validation events
            packageValidationManager.ValidationStatusUpdated += new PackageValidationManager.ValidationStatusUpdatedHandler(packageValidationManager_ValidationStatusUpdated);
            packageValidationManager.ValidationCompleted += new PackageValidationManager.ValidationCompletedHandler(packageValidationManager_ValidationCompleted);

            // 5. validate the package
            packageValidationManager.ValidatePackage(@"D:\myApplicationGalleryPackage.zip");

        }

        private static void packageValidationManager_ValidationStatusUpdated(object sender, StatusUpdatedEventArgs e)
        {
            Console.WriteLine("Validation status updated: " + e.ValidationEvent.Message);
        }

        private static void packageValidationManager_ValidationCompleted(object sender, ValidationCompletedEventArgs e)
        {
            Console.WriteLine("Validation result: " + e.Result);
        }
    }
}

The equivalent command-line for the API implementation above is

SIRCommandLine.exe -skipInstallation:true -reportFolder:d:\Reports -ParameterSchemaFile:%systemdrive%\inetpub\wwwroot\SIR\Parameters.xsd -sourcePath:D:\myAppGalleryPackage.zip

Future of SIR

We plan to eventually integrate SIR with the Application Gallery’s application submission process. Future versions of SIR will be aligned with the requirements of newer versions of the Web Deployment Tool and the Web Application Gallery.

Ackowledgements

We would like to thank Dave, Nitasha and the Application Gallery team for their support and feedback.

Thanks,

Yamini and Katerina

Install SIR Web Application with Web PI

kateroh — Mon, 25 Jan 2010 22:13:00 GMT

SIR is a tool to validate Application Gallery packages. SIR comes in three different flavors, a dll, command-line tool and a web application. To read more about the dll and command line usage, you can refer to this blog. In this blog, you will learn how the same validation can be done using a one page web application. Similar to other Application Gallery packages, this web application is packaged into a zip file using Web Deploy technology. Similar to the SIR command line tool, this web application runs on top of the AppGallerySIR.dll that contains all important validation methods and outputs the results back on the screen. Below are the step by step instructions on how to install this web application in a few clicks and start validating your Application Gallery packages, existing or new.

Web Platform Installer (Web PI) will help us install the package through a custom feed.

1. Open Web PI and go to the Options dialog.

2. In the Options dialog, add the following feed: http://blogs.iis.net/blogs/kateroh/SIR/SIRWebPIFeed.xml

3. A new tab called “Application Gallery Tools” will show. Follow the “Customize” link, select “SIR Web Application” and click to install. Note that if you will choose to install the command line tool as well, it will get installed under %ProgramFiles%\SIR on a 32-bit machine or under %ProgramFiles(x86)%\SIR on a 64-bit machine.

4. This web application requires Web Deploy v1.0 and .NET Framework 3.5 SP1, since validation uses AJAX calls to validate packages. Web PI will install these dependencies for you, if you don’t have them installed yet.

5. On the parameters page, choose the physical path for your application. This is required for your configuration in web.config to be updated accordingly.

6. Now application is successfully installed. Click “Launch” to launch the application in the browser or browse to the application’s default.aspx page. The page is ready to validate your packages either through a physical path to the package or a URL.

If you need to configure the proxy for URL validations, uncomment and tweak the lines below in web.config

<system.net>
   <defaultProxy>
      <proxy proxyaddress="your-proxy-name.domain.com:port-number-if-any" bypassonlocal="True" autoDetect="False" />
   </defaultProxy>
</system.net>

Refer to web.config for all SIR related configuration.

NOTE: in order to successfully validate the packages, application pool identity for this application should have Read/Write permissions for the following settings defined in web.config:

<appSettings> 
   <add key="reportFolder" value="<..>" /> 
   <add key="logFolder" value="<..>" /> 
   <add key="unzippedFolderLocation" value="<..>" /> 
</appSettings>

During the install time, these settings will be set to the physical path of your application. If the application pool identity already has permissions to this location, no additional step of setting ACLs is required.

7. Here is a sample report from the web application:

Web PI Options Dialog

kateroh — Wed, 04 Nov 2009 22:16:00 GMT

As many of you already know, version 2 RTW of Web Platform Installer released in September. So what’s new in this version since RC that was released in March? First of all, Web PI now caches downloaded installers. Second of all, Web PI now supports 9 additional languages – German, French, Spanish, Russian, Italian, Japanese, Korean, Traditional and Simplified Chinese. This language support extends to both displaying Web PI UI in the language of the current OS locale and installing a product (if available) in the language specified by the user. Finally, the last biggest feature of RTW is extensibility.

All the new features are surfaced through the Options dialog, which is also new in RTW. Here is a list of new features surfaced through the dialog:

Additional scenarios
Extensibility
- installing custom products
- installing custom applications
Localization
Installer caching

Some of these features are rather too big to include them in one article and are described separately through the links provided in each title. Thus, this article will cover only the remaining features surfaced through the Options dialog

Installer caching, and
Resetting the options

Installer Caching

In previous versions of Web PI, if installation fails for some reason and the user has to start installation again, Web PI would have to download the selected product again in order to start installation. This version of Web PI caches downloaded products in case it would want them again. Thus, every time you install something it gets cached under

%LocalAppData%\Microsoft\Web Platform Installer\installers

If installation fails, you can always run the cached installer that is likely to have a UI that might surface the errors better. Also, if you want to install the same set of products on a different machine, you can just copy the installer cache folder to that machine to the same location and Web PI will pick it up. No worries if an installer gets updated for a product, since Web PI will compare the time stamps and download the newer file when you request to install the product again. The size of the cache is always shown in the dialog. If it gets too big or you don’t find it useful anymore (everything installs fine), you can clear the cache by clicking on “Delete installer cache folder” hyperlink.

Resetting the options

From the command line you can launch Web PI with a /reset switch that will restore your options to the default state:

"%ProgramFiles%\Microsoft\Web Platform Installer\WebPlatformInstaller.exe" /reset

Enjoy the new set of features in Web Platform Installer and please provide your feedback to help us make the product serve your needs better!

Web PI Additional Scenarios: Media and Developer Tools

kateroh — Thu, 29 Oct 2009 22:18:00 GMT

Web Platform Installer now offers a set of Media and Azure products that are not included in the set of Web PI products by default. These additional scenarios can be enabled through the options dialog:

Options dialog is a new RTW dialog that allows enabling the additional scenarios among other new features:

Media Platform offers a set of products and services to enable a server side story of the HD smooth streaming. To include all Media products, check “Media” and click Ok. The new tab “Media Platform” will appear in Web PI that will offer a full set of Media Products offered up to the date. The following set of products is available so far (together with Expressions Encoder that is available from Media Content pillar):

For additional Developer Tools products the following products are offered:

Windows Azure Tools for Microsoft Visual Studio
Expressions Web 3 Trial

Windows Azure Tools for Visual Studio enables web application development on Windows Azure Platform. It is one of the offered Windows Azure Developer SDKs. Expressions Web 3 is a WYSIWYG HTML editor for faster and easier design of web sites.

To enable a set of products under Developers Tools, enable Developers scenario through the Options dialog.

Now you can install any additional Media or Developers Tools product with a full-blown Web PI experience, where Web PI pulls in the dependencies for you and checks for incompatibilities with already installed products.

These are the “extra” products offered by Web PI in additional scenarios: Media and Developer Tools scenarios. Stay tuned for more products and updates!

Web PI Localization

kateroh — Thu, 29 Oct 2009 18:36:00 GMT

Version 2 RTW of Web Platform Installer, released in September, now not only comes localized in 9 languages - English, German, French, Spanish, Russian, Italian, Japanese, Korean, Traditional and Simplified Chinese, but also supports installations of products in supported languages. Now, users can choose the language in which they want Web PI to install the products. Though, not all products are localized in all 9 languages. Those products that are not available in the language selected by the user or not localized at all, will be offered in English.

This article will talk about the following:

With extensibility added to Web PI story, the users will also be able to install custom products in different languages. To read about extensibility refer to the following articles:

The display language of Web PI UI

If your system display language is one of the nine Web PI supported languages, Web PI will automatically show up translated in your display language. To change or install a display language (Vista and above) go to Control Panel-->Regional and Language Options-->Install or Uninstall display languages, install a display language from the original installation CD, restart the machine and enjoy your operating system in your preferred language… along with Web PI localized in the same language, given it is one of the supported languages.

The language of products

Now, Web PI offers products that are available in more than one language. However, not all products are available in multiple languages and not all products that support more than one language, support all other 9 Web PI supported languages. Below is the matrix of products offered with Web PI v2 RTW and languages these products are localized in.

Title	French	Spanish	German	Japanese	Korean	Simplified Chinese	Traditional Chinese	Italian	Russian
Administration Pack 1.0	x	x	x	x
Application Request Routing 1.0	x	x	x	x
Database Manager 1.0	x	x	x	x
External Cache 1.0	x	x	x	x
FTP Publishing Service 7.5	x	x	x	x
PowerShell Snap-in For IIS7 1.0	x	x	x	x
IIS Media Services 2.0	x	x	x	x
Remote Admin Manager for IIS7 1.0	x	x	x	x
Silverlight 3 Tools for Visual Studio	x	x	x	x	x	x	x	x
SQL Server Express 2008 with Service Pack 1	x	x	x	x	x	x	x	x	x
SQL Server 2008 Express with Advanced Services	x	x	x	x	x	x	x	x	x
SQL Server 2008 Express with Tools	x	x	x	x	x	x	x	x	x
SQL Server 2008 Management Studio Express	x	x	x	x	x	x	x	x	x
Web Deployment Tool 1.0 RC	x	x	x	x	x	x	x	x	x
Visual Web Developer 2008 Express with SP1	x	x	x	x	x	x	x	x	x
WebDav 7.5	x	x	x	x
Web Farm Framework 1.0	x	x	x	x
URL Rewrite 1.1	x	x	x	x

To make Web PI offer products in a language other than English, go to Options dialog and select the language for your installations:

Once you choose a language other than English for your installations, Web PI UI will show you the same set of products with the only difference, that those products that are not available in the language you have chosen, will have “(English)” next to their title suggesting that if you pick those, they will install in English.

Custom products and localization

It was briefly covered in previous articles about extensibility, how to make a custom product localizable in more than one language. Let’s take a sample feed from that article and get it localized.

In the example below, SampleProduct is localized in Italian – both in display language and installer. Note, how you have to add a unique (across all Web PI) resource name id to each element you want to translate: resourceName="" and then reference it in your translation xml.

<?xml version="1.0" encoding="utf-8"?>

<feed xmlns="http://www.w3.org/2005/Atom">
  <version>1.0.0</version>
  <title>Sample Product WebPI v2 RTW Feed</title>
  <link href="http://www.contoso.com/SampleProductFeed.xml" />
  <updated>2009-9-29T16:30:00Z</updated>
  <author>
    <name>Sample Product Builder</name>
    <uri>http://www.contoso.com</uri>
  </author>
  <id>http://www.contoso.com/SampleProductFeed.xml</id>

  <resourcesList>
    <resources>
      <culture>en</culture>
    </resources>
    <resources>
      <culture>it</culture>
      <url>http://www.contoso.com/SampleProduct_it.xml</url>
    </resources>
  </resourcesList>
  
  <entry>
    <productId>SampleProduct</productId>
    <title resourceName="Entry_SampleProduct_Title">Sample Product</title>

    <summary resourceName="Entry_SampleProduct_Summary">Just summary</summary>
    <longSummary resourceName="Entry_SampleProduct_LongSummary">Long summary of SampleProduct</longSummary>
    <productFamily>Sample Products</productFamily>

    <version>1.0.0</version>
    <images>
      <icon>c:\SampleProductIcon.png</icon>
    </images>
    <author>
      <name>Sample Product Builder</name>
      <uri>http://www.contoso.com</uri>
    </author>
    <published>2009-9-29T12:30:00Z</published>
    
    <!-- How can WebPI know your product is installed? -->
    <discoveryHint>
      <or>
        <!-- 1. Through registry (version value should be 1.0.0, if dont care about the verion, should be just keypath) -->
        <discoveryHint>
          <registry>
            <keyPath>HKEY_LOCAL_MACHINE\SOFTWARE\SampleProduct\Sample Product Version 1.0.0</keyPath>
            <valueName>Version</valueName>
            <valueValue>1.0.0</valueValue>
          </registry>
        </discoveryHint>
        <discoveryHint>
          <file>
            <!-- 2. Through filepath - if the exe is at this location, WebPI will know that SampleProduct is installed -->
            <filePath>%ProgramFiles%\SampleProduct\SampleProduct.exe</filePath>
          </file>
        </discoveryHint>
      </or>
    </discoveryHint>

    <!-- 
         What products need to be installed first? 
         Define dependencies through ProductId property of products
         declared in the main WebProductList file or other previously 
         added feeds 
    -->
    <dependency>
      <productId>IISManagementConsole</productId>
    </dependency>

    <!-- SampleProduct cannot be installed if product IncompatibleSampleProduct is already installed -->
    <incompatibilities>
      <incompatibleProduct>
        <productId>IncompatibleSampleProduct</productId>
      </incompatibleProduct>
    </incompatibilities>

    <!-- 
         installers and installer commands. Here you can define separate installers for
         different architectures, OSes, SKUs and languages
    -->
    <installers>
      <installer>
        <!-- installer Id should be unique for every SampleProduct installer -->
        <id>1</id>

        <!-- English installer -->
        <languageId>en</languageId>

        <!-- same English installer for both x86 and x64 -->
        <architectures>
          <x86 />
          <x64 />
        </architectures>

        <!-- 
             list of OSes and SKUs this product can be installed on. On every OS/SKU that is not 
             supported, the product will not display 
        -->
        <osList>
          <os>
            <!-- the product is supported on Vista/Windows Server SP1 + -->
            <minimumVersion>
              <osMajorVersion>6</osMajorVersion>
              <osMinorVersion>0</osMinorVersion>
              <spMajorVersion>0</spMajorVersion>
            </minimumVersion>

            <!-- list of SKUs -->
            <osTypes>
              <Server />
              <HomePremium />
              <Ultimate />
              <Enterprise />
              <Business />
            </osTypes>
          </os>
        </osList>

        <!-- before the user will install the product, the link to the following EULA will be presented -->
        <eulaURL>http://www.contoso.com/eula.html</eulaURL>

        <!-- this info is important for WebPI to verify that the downloaded file was not tampered -->
        <installerFile>
          <!-- size in KBs -->
          <fileSize>1024</fileSize>
          <installerURL>http://www.contoso.com/SampleProduct_EnglishInstaller.msi</installerURL>
          <sha1>111222FFF000BBB444555EEEAAA777888999DDDD</sha1>
        </installerFile>

        <!-- how should WebPI install your product? -->
        <installCommands>
          <msiInstall>
            <msi>%InstallerFile%</msi>
          </msiInstall>
        </installCommands>
      </installer>

      <!-- x64 architecture installer -->
      <installer>
        <!-- installer Id should be unique for every SampleProduct installer -->
        <id>2</id>

        <!-- Italian installer -->
        <languageId>it</languageId>
        
        <!-- same Italian installer for both x86 and x64 -->
        <architectures>
          <x86 />
          <x64 />
        </architectures>

        <osList>
          <os>
            <!-- the product is supported on Vista/Windows Server SP1 + -->
            <minimumVersion>
              <osMajorVersion>6</osMajorVersion>
              <osMinorVersion>0</osMinorVersion>
              <spMajorVersion>0</spMajorVersion>
            </minimumVersion>

            <!-- list of SKUs -->
            <osTypes>
              <Server />
              <HomePremium />
              <Ultimate />
              <Enterprise />
              <Business />
            </osTypes>
          </os>
        </osList>

        <!-- before the user will install the product, the link to the following EULA will be presented -->
        <eulaURL>http://www.contoso.com/eula.html</eulaURL>

        <!-- this info is important for WebPI to verify that the downloaded file was not tampered -->
        <installerFile>
          <!-- size in KBs -->
          <fileSize>1024</fileSize>
          <installerURL>http://www.contoso.com/SampleProduct_ItalianInstaller.msi</installerURL>
          <sha1>111222FFF000BBB444555EEEAAA777888999DDDD</sha1>
        </installerFile>

        <!-- how should WebPI install your product? -->
        <installCommands>
          <msiInstall>
            <msi>%InstallerFile%</msi>
          </msiInstall>
        </installCommands>

      </installer>
    </installers>
  </entry>

  <!-- define a tab that contains SampleProduct -->
  <tabs>
    <tab>
      <pillarTab>
        <id>SampleTab</id>
        <name>Sample Tab</name>
        <description>My sample tab for my sample product</description>
        <pillar>
          <id>SampleProduct</id>
          <name>Sample Pillar</name>
          <description>Install sample product</description>
          <groupingId>SampleProductFamilyGrouping</groupingId>
          <recommended>
            <productId>SampleProduct</productId>
          </recommended>
        </pillar>
      </pillarTab>
    </tab>
  </tabs>

  <groupings>
    <grouping>
      <id>SampleProductFamilyGrouping</id>
      <!-- combine products based on their productFamily attributes -->
      <attribute>productFamily</attribute>
      <include>
        <item>Sample Products</item>
      </include>
    </grouping>
  </groupings>
</feed>

And SampleProduct_it.xml referenced in the resource list will have to look something like this:

<?xml version="1.0" encoding="utf-8"?>
<root>
  <data name="Entry_SampleProduct_Title" xml:space="preserve">
    <value>SampleProduct Title in Italian</value>
  </data>
  <data name="Entry_SampleProduct_Summary" xml:space="preserve">
    <value>SampleProduct Summary in Italian</value>
  </data>
  <data name="Entry_SampleProduct_LongSummary" xml:space="preserve">
    <value>SampleProduct Long Summary in Italian</value>
  </data>
</root>

Conclusion: to get all resource strings in your xml file localized, you need to point Web PI to another xml with all the translations. Resource section in resourceList of the first xml takes care of this. If you have your custom product available in more than one language, you can have a different installer for each of your supported language and hint Web PI with <languageId> element in your installer portion of the product definition, which installer to use for which language.

Web PI Extensibility: Custom Feeds – Installing Custom Applications

kateroh — Sat, 24 Oct 2009 04:13:00 GMT

One of the most important features of Web Platform Installer, version 2 RTW of which released in September, is that it surfaces web applications offered by Windows Web App Gallery. The Gallery is the place for open source apps that can be submitted through online submission process and be available through various sources, including Web PI, to millions of people. Both submission and admission is totally free, the application just needs to adhere to App Gallery Principles and be a Web Deploy zip package.

However, you don’t need to submit an app to the App Gallery to make Web PI install it for you. With a new feature that version 2 comes with – extensibility – deploying your custom application via Web PI becomes a piece of cake. This article will show you how to create a custom feed for Web PI to recognize your application and be able to install it.

All you need to start with this article is a Web Deploy zip package of your app and (optionally) an icon for the prettier UI display of your app.

Let the fun begin!

The feed below represents an example of how to add applications with ASP.NET/SQL and PHP/MySql dependencies, create a new tab and subtabs based on keywords, group products together and hint Web PI that your product is available in different languages. Please note that you have to define a new custom tab for your custom products, since they cannot be added to Web PI core tabs.

You can also download this feed from here or add it to Web PI by specifying this link: http://blogs.iis.net/blogs/kateroh/WebPI/SampleCustomAppsFeed.xml

<?xml version="1.0" encoding="utf-8"?>

<feed xmlns="http://www.w3.org/2005/Atom">
  <version>1.0.0</version>
  <title>Sample Applications for WebPI v2 RTW Feed</title>
  <link href="http://www.contoso.com/SampleApplicationsFeed.xml" />
  <updated>2009-10-5T16:30:00Z</updated>
  <author>
    <name>Sample Application Builder</name>
    <uri>http://www.contoso.com/</uri>
  </author>
  <id>http://www.contoso.com/SampleApplicationsFeed.xml</id>

  <!-- Sample ASP.NET & SQL app with dependencies -->
  <entry type="application">
    <productId>Sample_ASPNET_SQL_App</productId>
    <title>Sample ASP.NET and SQL application</title>
    <summary>ASP.NET and SQL application sample</summary>
    <longSummary>Sample ASP.NET and SQL to show how to add a feed with a custom ASP.NET application to WebPI and define all dependencies.</longSummary>

    <!-- Defines grouping for the application based on the keyword(s) -->
    <keywords>
      <keywordId>ASPNETApps</keywordId>
    </keywords>

    <version>1.0</version>
    <images>
      <icon>c:\SampleASPNETAppIcon.jpg</icon>
    </images>
    
    <updated>2009-10-5T18:30:02Z</updated>
    <published>2009-10-5T18:30:02Z</published>

    <author>
      <name>Sample Application Builder</name>
      <uri>http://www.contoso.com</uri>
    </author>
    
    <!-- Bring along SQLExpress, if it is not installed as a related/nice-to-have product, not a dependency -->
    <related>
      <relatedProduct>
        <productId>SQLExpress</productId>
      </relatedProduct>
    </related>

    <!-- 
         Minimum set of requirements/dependencies in order to successfully install the application: 
         WDeploy, SQL Management Objects and URL Rewrite.
    -->
    <dependency>
      <and>
        <dependency>
          <productId>SMO</productId>
        </dependency>
        <dependency>
          <productId>WDeployNoSMO</productId>
        </dependency>
        <dependency>
          <productId>UrlRewrite2</productId>
        </dependency>
      </and>
    </dependency>
     
    <!-- Installer for an application should be Web Deploy package -->
    <installers>
      <installer>
        <id>1</id>
        <!-- List of languages this package is localized in: English, Korean, Spanish, Traditional and Simplified Chinese -->
        <languageId>en</languageId>
        <languageId>ko</languageId>
        <languageId>es</languageId>
        <languageId>zh-tw</languageId>
        <languageId>zh-cn</languageId>

        <installerFile>
          <!-- size of the package in KBs -->
          <fileSize>1024</fileSize>
          <installerURL>http://www.contoso.com/SampleASPNETApplication.zip</installerURL>
          <displayURL>http://www.contoso.com/SampleASPNETApplication.aspx</displayURL>
          <!-- SHA of the package file for signature verification -->
          <sha1>1223334444555556666667777777888888889999</sha1>
        </installerFile>
        <helpLink>http://www.contoso.com/SampleASPNETApplicationForum.aspx</helpLink>
        <msDeploy>
          <startPage>
            <!-- start with a setup page rather than a default one -->
            <startPage>Setup.aspx</startPage>
          </startPage>
        </msDeploy>
      </installer>
    </installers>
  </entry>

  <!-- Sample PHP & MySQL app with dependencies -->
  <entry type="application">
    <productId>Sample_PHP_MySQL_App</productId>
    <title>Sample PHP and and MySQL application</title>
    <summary>PHP and MySQL application sample</summary>
    <longSummary>Sample PHP and MySQL to show how to add a feed with a custom PHP application to WebPI and define all dependencies.</longSummary>

    <!-- Display under PHPApps keyword subtab -->
    <keywords>
      <keywordId>PHPApps</keywordId>
    </keywords>

    <version>1.0</version>
    <images>
      <icon>c:\SamplePHPAppIcon.jpg</icon>
    </images>

    <updated>2009-10-5T18:30:02Z</updated>
    <published>2009-10-5T18:30:02Z</published>

    <author>
      <name>Sample Application Builder</name>
      <uri>http://www.contoso.com</uri>
    </author>

    <!-- Bring along SQLExpress, if it is not installed as a related/nice-to-have product, not a dependency -->
    <related>
      <relatedProduct>
        <productId>SQLExpress</productId>
      </relatedProduct>
    </related>

    <!-- 
         Minimum set of requirements/dependencies in order to successfully install the application: 
         PHP, WDeploy, SQL Management Objects, MySql Connector and URL Rewrite.
     -->
    <dependency>
      <and>
        <dependency>
          <productId>WDeployNoSMO</productId>
        </dependency>
        <dependency>
          <productId>PHP</productId>
        </dependency>
        <dependency>
          <productId>MySQLConnector</productId>
        </dependency>
        <dependency>
          <productId>UrlRewrite2</productId>
        </dependency>
      </and>
    </dependency>
    
    <!-- Installer for an application should be Web Deploy package -->
    <installers>
      <installer>
        <id>1</id>
        <!-- List of languages this package is localized in: English, Russian, French, German and Italian -->
        <languageId>en</languageId>
        <languageId>ru</languageId>
        <languageId>fr</languageId>
        <languageId>de</languageId>
        <languageId>it</languageId>
        
        <installerFile>
          <!-- size of the package in KBs -->
          <fileSize>1024</fileSize>
          <installerURL>http://www.contoso.com/SamplePHPApplication.zip</installerURL>
          <displayURL>http://www.contoso.com/SamplePHPApplication.aspx</displayURL>
          <!-- SHA of the package file for signature verification -->
          <sha1>1223334444555556666667777777888888889999</sha1>
        </installerFile>
        <helpLink>http://www.contoso.com/SamplePHPApplicationForum.aspx</helpLink>
        <msDeploy>
          <!-- Default page is a start page -->
          <startPage />
        </msDeploy>
      </installer>
    </installers>
  </entry>
  
  <!-- Tab definition -->
  <tabs>
    <tab>
      <keywordTab>
        <id>SampleApplications</id>
        <name>Sample Applications</name>
        <description>Select from sample applications:</description>
        
        <!-- Subtabs definitions -->
        <keywords>
          <keywordId>ASPNETApps</keywordId>
          <keywordId>PHPApps</keywordId>
        </keywords>
      </keywordTab>
    </tab>
  </tabs>

  <!-- Keyword/titles of subtabs to group apps with those keywords under -->
  <keywords>
    <keyword id="ASPNETApps">ASP.NET Apps</keyword>
    <keyword id="PHPApps">PHP Apps</keyword>
  </keywords>
</feed>

You can get a hash of your zip package, by using a free utility called File Checksum Integrity Verifier (FCIV) and running fciv.exe –sha <path to your zip package> from the command prompt.

Now, you can try the feed out by saving it locally or uploading it, opening the Options dialog and adding a feed through either a physical path or URL.

Note how applications are grouped based on keywords rather than product families like products do. Also, applications are grouped into keyword subtabs rather than group boxes (pillars for products). To read about adding a custom product through a custom feed refer to this article - Web PI Extensibility: Custom Feeds – Installing Custom Products.

Web PI Extensibility: Custom Feeds – Installing Custom Products

kateroh — Sat, 24 Oct 2009 04:09:00 GMT

As it was already mentioned in several articles about Web Platform Installer (Web PI), version 2 RTW of the product now offers extensibility as a part of its new set of features. Now, users can not only add additional Media and Developer Tools scenarios with a set of products not offered in Web PI by default, but also define and install their own products through Web PI. To add a new product to Web PI UI interface, you need to create a custom feed with some information for Web PI to parse and be able to display and later install products offered by your feed.

To make a product show up in the UI, you will need to define a new Web PI tab, pillar and product entities in the feed.

Here is sample XML that defines a Sample Product with a unique SampleProduct productId, that is grouped by Sample Products product family and put into a newly defined Sample Tab. Please note that you have to define a new custom tab for your custom products, since they cannot to be added to Web PI core tabs.

<?xml version="1.0" encoding="utf-8"?>

<feed xmlns="http://www.w3.org/2005/Atom">
  <version>1.0.0</version>
  <title>Sample Product WebPI v2 RTW Feed</title>
  <link href="http://www.contoso.com/SampleProductFeed.xml" />
  <updated>2009-9-29T16:30:00Z</updated>
  <author>
    <name>Sample Product Builder</name>
    <uri>http://www.contoso.com</uri>
  </author>
  <id>http://www.contoso.com/SampleProductFeed.xml</id>

  <entry>
    <productId>SampleProduct</productId>
    <title>Sample Product</title>

    <summary>Just summary</summary>
    <longSummary>Long summary of SampleProduct</longSummary>
    <productFamily>Sample Products</productFamily>

    <version>1.0.0</version>
    <images>
      <icon>c:\SampleProductIcon.png</icon>
    </images>
    <author>
      <name>Sample Product Builder</name>
      <uri>http://www.contoso.com</uri>
    </author>
    <published>2009-9-29T12:30:00Z</published>
    
    <!-- How can WebPI know your product is installed? -->
    <discoveryHint>
      <or>
        <!-- 1. Through registry (version value should be 1.0.0, if dont care about the verion, should be just keypath) -->
        <discoveryHint>
          <registry>
            <keyPath>HKEY_LOCAL_MACHINE\SOFTWARE\SampleProduct\Sample Product Version 1.0.0</keyPath>
            <valueName>Version</valueName>
            <valueValue>1.0.0</valueValue>
          </registry>
        </discoveryHint>
        <discoveryHint>
          <file>
            <!-- 2. Through filepath - if the exe is at this location, WebPI will know that SampleProduct is installed -->
            <filePath>%ProgramFiles%\SampleProduct\SampleProduct.exe</filePath>
          </file>
        </discoveryHint>
      </or>
    </discoveryHint>

    <!-- 
         What products need to be installed first? 
         Define dependencies through ProductId property of products
         declared in the main WebProductList file or other previously 
         added feeds 
    -->
    <dependency>
      <productId>IISManagementConsole</productId>
    </dependency>

    <!-- SampleProduct cannot be installed if product IncompatibleSampleProduct is already installed -->
    <incompatibilities>
      <incompatibleProduct>
        <productId>IncompatibleSampleProduct</productId>
      </incompatibleProduct>
    </incompatibilities>

    <!-- 
         installers and installer commands. Here you can define separate installers for
         different architectures, OSes, SKUs and languages
    -->
    <installers>
      <!-- x86 architecture installer -->
      <installer>
        <!-- installer Id should be unique for every SampleProduct installer -->
        <id>1</id>

        <!-- language of installer is English -->
        <languageId>en</languageId>

        <architectures>
          <x86 />
        </architectures>

        <!-- 
             list of OSes and SKUs this product can be installed on. On every OS/SKU that is not 
             supported, the product will not display 
        -->
        <osList>
          <os>
            <!-- the product is supported on Vista/Windows Server SP1 + -->
            <minimumVersion>
              <osMajorVersion>6</osMajorVersion>
              <osMinorVersion>0</osMinorVersion>
              <spMajorVersion>0</spMajorVersion>
            </minimumVersion>

            <!-- list of SKUs -->
            <osTypes>
              <Server />
              <HomePremium />
              <Ultimate />
              <Enterprise />
              <Business />
            </osTypes>
          </os>
        </osList>

        <!-- before the user will install the product, the link to the following EULA will be presented -->
        <eulaURL>http://www.contoso.com/eula.html</eulaURL>

        <!-- this info is important for WebPI to verify that the downloaded file was not tampered -->
        <installerFile>
          <!-- size in KBs -->
          <fileSize>1024</fileSize>
          <installerURL>http://www.contoso.com/SampleProduct_x86.msi</installerURL>
          <sha1>111222FFF000BBB444555EEEAAA777888999DDDD</sha1>
        </installerFile>

        <!-- how should WebPI install your product? -->
        <installCommands>
          <msiInstall>
            <msi>%InstallerFile%</msi>
          </msiInstall>
        </installCommands>
      </installer>

      <!-- x64 architecture installer -->
      <installer>
        <!-- installer Id should be unique for every SampleProduct installer -->
        <id>2</id>

        <!-- language of installer is English -->
        <languageId>en</languageId>

        <architectures>
          <x64 />
        </architectures>

        <osList>
          <os>
            <!-- the product is supported on Vista/Windows Server SP1 + -->
            <minimumVersion>
              <osMajorVersion>6</osMajorVersion>
              <osMinorVersion>0</osMinorVersion>
              <spMajorVersion>0</spMajorVersion>
            </minimumVersion>

            <!-- list of SKUs -->
            <osTypes>
              <Server />
              <HomePremium />
              <Ultimate />
              <Enterprise />
              <Business />
            </osTypes>
          </os>
        </osList>

        <!-- before the user will install the product, the link to the following EULA will be presented -->
        <eulaURL>http://www.contoso.com/eula.html</eulaURL>

        <!-- this info is important for WebPI to verify that the downloaded file was not tampered -->
        <installerFile>
          <!-- size in KBs -->
          <fileSize>1024</fileSize>
          <installerURL>http://www.contoso.com/SampleProduct_64.msi</installerURL>
          <sha1>111222FFF000BBB444555EEEAAA777888999DDDD</sha1>
        </installerFile>

        <!-- how should WebPI install your product? -->
        <installCommands>
          <msiInstall>
            <msi>%InstallerFile%</msi>
          </msiInstall>
        </installCommands>

      </installer>
    </installers>
  </entry>

  <!-- define a tab that contains SampleProduct -->
  <tabs>
    <tab>
      <pillarTab>
        <id>SampleTab</id>
        <name>Sample Tab</name>
        <description>My sample tab for my sample product</description>
        <pillar>
          <id>SampleProduct</id>
          <name>Sample Pillar</name>
          <description>Install sample product</description>
          <groupingId>SampleProductFamilyGrouping</groupingId>
          <recommended>
            <productId>SampleProduct</productId>
          </recommended>
        </pillar>
      </pillarTab>
    </tab>
  </tabs>

  <groupings>
    <grouping>
      <id>SampleProductFamilyGrouping</id>
      <!-- combine products based on their productFamily attributes -->
      <attribute>productFamily</attribute>
      <include>
        <item>Sample Products</item>
      </include>
    </grouping>
  </groupings>
</feed>

You can get a hash of your product, by using a free utility called File Checksum Integrity Verifier (FCIV) and running fciv.exe –sha <path to your file> from the command prompt.

To add a product from this feed to Web PI, save this text to an xml file. Then, go to the Options dialog (click Options link on the main window) and type the location of the xml file into the text box, click “Add feed” and close the dialog. You will see a new tab called “Sample Tab” that contains the grouping with the product – all defined in the xml above.

Below is a drill down of how your feed data is represented in the UI. The first screenshot shows how Web PI interprets tab and pillar feed elements.

To see how tabs group products based on their productFamily element, click on “Customize” link. The “Sample Products” group box represents a grouping by productFamily, to which Sample Product belongs. All other products with the same productFamily element would be grouped in the same group box.

To see product details, click on the small “i” icon next to the product title. Finally, the product details page shows all the details defined for the product itself. To install Sample Product, check “Install Sample Product” and click Install. Web PI will select an installer based on the current machine architecture and the language of the current UI culture (if such is available).

Note that the feed refers to an icon located at my local path c:\SampleProductIcon.png, the feed is also added from a physical location c:\SampleProduct.xml. Most likely, you will want to host this content somewhere and refer to it through URLs. Your feed is ready to go – you can publish it and let other people install your product through Web PI. Enjoy!

MSDeploy Custom Provider to execute batch files

kateroh — Fri, 19 Jun 2009 16:54:00 GMT

NOTE: All code and instructions in this blog post were updated to work with the latest version of Web Deploy v1.1. A blog post that outlines the changes that are required to custom providers in Web Deploy v.1.1 since Web Deploy v1 RC is here.

Overview

The IIS Web Deployment Tool (also known as MSDeploy) simplifies the migration, management and deployment of IIS Web servers, Web applications and Web sites. MSDeploy also offers the ability to run custom providers. These providers unlock hidden power in MSDeploy.

In this article you will find a sample code for a custom MSDeploy provider that executes batch file commands as a part of MSDeploy sync. The batch file provider can be used to execute custom scripts before or after deployment to make the deployment process a seamless one. You can set up performance counters for a particular MSDeploy sync, make a batch file copy content with xcopy rather than with MSDeploy (but remember that we’re faster than xcopy!) to name just a few possibilities. The code in this article is meant as a sample to get you started on writing your own custom MSDeploy provider. This provider is similar to MSDeploy runCommand provider with the exception that this custom provider does not have the full set of features the official MSDeploy runCommand provider does. In any case, the code is built thankfully to a great sample and blog that Yamini Jagadeesan wrote a couple of months ago on MSDeploy MySql custom provider that lets you sync from one MySql database to another. If you haven’t familiarized yourself with the article, it is a great read and another good start-up solution for MSDeploy custom provider.

Download and Install

First, download the zip file with the projects (also contains Yamini’s MySql custom provider). BatchProvider solution contains the following files:

BatchProviderFactory.cs – an entry point to your provider that kindly returns an instance of the provider in overridden CreateProvider method.
BatchProvider.cs – the provider itself that initiates execution of a batch file.
Strongname.pfx – the file with a key to sign the assembly for strong name verification. The password is “MSDeployRocks”, but you can delete the pfx file and specify your own key and password for singing the assembly by going to Project Properties-->Signing in Visual Studio.

To install the provider you need to

Compile the project (or just use this dll)
Create a folder called Extensibility under “%programfiles%\IIS\Microsoft Web Deploy”. This folder will contain all your MSDeploy custom providers
Drop the dll into the newly created folder

MSDeploy is ready to work with the new provider.

The Internals of BatchProvider

GetAttributes method is called on both source and destination to validate the object (think of performing a dump) without taking any action. If the object is invalid or if the object requires an action (in the example of the batch file provider, we need to run its commands in a shell program in a separate process), the method will throw a DeploymentException to make sure Add method is called. Finally, we want the code to take an action only when it is called on a destination object, which is insured by the following condition:
```
if (this.BaseContext.IsDestinationObject)
```
Add method insures that the object is valid. Think of this method as a “Make valid” method that requires an action, since it is called only on a destination object. Destination objects will always be the objects that require an action, since dump can be performed only on source objects. Which makes sense, because in the command line, dump can be performed only with –source switch:

msdeploy –verb:dump –source:<destination>
GetStream method is called when the source is getting synced to an archive directory (archiveDir provider) or a package (package provider). For example, this method will get called whenever the following commands are executed:

msdeploy –verb:sync –source:batch=”myBatchJob.bat” –dest:archiveDir=c:\backup
msdeploy –verb:sync –source:batch=”myBatchJob.bat” –dest:package=c:\backup.zip
msdeploy –verb:sync –source:manifest=”manifestWithBatchInIt.xml” –dest:package=c:\backup.zip

In GetStream method, the FileStream is returned, so that MSDeploy can attach a batch file to an archive or package as a simple text file.

You can tweak the provider to suit the task you have in mind. For example, you might want to tweak ProcessStartInfo of the process that will execute the batch file commands to control its behavior during sync. You might want to redirect output and error streams of the process to log the results of execution.

Please feel free to post any comments and questions.

Thanks to Yamini for pointing out these differences between MSDeploy versions.

Troubleshooting Common MSDeploy Issues

kateroh — Fri, 05 Jun 2009 16:28:00 GMT

This article is meant to provide a quick reference troubleshooting guide to help with the most frequently encountered problems and questions. It does not contain a full list of issues and problems, but will be updated with the latest issues and workarounds as the need arises.

Issues covered in this article:

Connection Issues and Remoting
Logging
Skip Replace Rules
Enabling/Disabling Link Extensions
Insufficient Privileges (401)
Working with IIS6
If None of the Above Works

Connection Issues and Remoting

MSDeploy agent

If you are syncing over the MSDeploy agent, make sure the corresponding MSDeploy service is started on the remote machine:

net start msdepsvc

Handler

(Web Management Service)

Similar to the agent case, if you are syncing over the handler, make sure the corresponding service is started:

net start wmsvc

Default TCP Port

MSDeploy operates through port 8172 by default. Enable port 8172 through the firewall by running

netsh firewall add portopening TCP 8172 WdeployAgent

Logging

Fatal errors are logged in %TEMP%\Web_Deployment_Agent_Service.log. Where %TEMP% refers to the service identity's temp folder which by default is Windows\ServiceProfiles\NetworkService\AppData\Local\Temp\MSDepSvc

Skip Replace Rules

If some destination settings are different from source settings (e.g. different system drives in file paths), you can write a skip replace rule to change the setting. Thus, if you sync an IIS6 site with the content that resides on c:\wwwroot\inetpub to another site that is mapped to d:\wwwroot\inetpub, you’d write the following replace rule to make the 1-liner sync possible:

msdeploy.exe -verb:sync -source:metaKey=/lm/w3svc/2 -dest:metaKey=/lm/w3svc/3 -replace:objectName=metaProperty,scopeAttributeName=name,scopeAttributeValue=path,targetAttributeName=value,match="e:",replace="d:"

An excellent resource for writing skip replace rules is the blog post: How to write skip and replace rules for MSDeploy

Enabling/Disabling Link Extensions

If you copy content of a webserver/site separately and don’t want it to be copied during your MSDeploy sync operation, you can do it by using -disableLink:ContentExtension command line option.

Example (sync one server to another w/o content):
msdeploy -verb:sync -source:webserver -dest:webserver,computerName=URLtoRemoteAgent

If you sync a site and its app pool is not pulled in (default behavior), you can enable pulling in the app pool by using the –enableLink:AppPoolExtension switch.

Example (create a backup of a site with app pool):
msdeploy -verb:sync –source:appHostConfig=”MySite” –dest:package=”c:\BackupUpOfSiteWithAppPool.zip” –enableLink:AppPoolExtension

Insufficient Privileges (401)

Things to check:

ACLs

If you are syncing as an IIS user, the content path that you are trying to access should be ACL’ed for read/write access for NT Service\WMSvc identity.

AppPoolIndentity

If you think you might have problems with app pool identity, try to run the app pool with admin privileges, see if the problem persists, fix permissions problem if necessary and set the app pool back its original identity.

Delegation Rules

If you are running a sync operation as a non-admin account, make sure delegation rules are set up correctly on the remote server. For example, to allow all users to import iisApp packages and set ACLs within user connection scope, add the rule below to "system.webServer/management" section in administration.config file.

<!-- set allowAdministrators to "false" if you don't want administrators to bypass delegation rules -->
<delegation allowAdministrators="false">
      <!--
      Will attempt to perform the operations as the current identity. 
      If you want to run these opearations as a specific user, uncomment "runAs" below
      -->
      <rule providers="iisapp,createapp,contentpath,setAcl" actions="*" path="{userScope}">
       <permissions>
       <user name="*" isRole="false" accessType="Allow" />
       </permissions>
       <!-- <runAs identityType="SpecificUser" userName="iisAppUser" password="iisUserPassword" /> -->
      </rule>
</delegation>

Another useful reference on automating the creation of delegation rules in C# is the following IIS.NET article: Configure the Web Deployment Handler

Server Certificates

How does your client validate server certificates?
- If you are running a command line and trust the server, specify the –allowUntrusted switch to accept untrusted certificates.
- If you wrote your own client to interface with MSDeploy APIs and sync to a remote machine, make sure to provide a certificate validation delegate to validate the server certificate.
Another great reference on the subject of certificate validation delegate is the MSDN article: Did you know... establishing a remote connection to a IIS server with self-issued certificate will require a certificate validation delegate?

Working with IIS6

MSDeploy does work with IIS. Moreover, MSDeploy can migrate a site from IIS6 to IIS7. Another excellent article about how to migrate a site from IIS6 to IIS7: Migrate from IIS 6.0 to IIS 7.0. Below are some important tips and tricks that will help you get around common problems.

Webserver Provider

To sync the whole IIS6 server, you need to user webserver60 provider instead of webserver, which is reserved for IIS7 servers

Specific Metabase Path

To sync a specific metabase path (a site or application), you need to use metakey provider

Site Identifiers

To specify a siteId for your metabase path, you need to find out what identifier your site/application has. Run the following command to list metabase paths:

adsutil enum /p w3svc
Microsoft (R) Windows Script Host Version 5.7
Copyright (C) Microsoft Corporation. All rights reserved.

[/w3svc/Info]
[/w3svc/Filters]

If None of the Above Works

Run your command with -debug switch and post your question on MSDeploy forum with the stack trace.

Hope this helps!

IIS Remote Manager for Windows 7 is out

kateroh — Tue, 02 Jun 2009 23:47:00 GMT

Last week, IIS Remote Manager was re-released to support Windows 7. Prior to this release, remote management was supported only on XP, Vista, Windows Server 2003 and Server 2008 (excluding Home Basic editions). Now, the users can install Remote Manager on Windows 7 Client to manage Server 2008 and Server 2008 R2 remotely.

Remote Manager is available for download on iis.net download center:

· IIS Manager for Remote Administration (x86)
· IIS Manager for Remote Administration (x64)

And also on microsoft.com:

· Internet Information Services (IIS) Manager

Finally, you can install IIS Remote Manager through Web Platform Installer:

Learn about Remote Manager:
· Remote Manager for Windows 2003, XP and Vista SP1