Come Get Some...Thoughts On Software Technology

IE 9 pinned mode and else demo page

Alex Strauss — Fri, 04 Mar 2011 11:53:56 GMT

Short revival of my blog with sharing a site I created to play a bit with the new taskbar features of Internet Explorer 9. After I realized that the site actually shows a good overview of most of the features described on the MSDN pinned site documentation with working samples I thought this might also be of interest to some other people. In addition it shows a bit about geo location (Thanks to Dariusz for his sample) and the new performance/navigation timing api which is currently being specified by a newly formed W3C Working Group.

Please remember however that most of the buttons only do what they are supposed to do when the site is actually in site mode (but you get informed about that anyway).

So have fun with it! http://www.level70.de/ie9demos/IE9Demos.html

The site was created by using the brand new web development tool from Microsoft called Web Matrix.

Do Enterprises Need An Independent Browser Strategy?

Alex Strauss — Tue, 25 May 2010 06:57:59 GMT

Microsoft Australia is currently driving a campaign where using Internet Explorer 6 is compared to drinking 9 year old milk. The by far biggest share of IE6 still used is in large enterprises. There are certainly many reasons why this is the case but in my opinion most of those reasons in one or another way are a direct result of specific circumstance which is

That Enterprises as well as small and medium businesses for the largest part do not have a browser strategy.

At least none that is independent from their client OS strategy. And the reason why most companies do not have an independent strategy is because Internet Explorer was shipped with Windows since Windows 98 with Internet Explorer 4 which is more than 12 years ago which again is centuries in IT terms. In addition, the importance of the browser as a productivity tool increased during those years with exponential rise over the last 5 or 6 years. Because of those circumstances many companies probably didn’t feel the urge to implement such an independent strategy. But because of not treating the browser as an independent part of the operating system most companies are still relying on Internet Explorer 6 which is already nine years old. In those 9 years however there were three different evolutionary streams. The first to name is the trend to implement more and more business applications as web applications which led to a huge amount of web applications within companies. And those were often optimized for the currently used browser (IE6). The second stream was the evolution of web technologies and web standards. The third stream was the growing number of attacks through web sites and also the growing numbers of attacking techniques including social engineering attacks. All three streams were heavily influenced and driven by the growing popularity and the rise of the web. So if you take this into account you could say that with the increase of the duration of usage of a specific browser version the ability to adapt and migrate decreases. This correlation is shown in the diagram below.

Critics now may say that this is all the fault of Microsoft because Microsoft is shipping IE together with Windows and Microsoft shipped IE6 flawed and forced the creation of web applications that introduced dependencies to those flaws. However those are reasons to from owns own complacency and indifference about treating the browser as an important productivity tool which needs to be treated like other mission critical applications or technologies in an enterprise. If Companies would have spent the browser the attention it deserved then there would have been plenty of opportunity to avoid the current situation because even Microsoft released two new browser versions which introduced great improvements in many browser relevant areas like security, standards, productivity features and performance compared to IE6. Those were released as stand-alone installers as well as part of Windows Vista or Windows 7. My theory is that they were simply neglected by enterprises because of a lacking independent browser strategy and omission. Although it seems like it I don’t want to scare anyone here because to be honest I think that the picture one my draw from the above would be way to negative because the ability to migrate will never be impossible and the efforts related to migration may be less than one would expect. I will elaborate about what I mean by that further down in this post.

Bottom line however is that the trends outlined above are some indicators that the browser is one of the most important tools in today's enterprise application landscape. This is not only my personal opinion but is also expressed by many respectable institutions and individuals. Forrester analyst Sheri McLeish for example said:

“Enterprises need to think about the browser as a productivity tool, not as a transparent application. They need to look at browsers more strategically.”

Another example is a citation of Andy Armagost, Birmingham Gas & Oil who said:

“The browser is one of the most important pieces of software we have right now”

And last but not least with ongoing increase of web applications, web services and especially now slowly starting move to cloud based services, the browser may become the single most important piece of software in the future. Which is a hypothesis that is also backed by Sheri McLeish:

“That IE6 is by far the most widely used browser among enterprises reflects most IT departments’ lack of interest in browsers. However, this laissez-faire approach toward browsers wouldn’t last long, he said. “The rise of software-as-a-service [SaaS] will force enterprises to at least come up with a browser strategy for their workforce”

With that all said it becomes obvious that - the time to act is now – it is time to do essentially two things:

Start realizing the importance of the browser for the own company and define a independent strategy for it
Start migrating to a current version of preferably Internet Explorer as it is still the best choice for deployment in corporate environments

I did not number these two tasks on purpose as they are probably almost equally important and because it is recommended to start doing both in parallel. As for the migration part still many companies, even those that may already have some kind of browser strategy discussion, are still in fear about the efforts and try to avoid the migration part. So I will try to give some, hopefully helpful, information on how one can get started, what else, apart from the above are the benefits of migration and about some determining factors relevant in the migration context.

Compatibility

I will not reiterate what has been said many times about compatibility and its various facets with respect to Internet Explorer 8. Although it is super important there are enough sources, including this blog, where you can find information about it. As a starting point you can go to my respective article or the compatibility center on MSDN. Here however I want to point out that there are different kinds of compatibility of which some are important to reflect about when planning a migration process and its accompanying decisions and some that may be less or maybe even useless when deciding about what’s important to solve one’s personal or corporate compatibility question:
1. Backward Compatibility or “Stand in for your heritage”
  
  Especially with an Internet Explorer focus I would define backwards compatibility as “Enabling correct functional execution and visualization of web applications created for previous versions of Internet Explorer and web standards”. Especially because of the fact that most companies are still sitting on back level browsers this is extremely important. And because this is so important Internet Explorer in particular lives up to the promise to provide a great deal of backwards compatibility by shipping with two rendering engines and compatibility modes. While probably still not the 100% solution to the compatibility questions it is a great relief for companies preparing for migration as this reliefs them from really touching applications and make real changes to the application assets (markup, styles and code)
2. Forward Compatibility
  
  I would define forward compatibility as “The Support of evolution of the web by endorsing and supporting current and upcoming specifications and actively participate in the definition of those standards”. Now this one is a bit tricky as we all don’t own a crystal orb to look trough into the future. However alone by the statements and the involved actions one can get at least some ideas about how friction free and smooth future migrations will become. Supportive for a positive perception with respect to forward compatibility I would count active participating in the standardization bodies, recommending new standards, early adoption of not yet settled standards, providing guidance on usage of standards, etc.
3. Artificial Compatibility
  
  Artificial compatibility or a compatibility that has been created and made popular as an benchmark thus creating a de-facto requirement of passing taking the benchmark in order to gain a positive perception. The problem with such an compatibility understanding is that they sometimes are not very helpful in or simply useless when taking the compatibility debate. One good example is the current ACID 3 test. There are many people out there thinking that the browser passing the test to 100% is the most standards compliant browser but this is not really the case as it only tests a subset of standards and it tests it upon the author’s interpretation of the specifications. And that there is much room for interpretation shows a simple example made by Ian Hickson, who is one of the editors of the HTML 5 specs at the W3C and maintainer of the Acid 3 test suite.
  
  “HTML 4 has an input element, which has a type="" attribute, which takes values like "text" and "checkbox." What should happen when you have an HTML input element with type="text" in a document is reasonably well defined: You display a text field.
  What should happen with input type="checkbox" is relatively well defined. However, with script, you can take the type="text" attribute, and change its value dynamically, while the user is editing the control, so that it is type="checkbox." This is not a common thing to do, and the HTML 4 and DOM2 HTML specs are completely silent on what should happen when this case is hit.
  
  The result is that different browsers do different things; IE will throw an exception, if I recall correctly, while Firefox will change the text field to a checkbox”
  
  There are other indications and statements that are quite a bit reserved to pay to much attention to those tests which I will spare here. For those interested just check out this or that. To sum it up I want to point out that I don’t say that tests such as Acid 3 are generally a bad thing but I think that just striving for the goal to pass a certain test and even optimize a product just to hit that target is a non goal and doesn’t help the web community in deciding which are the real important attributes are to solve the compatibility questions.
Some common misconceptions
1. Micro-Benchmark results are the key criteria to make browser choice decisions
  
  Micro-Benchmarks are without a doubt very popular at the moment. Especially those measuring JavaScript performance like the V8 Benchmark, Sunspider, Dromaeo or Peacekeeper are extremely popular nowadays. The only problem with them is that they are measuring only one tiny aspect of the whole browsing experience and therefore may be not sufficient to make an impartial browser decision. An attitude by the way that I’m not alone with. Jim Rapoza, Chief Technology Analyst at eWeek for example said:
  “Face it, right now all browsers are more than fast enough. And if you're running into slow performance on the Web, you should probably check about 100 other things (ISP performance, site problems, etc.) before you start wondering about browser speed.
  So why is every single browser maker spending so much time and resources trying to gain the mantle of fastest Web browser? I think it's because performance is the only non-subjective criteria that they can hang their hat on”
  
  Don’t get me wrong, Micro-Benchmark are important and give a good insight about the current state of a browsers script or rendering engines especially with more and more applications making heavy use of JavaScript however they shouldn’t be the only criteria to base one’s browser decisions on. I mean even we at Microsoft now are riding this horse with the latest announcements about the rework of the JavaScript engine in Internet Explorer IE9 and the performance shown already in the current technology previews of IE9. But still there is the belief that there is a superset of of criteria that need to be taken into account when thinking about browsers and the usage of web applications.
2. Specifications leave no room for interpretations
  
  I already gave an example about this further up in the compatibility section so here’s some more about that. A international standardization process is a complex beast. There are many parties involved (which is basically a good thing) but the more parties the more opinions and discussions. This is the reason that it takes a long time before standards are finally released and their specifications are complete and signed-off. So sometimes you need to rely and base your work (e.g. a browser) on unfinished specifications which may be unclear in certain aspects or may change over time. Think about CSS. There is still no final specification for CSS 2.1 available. And probably not only because of this Derek Featherstone, Group Lead Web Standards Project comes to the conclusion that:
  
  ”We don't even have a perfect implementation of CSS 2.1 yet”
  
  So its easy to say that one or the other browser is not implementing the specs correctly but with some insight it becomes obvious that there is not the one correct way and it is difficult for a browser provider to hit a moving target (unsettled specs).
3. Browser migration is different from other application migrations
  
  To be honest I have no real clue about were this misconception comes from but I know it is all around. In many cases I hear or feel a lack of comprehension about browser migration and the related efforts to assess the applications if they are still working as designed. However I think this is something that is quite common in today’s IT environments. Think about migrations of JDK’s, Application Server upgrades or Windows Client upgrades not to speak of upgrade of a large SAP installation. Those don’t come without migration efforts either and they are huge in many cases. Of course IT responsible complain about those efforts as well but there still is an acceptance or an understanding that this is something that needs to be done. In the context of browser there is a total lack of such an acceptance and often this then leads to not migrating at all up to the time where there is no other chance anymore. However not only the efforts necessary will increase over time as I already pointed out but also those company will miss some great opportunity as we will see in the next section.
Application classification

Let’s get a away from the philosophic and sometimes religious questions and get a bit more practical. If you plan a migration you are probably think about the right process or which are the right tasks. One important task within the process is to do some kind of application classification. As this also can give great insight into what the overall migration efforts actually will be it should happen very early in the process. Of course there are many different ways to classify applications and there may also be quite some company specific, internal classification factors. Nevertheless I will try to give a generic views on how to classify and estimate the efforts. Base for this classification is the source of the application or in other words the producer and how much it has been customized. As seen in the following figure the complexity and efforts of a migration increases with the customization level in combination with the sources moving from internal to external.

Important to note is that this not only considers technical factors but also includes organizational and feasibility factors. For example an application from an external source may be harder to migrate because the VAR/VAP or ISV may not even exist anymore. This is especially important for application including binary components such as ActiveX controls. On the other hand if a web application is based on an ISV product that has not been customized the effort may be near to nothing because the ISV already has official support for current browsers.
After doing this classification there is then the chance to prioritize which applications to migrate first and which can be eliminated completely. So a quadrant model for this prioritization could look like the one I depict in the following figure.

The most important take away from this in my opinion is that you shouldn’t look at browser migration in the context of cost only but also in the context of opportunity to create a comprehensive web application inventory which many enterprises still lack today, streamline the web application landscape and increase value and productivity through innovation by using new features and standards not available or supported with older browsers.
Migration Guidance & generic process

So now I can get to the final guidance and outline a generic process for a browser migration. As it is quite generic and of course doesn’t touch any specifics of a certain vertical or even individual enterprise it looks quite simple but yet it is a good starting point to refine it and adapt it to the individual company.

A lot of text now simply to explain why I think that companies should

treat the browser as a mission critical application
define an independent strategy for it
realize that its time to migrate to a current browser
start migrating to Internet Explorer 8 today as it is probably still the best choice for enterprise IT-Environments because of its
- Standards compliance
- Compatibility features
- Deployment options (IEAK, Slipstreaming, WSUS, AD, SCCM)
- Group Policy customizability
- Unique security features (protected mode, domain model, etc.)

So hopefully I created some awareness and the thoughts I tried to express about this, certainly very complex, topic was understandable, a bit helpful and created a sense of urgency to ACT NOW then I reached my goal for this post. And finally the answer to the question if enterprises need an independent browser strategy is definitely “YES”.

As always feel free to comment and start a discussion.

A Few IE8 Tips for Developers And IT-Professionals

Alex Strauss — Tue, 25 May 2010 06:55:53 GMT

Use the WebSlice title for dynamic user related content

The only information of a WebSlice that is visible while normal usage of the browser is the caption of the button in the favorites pane. This caption is provided by an HTML portion which is annotated with the keyword entry-title in the WebSlice's update source. So this is a valuable piece of information present all time in the Internet Explorer Chrome. So it is recommended to use it more wisely than to only display static text. So rather update the title with meaningful information. One good example could be to display the current points balance of a loyalty program.

Simply add a dynamic <span>-Element which may even be hidden to a personalized web page template, mark this dynamic piece as the entry-title and your done. It doesn’t matter if this is the main webpage of the respective provider or a specially created one as alternative display source for the web slice. Whenever the account balance changes this data is then automatically promoted into this page dynamically. With the next update check of IE the current balance is then shown in the caption of the WebSlice button in bold letters.

WebSlice Tracking

Usage tracking of WebSlices is actually quite easy however there is a thing to remember. Internet Explorer checks for new WebSlice content in certain intervals. This interval is either defined by the WebSlice provider in the WebSlice content using the ttl-property or the user trough the WebSlice properties dialog or it defaults to 24 hours. Now when this interval passes the Internet Explorer 8 sends a request to the update source of the WebSlice through the Windows RSS Platform subsystem. This means that in the case of update checks for WebSlices is not Internet Explorer and thus also the user-agent string differs from the one for regular IE website requests. The user-agent string for those requests is:

User-Agent: Windows-RSS-Platform/2.0 (MSIE 8.0; Windows NT 6.1)

So you could use this user-agent string for tracking WebSlice usage however you need to know that simply checking for updates doesn’t imply really that the content is also recognized by the user. If you want to have real usage tracking you probably should use the commonly used website tracking scripts or tracking pixels methods and integrate them into the entry-content portion of your WebSlice and in addition if you have the possibility to alter the Headers of your HTTP-Response you should disable client side caching. If you implement it like that and know the update frequency you can easily calculate the real usage of the slice.

All Requests – Update checks in analyzing timeframe = Real usage/Real WebSlice impressions

Even better would be to include all that in an alternative display source. This will give you the right usage numbers instantly as the display source is not requested when Internet Explorer checks for updated content. So this alternative content is only requested (and this time by IE with the original IE8 user-agent string) when the user clicks on the WebSlice button and opens the fly out.

Text fields in Accelerator Previews and WebSlice display sources

As you may already know you can use an accelerator preview window and and WebSlice fly out to display rich and/or interactive content. So you can for example use Silverlight based applications to deliver great user experiences through those IE features and increase value and stickiness of your content. There is however at least one area where the WebSlice fly out behaves differently from the accelerator preview window and this is the use of text fields or textboxes. While you can use those as usual in WebSlices you shouldn’t in accelerator previews as the keyboard inputs are captured by the context menu where you chose the accelerator from and are not forwarded to the accelerator preview and thus the user is unable to type text into the text field. This behavior is technology agnostic and will occur in plain HTML as well as in Silverlight or Flash applications. So it needs a little bit of intelligent information design for accelerators to allow a user to provide feedback via meaningful and clickable elements (e.g. instead of letting the user type a location let him choose from a list or make some guesses based on the present context).

Identifying IE8 when compatibility mode is active

It is already commonly known that Internet Explorer 8 ships with two rendering engines and allows website owners and users to enable a compatibility mode. So Internet Explorer 8 can be forced to behave like an Internet Explorer 7 by switching to the IE7 browser mode. As this needs to be a complete back level switch IE8 then also identifies as IE7 in its user-agent string. This is also true for querying the Window.navigator.appName, Window.navigator.appVersion and Window.navigator.userAgent properties using JavaScript. So if you rely on correctly identifying IE8 although the browser is currently operating in compatibility mode (for example you want to offer a customized IE8 download to users using older browsers) you need to change your identifying code a little bit and query the Document.documentMode Property which is only available in Internet Explorer 8 (and probably in IE9). This will report the current document mode the browser is currently operating in if the user uses Internet Explorer 8 and is also available when the browser is in a back level browser mode.

If the user however really uses a older version of IE or no IE at all the property is not available and the browser should return a “undefined” as result of your query for this object and you can handle the result accordingly.

Application Partitioning with MEF, Silverlight and Windows Azure – Part II

Alex Strauss — Wed, 28 Apr 2010 11:44:00 GMT

Welcome back to the partitioned blog post about application partitioning with Silverlight MEF and Windows Azure. In this second and last post I will talk about how you can retrieve the information about the deployed parts of the application and retrieve the actual XAP files from the Azure Blob Storage.

Still we only have one Silverlight project where we added just one interface as the contract for the import and lazy initialization and an attribute class to flag our parts in the Silverlight projects to come as user controls to be exported as parts of the application meeting the specified contract.

Now we can extend the class corresponding to our shell to handle the imports of those attributed parts. This is also straight forward and follows the standard MEF procedures.

First thing to do would be to define a property attributed with the ImportMany attribute to tell MEF that it should populate this property with all (not just one) exports meeting the requirements of the importing application. This requirement is actually the contract I were talking about before.

[ImportMany(AllowRecomposition = true)]

public IEnumerable<Lazy<UserControl, IPartAttributes>> Parts { get; set; }

Important to note is the AllowRecomposition property for the ImportMany attribute which tells CompositionContainer to repopulate (recompose) when exports change. Now that we have this we still need to tell MEF to actually populate this property and this is as easy as calling the SatisfyImports method on the of CompositionInitializer class. For real world projects you should however be aware of the limitations of CompositionInitializer.

public partial class MainPage : UserControl, IPartImportsSatisfiedNotification

    public MainPage()

        InitializeComponent();

        CompositionInitializer.SatisfyImports(this);

In order to recognize when all imports have been finished (or satisfied) the class also implements an interface which lets MEF automatically call the OnImportsSatisfied method when recomposition occurs. As a side note it would make sense to follow implement the Model View ViewModel pattern for this application as well then you would factor out this code into a ViewModel class and mark that exportable and then again import it as a part into the main applications shell class printed above. How this can be done is described in a blog post by Glen Block. Continuing with this sample however there is one last thing to do which is to filter and add the UserControls imported by MEF to the items collections of the respective ItemsControl. That involves two steps actually:

Clear the items collections of the ItemsControls
Filter and add the new imports

Here’s the simplistic implementation for the shell areas in this sample application.

public void OnImportsSatisfied()

    ClearShellItemControls();

    PopulateShellAreas();

private void PopulateShellAreas()

    var headerParts = Parts.Where(p => p.Metadata.IsHeaderPart == true).Select(p => p.Value);

    foreach (var hPart in headerParts)

        header.Items.Add(hPart);

    var leftnavParts = Parts.Where(p => p.Metadata.IsLeftNavPart == true).Select(p => p.Value);

    foreach (var lnPart in leftnavParts)

        leftnav.Items.Add(lnPart);

    var workbenchParts = Parts.Where(p => p.Metadata.IsWorkbenchPart == true).Select(p => p.Value);

    foreach (var wbPart in workbenchParts)

        workbench.Items.Add(wbPart);

    var footerParts = Parts.Where(p => p.Metadata.IsFooterPart == true).Select(p => p.Value);

    foreach (var fPart in footerParts)

        footer.Items.Add(fPart);

private void ClearShellItemControls()

    header.Items.Clear();

    leftnav.Items.Clear();

    workbench.Items.Clear();

    footer.Items.Clear();

Next thing to do now is the handle the means on how the application gets to know which XAPs to retrieve in order to import the parts into the container. As already pointed out we need to keep the information about which XAP files belong to the application and their storing location outside of the original Windows Azure deployment package (.cspkg). Because if we would keep it internally we would need to redeploy the package whenever the list of XAP files changes which is something what we don’t want to do.

It would of course be possible to put this information into the configuration file of the cloud service which is exposed through the Windows Azure management portal or the Management API. However this is does only really help for the task of changing the information about the application parts easily. It does however introduce some difficulties in retrieving those values from the Silverlight client which does not have any direct means to get to the configuration settings of the service. So we would need this information through some mechanics embedded into the hosting ASP.Net page or surface it through an respective web service. For simplicity I tool another approach and put a simple XML file also into the blob storage which I then can retrieve easily from my Silverlight application and I can also easily change and redeploy it by simply downloading, changing and uploading it again using my preferred tools. The file itself was already shown in the previous post of this series so now I will focus on how to retrieve it which is absolutely straight forward by using a standard Silverlight WebClient class in the Application_Startup method of the main application to get the file.

private void Application_Startup(object sender, StartupEventArgs e)

    WebClient wClient = new WebClient();

    wClient.DownloadStringCompleted += new DownloadStringCompletedEventHandler(wClient_DownloadStringCompleted);

    wClient.DownloadStringAsync(new Uri("http://<storageaccount>.blob.core.windows.net/mefparts/DeploymentCatalog.xml"));

    CompositionHost.Initialize(new DeploymentCatalog(), catalogs);

    this.RootVisual = new MainPage();

Then we can parse the file and for each part start an asynchronous download of the XAP files into an AggregateCatalog which is the type of the catalogs object in the code below.

void wClient_DownloadStringCompleted(object sender, DownloadStringCompletedEventArgs e)

    if (e.Error == null)

        string deploymentCatalogDefinition = e.Result;

        XDocument doc = XDocument.Parse(deploymentCatalogDefinition);

        var v = doc.Descendants("PartFile");

        foreach (XElement xe in v)

            catalogs.Catalogs.Add(CreateCatalog(xe.Attribute("name").Value));

private DeploymentCatalog CreateCatalog(string partName)

    Uri uri = new Uri("http://<storageaccount>.blob.core.windows.net/" + partName);

    var catalog = new DeploymentCatalog(uri);

    catalog.DownloadCompleted += new EventHandler<System.ComponentModel.AsyncCompletedEventArgs>(catalog_DownloadCompleted);

    catalog.DownloadAsync();

    return catalog;

For this to work however there is one prerequisite to be met on the blob storage side and this is to allow public access for retrieving blobs from the container holding the XAP files and the DeploymentCatalog.xml file. This can of course be done with one of the various tools for managing the Azure Storage Service or if you created the container using the StorageClient class library you can create the container and set the permissions respectively. This also gives you two other advantages which are:

The Silverlight application does not need to carry the shared key of your storage account to retrieve blobs which would impose a security risk
You do not need to create REST calls to the storage service including the authorization and other headers as there is no StorageClient library available for Silverlight

This completes main application and it’s now time to create the parts that comprise the meat of the current applications. For this sample there is actually not much more to do than:

To add another Silverlight project to the solution. It is recommended to make sure that you uncheck the option to host the Silverlight application in the existing web project. It actually does no harm if it is added however it bloats the cloud service package with the XAPs which are not needed there.

Create the UI for the part

<Border x:Name="LayoutRoot" Background="LightBlue" Height="50" VerticalAlignment="Top">

    <TextBlock HorizontalAlignment="Center" VerticalAlignment="Center" Text="Footer" FontSize="16" FontWeight="Bold" />

</Border>

And then add the MetadataAttribute and the contract interface to the project like it was done in the main application

Mark the UserControl exportable using the MetadataAttribute just added to the project

[ExportPart(IsFooterPart=true)]

public partial class MainPage : UserControl

    public MainPage()

        InitializeComponent();

This is then usually repeated for all other parts of the application until all areas have a populating part located in an external XAP. For this sample the complete Solution structure looks lie this.

The main project (here “DynamicCloudRIA”) is deployed via the WebRole project (here “DynMefWebRole1”) as a standard cloud solution project and the XAPs of the other Silverlight projects can be uploaded to the respective container in the Windows Azure Blob Storage. For this sample the container contents look like shown below.

After this has been done the application should already run and show the shell and the dynamically loaded application parts. Hopefully this helps to understand how MEF can help to create partitioned applications with loosely coupled application parts even when the application and its parts is deployed on a cloud platform such as Windows Azure. The source code for the sample is attached for download below.

Application Partitioning with MEF, Silverlight and Windows Azure – Part I

Alex Strauss — Tue, 27 Apr 2010 18:31:56 GMT

The Managed Extensibility Framework (MEF) supports you in creating loosely coupled and partitioned applications. To embrace those paradigms makes sense for many reasons. Some of the various benefits are:

Share work across multiple developers or development team and have a well defined boundaries for the work items of the teams based on MEF components
Dynamic extension or updates of application parts or components without a complete redeployment and long downtimes

MEF has been around in the .Net Framework for quite some time and since the current release of Silverlight 4 it is also available for use in Silverlight applications.

Especially for the use in Silverlight and to introduce application partitioning on with having application XAP files as physical component boundaries it was necessary to alter the capabilities of the DirectoryCatalog class as now the the application parts are not sitting in a local file system directory as assemblies but as XAP archives on a remote web server.

Therefore the DirectoryCatalog was replaced by the DeploymentCatalog in Silverlight. However as far as I understand this comes with one shortcoming which is that you need to specify an direct URL to the XAP files that you want to include into your application. As long as you do not externalize a component that provides those URLs you won not much in terms of loose coupling. But if you do externalize the URL “injection” you have all possibilities MEF offers with respect to dynamically compose applications. Even more you then also have better possibilities to use Windows Azure as the hosting environment for your Silverlight Application. In this Blog post I will demonstrate how this can work in an easy example.

The sample application is partitioned based on UI components to make the concept as obvious as possible. First the main application simply defines some UI areas with an ItemsControl as placeholder for the actual partial UI coming from the external XAPs. So you can more or less say that we define a shell and content modules. From the UI point of view this feels quite a bit like the Composite Application Library (CAL) for Silverlight however the CAL still goes a little bit beyond what we want to accomplish here. The overall application structure looks like the following.

First thing to mention is that we have actually two locations were application parts are stored and served from. As this might seem a bit odd it is however necessary due to the nature of how application packages are deployed on Windows Azure and due to the fact that you do not have direct access to the directories of the web server and the websites. So in order to be able to deploy and provide application parts after the initial deployment we need a place where we put the extending XAP files and were the main application can pick it up. In our case the XAPs are provided through the Windows Azure Blob Storage. This comes in handy as you can use your own or some third party tools to put your XAPs and the related artifacts into the Windows Azure storage.

There is however one thing to be aware of which is that now with having two different locations the cross domain restrictions of Silverlight will intercept and prevent Silverlight or to be more precise MEF from downloading the extending XAPs from blob storage.

Therefore we need to deploy a Silverlight policy file on the target server which in our case is the root of our blob storage account. The file needs to be named ClientAccess.xml. An excellent example how to deploy such kind of file can be found in this blog post by Steve Marx.

What you also need is some kind of external artifact to the application that tells the main application where and which XAPs to download and integrate as parts into the application. In my case I chose to define that in a simple XML file

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

<Deployment>

    <Catalog>

        <PartFile name="mefparts/DynamicCloudRIA.Header.xap" />

        <PartFile name="mefparts/DynamicCloudRIA.LeftNav.xap" />

        <PartFile name="mefparts/DynamicCloudRIA.Workbench.xap" />

        <PartFile name="mefparts/DynamicCloudRIA.Footer.xap" />

    </Catalog>

</Deployment>

So now that I have this prerequisites I can start creating the main application and the application parts. The following screenshot shows the result of this demonstration which is actually a very simple UI which is composed from 5 different XAP files. It is important to note that implementation of functionality does not matter for this sample but the structure and the coupling of the different UI parts through MEF.

To start off I created a new Cloud Project in Visual Studio 2010 with one WebRole and then added a Silverlight Project to the cloud solution which is referenced by the WebRole project. The main UI layout is defined in the main Silverlight application. In this sample a Grid is defined with three rows and two columns. Then a placeholder for each area is defined as an ItemsControl. The XAML for this simple main layout looks like this (I used a fixed size layout for simplicity):

<Grid x:Name="LayoutRoot" Background="White">

    <Grid.ColumnDefinitions>

        <ColumnDefinition Width="200" />

        <ColumnDefinition />

    </Grid.ColumnDefinitions>

    <Grid.RowDefinitions>

        <RowDefinition Height="50" />

        <RowDefinition />

        <RowDefinition Height="50" />

    </Grid.RowDefinitions>

    <ItemsControl x:Name="header" Grid.ColumnSpan="2" Grid.Row="0" />

    <ItemsControl x:Name="leftnav" Grid.ColumnSpan="1" Grid.Row="1" />

    <ItemsControl x:Name="workbench" Grid.ColumnSpan="1" Grid.Row="1" Grid.Column="1" />

    <ItemsControl x:Name="footer" Grid.ColumnSpan="2" Grid.Row="2" />

</Grid>

Next we have to implement some basic “infrastructure” for this sample in order to make it work. First is we have to define a MetadataAttribute in order to allow us to filter the UserControls inside the asynchronous downloaded XAPs for the area they want to attach to. To get to know more about that I recommend to watch the Silverlight TV Episode 5: Using Metadata with MEF. For my sample I added the following class to my main application project.

[MetadataAttribute]

[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]

public class ExportPart : ExportAttribute

    public ExportPart() : base(typeof(UserControl)) { }

    public bool IsHeaderPart { get; set; }

    public bool IsFooterPart { get; set; }

    public bool IsLeftNavPart { get; set; }

    public bool IsWorkbenchPart { get; set; }

As we want to access the metadata or better say filter for the metadata in a strongly typed fashion we need to define an interface with matching read only properties to those exposed in the MetadataAttribute. This allows us to import the application parts with such an ExportAttribute with lazy initialization using the Type System.Lazy<T, TMetadata>. This looks like the following in this sample:

public interface IPartAttributes

    bool IsHeaderPart { get; }

    bool IsFooterPart { get; }

    bool IsLeftNavPart { get; }

    bool IsWorkbenchPart { get; }

That’s it for the moment. In the next part I will discuss how to import parts handle the XAP retrieval and do the deployment. So stay tuned.

Tales About Working With The Azure Service Management API – Chapter III

Alex Strauss — Wed, 17 Feb 2010 10:29:00 GMT

After my last post I was a little bit dissatisfied with the fact that if you use the scripts frequently the blob storage container will fill up quite a bit. As already outlined this will affect the monthly charges billed to your account especially when you are deploying in a high frequency and have to deploy large packages. So I was looking for a solution to that.

So as we are already operating in a Windows Powershell environment I thought the best way to resolve this would be to provide a commandlet that does enable you to delete the deployment packages in the blob storage. So I created a small that of commandlets which enable you to interact with the Windows Azure blob storage based on the official StorageClient managed API. I packaged the commandlets into a SnapIn.

The available commandlets so far are:

Get-Storage	*This represents the base storage service with the elemental properties “SharedKey” and “StorageAccount” which are needed for almost every subsequent operation.*
*Get-Container*	*Lists the container currently available in the blob storage account. This commandlet is not needed for the task of removing the deployment packages.*
*Get-Bloblist*	This commandlet lists the blobs of a specific container and holds a property of “BlobList” which can be used as a piping parameter for the Remove-Blob commandlet. It allows for simple filtering based on extensions with the “ExtensionFilter” parameter. So for our task you could filter for the “cspkg” extension to target all deployment packages.
*Remove-Blob*	*This commandlet removes the blobs provided via the “BlobList” parameter or all blobs in the container if no list is provided. So be careful in using this commandlet.*

The code is attached to this blog post. I choose to provide it in a separate SnapIn package however you could also add it to the Windows Azure Service Management CmdLets project which is also provided as source code. If you use the package as is you need to install it once using the Installer Tool shipping with the .Net Framework. So you need to issue a command similar to this:

c:\Windows\Microsoft.NET\Framework\v2.0.50727\InstallUtil.exe AzureCommandletCollection.dll

After doing so you can check if the AzureCommandletCollectionSnapIn is listed as a registered SanpIn using the command

Get-PSSnapin –registered

The output should look something like this:

Then finally in order to use it you need to add the SnapIn to the snapin to the active powershell session. You need to do that no matter if you want to use the commandlets interactively or from script. Issue the to do so.

Add-PSSnapin AzureCommandletCollectionSnapIn

With respect to integrating the removal task to our scripts I have then altered my deployment script to get rid of the deployment package right after the deployment. So the list of blobs should usually always only consist of one entry.

The changes are minimal. There are only two changes. The first is the part where we need to add the SnapIn to the session:

if(!($mgmtsnapin = Get-PSSnapin AzureManagementToolsSnapIn -erroraction silentlycontinue))

    Write-Host "Adding ManagementTools SnapIn...please wait"

    Add-PSSnapin AzureManagementToolsSnapIn

    if(!($storagesnapin = Get-PSSnapin AzureCommandletCollectionSnapIn -erroraction silentlycontinue))

        Write-Host "Adding AzureCommandletCollection SnapIn...please wait"

        Add-PSSnapin AzureCommandletCollectionSnapIn

The second change is the the actual removal task:

$storagekeys = Get-StorageKeys -ServiceName $storageservicename -SubscriptionId $subscriptionid -Certificate $cert

Get-Storage -StorageAccount $storageservicename -SharedKey $storagekeys.Primary

| Get-Bloblist -ContainerName mydeployments -ExtensionFilter cspkg

| Remove-Blob

So then we can outline the final script which looks like the following:

<#    .Synopsis        Will deploy and start a Windows Azure Service    .Description        Will deploy and start a Windows Azure Service            .Parameter servicename        The name of the Azure service that will hold the deployment    .Parameter thumbprint        The thumbprint of a locally installed and valid certificate for accessing        the Windows Azure Management Service    .Parameter subscriptionid        The ID for the subscription of the Azure Account hosting the respective service    .Parameter slot        The deployment slot in which the package shall be deployed <Production | Staging>    .Parameter storageservicename        The storage account that can be used to upload the deployment package    .Parameter package        The full qualified path to the deployment package    .Parameter config        The full qualified path to the configuration file for this deployment    .Example        deployAzureService.ps1 -servicename "MyService" -thumbprint "5643060E8F0029FB8C6DB76AAE905C7FA697" -subscriptionid "00000000-0000-0000-0000-000000000000" -slot "Production" -storageservicename "StorageService" -package "C:\deployment\HelloWorld.cspkg" -config "C:\deployments\ServiceConfiguration.cscfg" -label "MyFirstDeployment"#> param([PARAMETER(Mandatory=$true)][string]$servicename, [PARAMETER(Mandatory=$true)][string]$thumbprint, [PARAMETER(Mandatory=$true)][string]$subscriptionid, [PARAMETER(Mandatory=$true)][string]$slot, [PARAMETER(Mandatory=$true)][string]$storageservicename, [PARAMETER(Mandatory=$true)][string]$package, [PARAMETER(Mandatory=$true)][string]$config, [PARAMETER(Mandatory=$true)][string]$label)if(!($mgmtsnapin = Get-PSSnapin AzureManagementToolsSnapIn -erroraction silentlycontinue)){    Write-Host "Adding ManagementTools SnapIn...please wait"    Add-PSSnapin AzureManagementToolsSnapIn    if(!($storagesnapin = Get-PSSnapin AzureCommandletCollectionSnapIn -erroraction silentlycontinue))    {        Write-Host "Adding AzureCommandletCollection SnapIn...please wait"        Add-PSSnapin AzureCommandletCollectionSnapIn    }}$cert = Get-Item cert:\CurrentUser\My\$thumbprint$service = Get-HostedService $servicename -Certificate $cert -SubscriptionId $subscriptionidif($service){    $deployment = Get-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert -erroraction silentlycontinue    $name = $deployment.Name    if(!$deployment.Name)    {        Write-Host "Creating new deployment...please wait"        New-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert -Package $package -Configuration $config -Label $label -StorageServiceName $storageservicename |        Get-OperationStatus -WaitToComplete                Write-Host "Starting the new deployment...please wait"        Get-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert |        Set-DeploymentStatus "Running" |        Get-OperationStatus -WaitToComplete        $storagekeys = Get-StorageKeys -ServiceName $storageservicename -SubscriptionId $subscriptionid -Certificate $cert        Get-Storage -StorageAccount $storageservicename -SharedKey $storagekeys.Primary | Get-Bloblist -ContainerName mydeployments -ExtensionFilter cspkg | Remove-Blob    } else    {        Write-Host "Service $servicename already has an active deployment with the name $name...please remove the active deployment first"    }} else{    Write-Host "No service found with the name $servicename"}

When running from the command line it should produce the following output:

Tales About Working With The Azure Service Management API – Chapter II

Alex Strauss — Mon, 15 Feb 2010 10:44:14 GMT

After I elaborated a bit on one of the base requirements to work with the Azure Service Management API at all which is enabling a valid certificate to authenticate your calls to the API I want today share some thoughts about how to automate tasks related with Azure deployments. As already pointed out in Chapter I you probably want to use Windows Powershell together with the Windows Azure Service Management CmdLets which will make your life in interacting with the Windows Azure Fabric from a shell environment much easier. The commandlets support most of the relevant tasks to do deployments and undeployments.

So in my example here I will show how those commandlets can be used in scripts to optimize the consumption of Windows Azure compute services. As you might know the compute service is billed based on service hours which basically means that as long as a service is deployed it will produce cost although the service may not be used at all during certain times. And as there may be quite some solutions where there are known time windows in which the service isn’t used (e.g. non busines hours) it may come in handy if there would be the possibility to undeploy and deploy the services based on their availability needs.

To have this work the only thing needed is two Windows Powershell scripts where on does the deployment and the other one the undeployment. The script for undeploying a service could look like the following:

     <#

        .Synopsis

            Will suspend and undeploy a Windows Azure Service

        .Description

            Will suspend and undeploy a Windows Azure Service        

        .Parameter servicename

            The name of the Azure service that holds the deployment

        .Parameter thumbprint

            The thumbprint of a locally installed and valid certificate for accessing

            the Windows Azure Management Service

        .Parameter subscriptionid

            The ID for the subscription of the Azure Account hosting the respective service

        .Parameter slot

            The deployment slot in which the package to be undeployed is physically situated

        .Example

            undeployAzureService.ps1 -thumbprint "5643060E8F0029FB8C6DB76AAE905C7FA697" -servicename "MyService" -subscriptionid "00000000-0000-0000-0000-000000000000" -slot "Production"

    #>

    param([PARAMETER(Mandatory=$true)][string]$servicename, [PARAMETER(Mandatory=$true)][string]$thumbprint, [PARAMETER(Mandatory=$true)][string]$subscriptionid, [PARAMETER(Mandatory=$true)][string]$slot)

    if(!($snapin = Get-PSSnapin AzureManagementToolsSnapIn -erroraction silentlycontinue))

    {

        Write-Host "Adding ManagementTools SnapIn...please wait"

        Add-PSSnapin AzureManagementToolsSnapIn

    }

    $cert = Get-Item cert:\CurrentUser\My\$thumbprint

    $service = Get-HostedService $servicename -Certificate $cert -SubscriptionId $subscriptionid

    if($service)

    {

        $deployment = Get-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert -erroraction silentlycontinue

        if($deployment.Name)

        {

            Write-Host "Suspending deployment...please wait"

            Get-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert |

            Set-DeploymentStatus 'Suspended' |

            Get-OperationStatus -WaitToComplete

            Write-Host "Removing deployment...please wait"

            Get-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert |

            Remove-Deployment |

            Get-OperationStatus -WaitToComplete

        } else

        {

            Write-Host "No deployment found for the service named $servicename"

        }

    } else

    {

        Write-Host "No service found with the name $servicename"

    }

After creating this script you then can create a scheduled job using the Windows Scheduler. When creating the command line for the scheduled task you have to be carefull about two things:

Set the execution policy for powershell so that it allows to run scripts. Depending on your environment and security policies you should set the execution policy to either “AllSigned”, “RemoteSigned” or “Unrestricted”. For more information consult the powershell documentation. Example: Set-ExecutionPolicy Unrestricted
If your path to the powershell script which you need to pass over to powershell as an argument does contain blanks you need to use double quotes surrounding the whole argument including the ampersand (which is the call operator in Windows Powershell) and inside enclose the path information with single quotes. So a correct statement would look like this: powershell.exe -command "& 'C:\My Scripts\undeployAzureService.ps1'" …

To create the scheduled task using the wizard or use a XML template like the one below, insert your data and import it into the scheduler.

<?xml version="1.0" encoding="utf-16"?>
<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Date>2010-02-12T13:44:02.910461</Date>
    <Author>[userid]</Author>
    <Description>Timed undeployment of Azure Service during non business hours to optimize Azure consumption of service compute hours.</Description>
  </RegistrationInfo>
  <Triggers>
    <CalendarTrigger>
      <StartBoundary>2010-02-12T19:00:00Z</StartBoundary>
      <Enabled>true</Enabled>
      <ScheduleByDay>
        <DaysInterval>1</DaysInterval>
      </ScheduleByDay>
    </CalendarTrigger>
  </Triggers>
  <Principals>
    <Principal id="Author">
      <UserId>[userid</UserId>
      <LogonType>Password</LogonType>
      <RunLevel>LeastPrivilege</RunLevel>
    </Principal>
  </Principals>
  <Settings>
    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    <StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>
    <AllowHardTerminate>true</AllowHardTerminate>
    <StartWhenAvailable>true</StartWhenAvailable>
    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
    <IdleSettings>
      <StopOnIdleEnd>true</StopOnIdleEnd>
      <RestartOnIdle>false</RestartOnIdle>
    </IdleSettings>
    <AllowStartOnDemand>true</AllowStartOnDemand>
    <Enabled>false</Enabled>
    <Hidden>false</Hidden>
    <RunOnlyIfIdle>false</RunOnlyIfIdle>
    <DisallowStartOnRemoteAppSession>false</DisallowStartOnRemoteAppSession>
    <UseUnifiedSchedulingEngine>false</UseUnifiedSchedulingEngine>
    <WakeToRun>false</WakeToRun>
    <ExecutionTimeLimit>P3D</ExecutionTimeLimit>
    <Priority>7</Priority>
  </Settings>
  <Actions Context="Author">
    <Exec>
      <Command>powershell</Command>
      <Arguments>-command "&amp; 'C:\my scripts\undeployAzureService.ps1'" -servicename "MyService" -thumbprint "5643060E8F0029FB8C6DB76AAE905C7FA697" -subscriptionid "00000000-0000-0000-0000-000000000000" -slot "Production" &gt; log.txt</Arguments>
      <WorkingDirectory>C:\deployments\logs</WorkingDirectory>
    </Exec>
  </Actions>
</Task>

Then do the same for the deployment process. A respective Windows Powershell script could look like this:

    <#

        .Synopsis

            Will deploy and start a Windows Azure Service

        .Description

            Will deploy and start a Windows Azure Service        

        .Parameter servicename

            The name of the Azure service that will hold the deployment

        .Parameter thumbprint

            The thumbprint of a locally installed and valid certificate for accessing

            the Windows Azure Management Service

        .Parameter subscriptionid

            The ID for the subscription of the Azure Account hosting the respective service

        .Parameter slot

            The deployment slot in which the package shall be deployed <Production | Staging>

        .Parameter storageservicename

            The storage account that can be used to upload the deployment package

        .Parameter package

            The full qualified path to the deployment package

        .Parameter config

            The full qualified path to the configuration file for this deployment

        .Example

            deployAzureService.ps1 -servicename "MyService" -thumbprint "5643060E8F0029FB8C6DB76AAE905C7FA697" -subscriptionid "00000000-0000-0000-0000-000000000000" -slot "Production" -storageservicename "StorageService" -package "C:\deployment\HelloWorld.cspkg" -config "C:\deployments\ServiceConfiguration.cscfg" -label "MyFirstDeployment"

    #>

    param([PARAMETER(Mandatory=$true)][string]$servicename, [PARAMETER(Mandatory=$true)][string]$thumbprint, [PARAMETER(Mandatory=$true)][string]$subscriptionid, [PARAMETER(Mandatory=$true)][string]$slot, [PARAMETER(Mandatory=$true)][string]$storageservicename, [PARAMETER(Mandatory=$true)][string]$package, [PARAMETER(Mandatory=$true)][string]$config, [PARAMETER(Mandatory=$true)][string]$label)

    if(!($snapin = Get-PSSnapin AzureManagementToolsSnapIn -erroraction silentlycontinue))

    {

        Write-Host "Adding ManagementTools SnapIn...please wait"

        Add-PSSnapin AzureManagementToolsSnapIn

    }

    $cert = Get-Item cert:\CurrentUser\My\$thumbprint

    $service = Get-HostedService $servicename -Certificate $cert -SubscriptionId $subscriptionid

    if($service)

    {

        $deployment = Get-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert -erroraction silentlycontinue

        $name = $deployment.Name

        if(!$deployment.Name)

        {

            Write-Host "Creating new deployment...please wait"

            New-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert -Package $package -Configuration $config -Label $label -StorageServiceName $storageservicename |

            Get-OperationStatus -WaitToComplete

            Write-Host "Starting the new deployment...please wait"

            Get-Deployment -Slot $slot -ServiceName $servicename -SubscriptionId $subscriptionid -Certificate $cert |

            Set-DeploymentStatus "Running" |

            Get-OperationStatus -WaitToComplete

        } else

        {

            Write-Host "Service $servicename already has an active deployment with the name $name...please remove the active deployment first"

        }

    } else

    {

        Write-Host "No service found with the name $servicename"

    }

And the template for the scheduler could look like this:

<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <Date>2010-02-15T09:50:14.2255756</Date>
    <Author>[userid]</Author>
  </RegistrationInfo>
  <Triggers>
    <CalendarTrigger>
      <StartBoundary>2010-02-15T07:00:00</StartBoundary>
      <Enabled>true</Enabled>
      <ScheduleByDay>
        <DaysInterval>1</DaysInterval>
      </ScheduleByDay>
    </CalendarTrigger>
  </Triggers>
  <Principals>
    <Principal id="Author">
      <UserId>[userid]</UserId>
      <LogonType>Password</LogonType>
      <RunLevel>HighestAvailable</RunLevel>
    </Principal>
  </Principals>
  <Settings>
    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
    <StopIfGoingOnBatteries>true</StopIfGoingOnBatteries>
    <AllowHardTerminate>true</AllowHardTerminate>
    <StartWhenAvailable>false</StartWhenAvailable>
    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
    <IdleSettings>
      <StopOnIdleEnd>true</StopOnIdleEnd>
      <RestartOnIdle>false</RestartOnIdle>
    </IdleSettings>
    <AllowStartOnDemand>true</AllowStartOnDemand>
    <Enabled>true</Enabled>
    <Hidden>false</Hidden>
    <RunOnlyIfIdle>false</RunOnlyIfIdle>
    <WakeToRun>false</WakeToRun>
    <ExecutionTimeLimit>P3D</ExecutionTimeLimit>
    <Priority>7</Priority>
  </Settings>
  <Actions Context="Author">
    <Exec>
      <Command>powershell</Command>
      <Arguments>-command "&amp; 'C:\My Scripts\deployAzureService.ps1'" -servicename "MyService" -thumbprint "5643060E8F0029FB8C6DB76AAE905C7FA697" -subscriptionid "00000000-0000-0000-0000-000000000000" -slot "Production" -storageservicename "mystorageservice" -package "'C:\deployments\packages\HelloWorld.cspkg'" -config "'C:\deployments\packages\ServiceConfiguration.cscfg'" -label "MyFirstDeployment" &gt; deployment.log</Arguments>
      <WorkingDirectory>C:\deployments\packages\logs</WorkingDirectory>
    </Exec>
  </Actions>
</Task>

This is all to automate your deployment tasks. One thing however is to remember here. As the New-Deployment commandlet uploads your deployment package into the blob storage of the specified Azure Storage account you should check your blob storage from time and do a clean up otherwise this will also produce unnecessary cost.

Tales About Working With The Azure Service Management API – Chapter I

Alex Strauss — Thu, 28 Jan 2010 19:03:00 GMT

For enterprises, power users and people who simply don’t like the Azure administration portal but do use Windows Azure as an deployment option for their applications or services it may be desirable to integrate deployment and administration tasks into automatic processes and/or customized tools. To support that Microsoft provides a REST based Service Management API. This API is quite comprehensive and allows you to view and alter your deployments, services and storage accounts. In order to secure access to those resources via the API mutual authentication of certificate over a SSL connection is required. In addition also the Subscription-ID of your account is needed as part of the rest URLs to correctly address your resources. While this is by no means a security feature it is recommended to keep this ID a secret, though. But back to the Certificates now. In order to use the service API you need to have a certificate that you associate with your service API. You can do that by using the developer portal and go to the “Account” page and then use the link “Manage My API Certificates”. Then you are able on import A DER encoded binary representation of your certificate (use certmgr.msc on Windows to do so).

In order to get a certificate for use with the Windows Azure Service Management API there are several possibilities:

Create one using the makecert.exe tool which comes with the Windows SDK and also with Visual Studio. How to create a suitable self signed certificate with makecert.exe refer to this blog post
Create a self signed certificate using the IIS Management console. Refer to this Technet article to see how this can be done.
Get a certificate from a Certificate Authority (CA) such as Verisign, GoDaddy, CACert.org, etc.

It is to note that:

The certificate doesn’t need to be a server certificate (enhanced key usage: server authentication). A client certificate is necessary (and probably also easier/cheaper to get from your CA). However please be aware that this cannot be used as a SSL certificate for one of your services (which wouldn’t probably be a good idea anyway)
The certificate needs to have at least a 2048 bit key

Refer to the API documentation for further information.

No you might ask why do I write all this when this is mostly already documented. Because I got my certificate via the automated process of CAcert.org. And in my first try I run into an error that I was not able to get my Service Management API requests authenticated. The service always returned:

Error 403 (Forbidden): The HTTP request was forbidden with client authentication scheme 'Anonymous'

I didn’t really understand why this was happening as I was creating the certificate in my code using one of the above mentioned DER encoded binary .cer files which I exported from the management console. Here is the code which is really not that complicated.

try
{
    X509Certificate cert = X509Certificate.CreateFromCertFile("AzureCert.cer");
    HttpWebRequest req = (HttpWebRequest)WebRequest.Create("https://management.core.windows.net/<subscription-id>/services/storageservices");
    req.ClientCertificates.Add(cert);
    req.UserAgent = "Azure Cloud Management Studio";
    req.Method = "GET";
    req.ProtocolVersion = HttpVersion.Version11;
    req.Headers.Add("x-ms-version", "2009-10-01");
    req.ContentType = "text/xml";
    HttpWebResponse response = (HttpWebResponse)req.GetResponse();
    ...
}
catch (Exception ex)
{
    ...
}

After a while of investigating I realized that as I created the .cer file from a certificate string shown outlined in the picture below.

However I did not realize that I’m then missing the private key generation process that included by clicking on the install button and uses ActiveX in Internet Explorer.

“Your private key is generated by your browser, *IN* your browser when you request a new cert from CAcert. That way CAcert never has your private key in its possession. The implication for you is that you must be on the same machine using the same browser that you used to request the cert initially, when needing to access your private key. So don't forget if it was your "work" machine vs. your "home" machine.”

Unfortunately I couldn’t get that to work with IE8 and Windows 7 what brought me to use the certificate string in the first place. But if you walk down this road and copy that string into a text file, change the file extension to .cer and then install the certificate you will not have a private key associated with this certificate and that’s why the request is failing. In order to have the requests working you need to meet two prerequisites for your certificate:

The certificate needs to be installed in the certificate store of the client machine from where you send the requests to the Service Management API.
The certificate must have an associated private key.

For me this meant:

Use Windows 7 XP Mode and IE6 ;) to issue a new certificate request to CACert.org
Install the certificate from the CAcert.org website using the same browser in the same XP Mode instance
Export the certificate as a Personal Information Exchange (PKCS#12) file including the private key (note that such file have an .pfx file extension)
Import the the certificate on the Windows 7 system used to work with the Service Management API
Make sure that the private key is available
Export the certificate again as a DER encoded binary .cer file (this time make sure that the private key is not exported 1. because you don’t need it on the Azure side and 2. you wouldn’t be able to create a .cer file)
Import the .cer file with the Azure Management Console

After all those steps I was able to issue successful requests with my own code as well as available tools to interact with the Windows Azure Service Management API such as csmanage.exe or the PowerShell Windows Azure Service Management CmdLets. However just to note it again this only works because the certificate is actually also installed in the certificate store where the .Net Cryptographic API does a lookup of the certificate and its corresponding private key. You can verify this if you import the certificate in step 4 above to prompt you if an application tries to use the private key of this certificate.

Bookmark this on Delicious

DHL Shipment Tracking Accelerator for IE8

Alex Strauss — Tue, 10 Nov 2009 13:41:00 GMT

Today it’s going to be a short and extremely non technical post however I thought this may be of interest to some of you. I had some spare time and was waiting for DHL to deliver my copy of Dragon Age: Origins. So I consulted the DHL tracking system quite a few times. And because I found it quite annoying to copy and paste the shipment number out of the Amazon UK webpage into the tracking system on the DHL website I decided to quickly create a DHL Shipment Tracking Accelerator. Although many ecommerce shops already provide links to the tracking system there are still quite a few that don’t. So I think this provides at least some value.

Here’s a little screenshot of the preview. Luckily DHL designed the page so that at least some relevant info is presented within the preview. To get full fidelity however you can hit the mouse button on the accelerator menu item to go to the full page.

If you want to add the accelerator yourself…here you go. I provide a English and a German version.

Bookmark this on Delicious

Installing IEAK IN A VPC without Disk Space Determination

Alex Strauss — Wed, 14 Oct 2009 10:48:17 GMT

If you try to install the Internet Explorer Administration Kit on a Virtual PC image you may have probably encountered the following situation

The box shown above appears and stays there forever. The only option you have is to click the “Return” button and cancel the installation process. But as you may still want to have this piece of software installed on your virtual pc you are pretty much stuck here. However there is at least still one possibility to install the .msi package. That is by using the msiexec.exe tool with the quiet or passive option. So after opening a Command Window (eventually as Administrator) you can use the following command line to silently install the IEAK install image:

msiexec /quiet /i <PATH>\ieak.msi

This will install the package and it will be available for use. However there is one problem with this approach. In the GUI you need to choose a license type from three options (Internet Service Provider (ISP), Internet Content Provider (ICP) and Corporate). With the above method you cannot do that and therefore the product is installed with the default license which obviously is the ISP license. Implication of this is that there are certain features enabled or disabled in IEAK depending on the license mode. So if you need the ICP or the Corporate mode you are stuck again. However as a quick hack you can modify one (or better) two registry key in order to adapt IEAK to your needs and requirements.

You need to go to:

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\IEAK

And then there are the two string values which you can modify:

Mode: <0|1|2> where 0 is ISP, 1 is ICP and 2 is Corporate

Organization Name: Which is the name that gets inserted in certain UI areas of IE and which probably has also some legal meaning with respect to licensing.

So finally it will look something like this which is the correct setting for your requirements and you then are ready to start creating custom IE8 packages.