Using an Azure PublishSettings File From C#

Monday, April 28, 2014 by K. Scott Allen

One of the fantastic aspects of cloud computing in general is the capability to automate every step of a process. Hanselman and Brady Gaster have both written about the Windows Azure Management Libraries, see Penny Pinching in the Cloud and Brady’s Announcement for some details.

The management libraries are wrappers around the Azure HTTP API and are a boon for businesses that run products on Azure. Not only do the libraries allow for automation but they also allow you (or rather me, at this very minute) to create custom applications for a business to manage Azure services. Although the Azure portal is full of features, it can be overwhelming to someone who doesn’t work with Azure on a daily basis. An even bigger issue is how there is no concept of roles in the portal. If you want to give someone the ability to shutdown a VM from the portal, you also give them the ability to do anything in the portal, including the ability to accidently delete all services the business holds dear.

A custom portal solves both of the above problems because you can build something tailored to the services and vocabulary the business uses, as well as perform role checks and restrict dangerous activities. The custom portal will need a management certificate to perform activities against the Azure API, and the easiest approach to obtain a management certificate is to download  a publish setting file.

Once you have a publish settings file, you can write some code to parse the information inside and make the data available to higher layer management activities. There are a few libraries out there that can work with publish setting files, but I have some special requirements and want to work with them directly. The contents of a publish settings file look like the following (and note there can be multiple Subscription elements inside).

      Name="Happy Subscription Name"
      ManagementCertificate="...base64 encoded certificate data..." />


Let’s use the following code as an example goal for how my custom publish settings should work. I want to:

  1. Create an object representing the settings by just handing off some text.
  2. Loop through the subscription in a file
  3. Ask each subscription to create credentials I can use to invoke the Azure HTTP API.
var fileContents = File.ReadAllText("odetocode.publishsettings");
var publishSettingsFile = new PublishSettingsFile(fileContents);

foreach (var subscription in publishSettingsFile.Subscriptions)
    Console.WriteLine("Showing compute services for: {0}", subscription.Name);
    var credentials = subscription.GetCredentials();
    using (var client = new ComputeManagementClient(credentials, subscription.ServiceUrl))
        var services = client.HostedServices.List();
        foreach (var service in services)
            Console.WriteLine("\t{0}", service.ServiceName);

It is the PublishSettingsFile class that parses the XML and creates PublishSetting objects. I’ve removed some error handling from the class so it doesn’t appear too intimidating.

public class PublishSettingsFile
    public PublishSettingsFile(string fileContents)
        var document = XDocument.Parse(fileContents);

        _subscriptions = document.Descendants("Subscription")

    private PublishSettings ToPublishSettings(XElement element)
        var settings = new PublishSettings();
        settings.Id = Get(element, "Id");
        settings.Name = Get(element, "Name");
        settings.ServiceUrl = GetUri(element, "ServiceManagementUrl");
        settings.Certificate = GetCertificate(element, "ManagementCertificate");
        return settings;

    private string Get(XElement element, string name)
        return (string) element.Attribute(name);

    private Uri GetUri(XElement element, string name)
        return new Uri(Get(element, name));

    private X509Certificate2 GetCertificate(XElement element, string name)
        var encodedData = Get(element, name);
        var certificateAsBytes = Convert.FromBase64String(encodedData);
        return new X509Certificate2(certificateAsBytes);

    public IEnumerable<PublishSettings> Subscriptions
            return _subscriptions;

    private readonly IList<PublishSettings> _subscriptions;

The PublishSettings class itself is relatively simple. It mostly holds data, but can also create the credentials object needed to communicate with Azure.

public class PublishSettings
    public string Id { get; set; }
    public string Name { get; set; }
    public Uri ServiceUrl  { get; set; }
    public X509Certificate2 Certificate { get; set; }

    public SubscriptionCloudCredentials GetCredentials()
        return new CertificateCloudCredentials(Id, Certificate);


In the future I’ll try to write more about the custom portal I’m building with ASP.NET MVC, WebAPI, and AngularJS. It has some interesting capabilities.

Canceling $http Requests in AngularJS

Thursday, April 24, 2014 by K. Scott Allen

One of the objects you can pass along in the config argument of an $http operation is a timeout promise. If the promise resolves, Angular will cancel the corresponding HTTP request.

Sounds easy, but in practice there are a few complications. Before we get to the complications, let’s look at some easy code. Imagine the following  inside of a controller where a user can click a Cancel button.

var canceller = $q.defer();

$http.get("/api/movies/slow/2", { timeout: canceller.promise })
        $ =;

$scope.cancel = function(){
    canceller.resolve("user cancelled");  

The code passes the canceller promise as the timeout option in the config object. If the user clicks cancel before the request completes, we’ll see the cancellation in the Network tab of the developer tools.

Cancelled HTTP Request

The complications come in real life scenarios where we have to manage multiple requests, provide the ability to cancel an operation to other client components, and figuring out if a given request is cancelled or not.

First, let’s look at a service that wraps $http to provide domain oriented operations. Typically services that talk using $http return simple promises, but now we need to return objects that provide a promise for the outstanding request, and  a method that can cancel the request.

app.factory("movies", function($http, $q){

    var getById = function(id){
        var canceller = $q.defer();

        var cancel = function(reason){

        var promise =
            $http.get("/api/movies/slow/" + id, { timeout: canceller.promise})

        return {
            promise: promise,
            cancel: cancel

    return {
        getById: getById


A client of the service might need to track multiple requests, if there is a UI like the following that allows a user to send multiple requests.

<div ng-controller="mainController">

    <button ng-click="start()">
        Start Request

        <li ng-repeat="request in requests">
            <button ng-click="cancel(request)">Cancel</button>

        <li ng-repeat="m in movies">{{m.title}}</li>


The following code will manage the UI and allow the user to cancel any outstanding request.

app.controller("mainController", function($scope, movies) {

    $scope.movies = [];
    $scope.requests = [];
    $ = 1;

    $scope.start = function(){

        var request = movies.getById($;
        }, function(reason){

    $scope.cancel = function(request){
        request.cancel("User cancelled");

    var clearRequest = function(request){
        $scope.requests.splice($scope.requests.indexOf(request), 1);

The logic gets messy and could use some additional encapsulation to keep request management from overwhelming  the controller, but this is the essence of what you’d need to do to allow cancellation of $http operations.

Is It Time To Switch To JavaScript?

Wednesday, April 23, 2014 by K. Scott Allen

JavaScript LogoQuestion from the mailbox: "After many years as a server side developer and DBA, is it time to make a switch to JavaScript and focus on client side development?"

I think you need to work in an environment you enjoy. Some people do not enjoy client side development, and that's ok. There is still plenty of work to do on the server and in the services that run there.

The funny thing is, you don't have to leave the server to learn JavaScript. Take a look at technologies like NodeJS or MongoDB first. Having some JavaScript experience will be good, and I think there is no better way to learn a new language than to use the language inside a paradigm you already understand.

Once you know more about JavaScript the language you should take some time to explore the HTML development landscape and try working with some of the tools and frameworks, even if you have to use some of your spare time.

Maybe you’ll find you like the new world, only then it would be time for a switch, because in the end you gotta do what you enjoy...

Better Error Handling In AngularJS

Monday, April 21, 2014 by K. Scott Allen

In my recent work I’ve been using two approaches to handling errors and exceptions. The ultimate goal is to not let an error go unnoticed.


First up is a decorator for the $exceptionHandler service. We’ve looked at other decorators in a previous post. This specific decorator will send all errors to $rootScope for data binding before allowing the call to fall through to the default implementation (addError is a custom method on $rootScope, while $delegate represents the service being decorated). You could also try to send the errors back to the host and thereby collect errors from all clients.


    $provide.decorator("$exceptionHandler", function($delegate, $injector){
        return function(exception, cause){
            var $rootScope = $injector.get("$rootScope");
            $rootScope.addError({message:"Exception", reason:exception});
            $delegate(exception, cause);


Notice the use of $injector in the above code. Using the $injector service directly is required to avoid a circular dependency error by advertising both $exceptionHandler and $rootScope as dependencies.

Promising Errors

I’m a fan of using catch at the end of a chain of promises. One reason is that catch is the only sure fire way to process all possible errors. Let’s use the following code as an example. 

    .then(workComplete, workError);

Even though an error handler (workError) is provided to the then method, the error handler doesn’t help if something goes wrong inside of workComplete itself . . .

var workComplete = function(result){
    return  $q.reject("Feeling lazy");

. . . because we are already inside a success handler for the previous promise. I like the catch approach because it handles this scenario and also makes it easier to see that an error handler is in place.

    .catch(errors.catch("Could not complete work!"));

Since so many catch handlers started to look alike, I made an errors service to encapsulate some of the common logic.

app.factory("errors", function($rootScope){
    return {
        catch: function(message){
            return function(reason){
                $rootScope.addError({message: message, reason: reason})

And now async related activities can present meaningful error messages to the user when an operation fails.

The Special Properties of ngRepeat In AngularJS

Thursday, April 17, 2014 by K. Scott Allen
1 comment

Today’s tip comes straight from the AngularJS documentation, but I’ve seen a few people miss the topic. 

Inside an ngRepeat directive the special properties $first, $last, and $middle are available. These properties hold boolean values ($first is true only for the first repeated element), and two more special properties that are available are $even and $odd.

Another useful property is the $index property, which contains the offset of each repeated element and starts at 0 (like all good offsets).

You can view the following markup live in this Plunker. The code is using $first and $last to avoid showing clickable up and down prompts when an item is in the first or last position. The markup is also using $index to grab the offset of a clicked item.

    <tr ng-repeat="item in items">
        <td><span ng-show="!$first" ng-click="moveUp($index)">up</span></td>
        <td><span ng-show="!$last" ng-click="moveDown($index)">down</span></td>

Combined with the following controller, you can move items up and down by clicking on the arrows.

module.controller("mainController", function($scope){
    $scope.items = [
        { title: "Item 1" },
        { title: "Item 2" },
        { title: "Item 3" },
        { title: "Item 4" },
        { title: "Item 5" },

    var move = function (origin, destination) {
        var temp = $scope.items[destination];
        $scope.items[destination] = $scope.items[origin];
        $scope.items[origin] = temp;

    $scope.moveUp = function(index){            
        move(index, index - 1);

    $scope.moveDown = function(index){                    
        move(index, index + 1);


Deconstructing A Function From Microsoft Word 1.1a

Tuesday, April 15, 2014 by K. Scott Allen

When Microsoft released the source code to MS-DOS and Word, I had to take a look. One of the first functions I came across was ReplacePropsCa from the srchfmt.c file.

/* %%Function:ReplacePropsCa %%Owner:rosiep */
ReplacePropsCa(prpp, pca)
struct RPP *prpp;
struct CA *pca;
    struct CA caInval;

    if (prpp->cbgrpprlChp)
        ExpandCaSprm(pca, &caInval, prpp->grpprlChp);
        ApplyGrpprlCa(prpp->grpprlChp, prpp->cbgrpprlChp, pca);
        if (!vfNoInval)
            InvalText(pca, fFalse /* fEdit */);

    if (prpp->cbgrpprlPap)
        int fStc;
        struct CHP chp;
        struct PAP pap;

        if (fStc = (*prpp->grpprlPap == sprmPStc))
            CachePara(pca->doc, pca->cpFirst);
            pap = vpapFetch;
        ExpandCaSprm(pca, &caInval, prpp->grpprlPap);
        ApplyGrpprlCa(prpp->grpprlPap, prpp->cbgrpprlPap, pca);
        if (fStc)
            GetMajorityChp(pca, &chp);
            EmitSprmCMajCa(pca, &chp);
            if (!FMatchAbs(pca->doc, &pap, &vpapFetch))
        if (!vfNoInval)
            InvalText (pca, fFalse /* fEdit */);

Thought #1: Every Function Has An Owner. Although I see the occasional project where each file has a comment indicating the owner, I don’t remember ever seeing ownership declared on individual functions. I think the concept of collective ownership is a healthier approach to building software, both for the software and the developers. Today’s tools also make it easier to jump around in code.

Thought #2: The Flow Control Is All Wrong. Oh, wait, the flow control seems ok, it’s just the funny indentation of curly braces setting off alarm bells. Joel Spolsky has a post from 2005 titled Making Wrong Code Look Wrong in which he says:

This is the real art: making robust code by literally inventing conventions that make errors stand out on the screen.

After many years in 3 different languages using { and }, my eyes are accustomed to looking for a closing curly brace in the same column as the if. Not seeing the curly means code might accidently execute outside the conditional check. This function hides the closing curly and is full of evil.

Thought #3: The Notation Is Hilarious. Call it Hungarian Notation, or Anti-Hungarian Notation, or something not Hungarian at all but a custom DSL designed in C. In any case the idea of checking to see if a prpp->grpplPap is equal to a sprmPStc is just one brick in a wall of gibberish that reminds me of a Lewis Carroll poem.

`Twas brillig, and the slithy toves
  Did gyre and gimble in the wabe:
All mimsy were the borogoves,
  And the mome raths outgrabe.

Both the function and the poem include gibberish, but at least the Lewis Carroll poem rhymes.

Deep Linking a Tabbed UI With AngularJS

Monday, April 14, 2014 by K. Scott Allen

The idea is to dynamically generate a tabbed navigation using Angular and UI Bootstrap.

 I’ve done this before, but this time around I needed the ability to deep link into a tab. That is, if a user bookmarks /someapp/tab2, then the 2nd tab should be active with its content showing.

Tabbed UI Angular JS

Instead of using ngRouter, which is a bit simplistic, I decided to use UI Router. UI Router is not without quirks and bugs, but it does give the opportunity to setup multiple, named “states” for an application, and can manage nested states and routes through associated URLs. One of the first steps in working with UI Router is configuring the known states

var app = angular.module("routedTabs", ["ui.router", "ui.bootstrap"]);

app.config(function($stateProvider, $urlRouterProvider){


        .state("main", { abstract: true, url:"/main", templateUrl:"main.html" })
            .state("main.tab1", { url: "/tab1", templateUrl: "tab1.html" })
            .state("main.tab2", { url: "/tab2", templateUrl: "tab2.html" })
            .state("main.tab3", { url: "/tab3", templateUrl: "tab3.html" });

In the above code, “main” is a parent state with three children (tab1, tab2, and tab3). Each child has an associated URL (which will be appended to the parent URL) and a template. Each child template will plug into the parent template of main.html, which itself has to plug into the application shell.

In other words, the shell of the application uses the ui-view directive to position the parent template (main.html).

<body ng-app="routedTabs" class="container">

   <div ui-view></div>


This is not much different than using ngRouter and its ngView directive, but UI router also allows for main.html to use another ui-view directive where one of the child templates will appear.

<div ng-controller="mainController">

            ng-repeat="t in tabs" 

    <div ui-view></div>


This view requires a controller to provide the tab data.

app.controller("mainController", function($rootScope, $scope, $state) {        
    $scope.tabs = [
        { heading: "Tab 1", route:"main.tab1", active:false },
        { heading: "Tab 2", route:"main.tab2", active:false },
        { heading: "Tab 3", route:"main.tab3", active:false },

    $scope.go = function(route){

    $ = function(route){
        return $;

    $scope.$on("$stateChangeSuccess", function() {
        $scope.tabs.forEach(function(tab) {
   = $;

The only reason to listen for UI router’s $stateChangeSuccess is to keep the right tab highlighted if the URL changes. It’s a bit of a hack and actually makes me wonder if using tabs from UI Bootstrap is worth the extra code, or if it would be easier to write something custom and integrate directly with UI router.

If you want to try the code for yourself, here it is on Plunkr

by K. Scott Allen K.Scott Allen
My Pluralsight Courses
The Podcast!