Gunnar Peipman's ASP.NET blog

ASP.NET Web API: Query string based content formatting

DigiMortal — Mon, 23 Apr 2012 07:24:09 GMT

My previous post about Web API content negotiation showed how to add support for new content formats. As our API may have consumers who prefer query for data using GET requests we have to offer something for these dudes too. In this post I will show you how to make life easier for our Web API consumers by using query string mappings.

I will use media type mapping and formatter from my previous posting Extending content negotiation with new formats. We have to modify code a little bit because we need also single vCard download.

Media type formatter

Here is my media type formatter for vCard. It supports vCard format for single and multiple results. Multiple results are given to write method as IEnumerable<ContactModel>.

public class vCardMediaTypeFormatter : MediaTypeFormatter

{

public vCardMediaTypeFormatter()

{

SupportedMediaTypes.Clear();

SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/x-vcard"));

}

protected override bool CanWriteType(Type type)

{

return type == typeof(IEnumerable<ContactModel>) ||

type == typeof(ContactModel);

}

protected override Task OnWriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, FormatterContext formatterContext, TransportContext transportContext)

{

return Task.Factory.StartNew(() =>

{

if (type == typeof(ContactModel))

WriteVCard((ContactModel)value, stream);

else

WriteVCard((IEnumerable<ContactModel>)value, stream);

});

}

private void WriteVCard(ContactModel model, Stream stream)

{

var buffer = new StringBuilder();

buffer.AppendLine("BEGIN:VCARD");

buffer.AppendLine("VERSION:2.1");

buffer.AppendFormat("N:{0};{1}\r\n", model.LastName, model.FirstName);

buffer.AppendFormat("FN:{0} {1}\r\n", model.FirstName, model.LastName);

buffer.AppendLine("END:VCARD");

using (var writer = new StreamWriter(stream))

{

writer.Write(buffer);

}

private void WriteVCard(IEnumerable<ContactModel> contactModels, Stream stream)

{

var enumerator = contactModels.GetEnumerator();

while (enumerator.MoveNext())

{

WriteVCard(enumerator.Current, stream);

}

Query string mapping

Now let’s say to our web application that contacts API support vCard also with GET requests. QueryStringMapping class will help us out. We just add correctly initialized query string mapping to vCard media type formatter.

var vcard = new vCardMediaTypeFormatter();

vcard.MediaTypeMappings.Add(new VCardMediaTypeMapping());

vcard.MediaTypeMappings.Add(new QueryStringMapping("format", "vcard", "text/x-vcard"));

GlobalConfiguration.Configuration.Formatters.Add(vcard);

One thing to notice – we made no changes to our API to add support for vCards and query string mappings. Our API provides only functionality and it doesn’t make any decision about output formatting.

Testing query string

Now it’s time to test our query string mapping. We don’t mess with AJAX-requests anymore because we can conveniently use out browser. If I want to download contact that has ID value 11 over Web API I have to use the following query string:

http://my-app/api/contacts/11/?format=vcard

I will also open IE developer tools to monitor traffic. This is what was returned to browser:

But now something weird happens – browser asks if we want to open vCard we just requested. Let’s say yes. Here is what you should see on the screen:

This is good example about how we can use our API in “mixed” mode. We can exchange data between systems but we can also let user to handle some results directly.

Conclusion

Our API can be consumed by different AJAX-clients but now we also made our API easier to use for guys who can easily make GET-requests. By example, PHP guys can use fopen() to make GET-request to our API controller. As we saw we can also use those GET-requests to let end users handle formatted downloads.

ASP.NET Web API: Extending content negotiation with new formats

DigiMortal — Fri, 20 Apr 2012 09:11:36 GMT

My last post about ASP.NET Web API content negotiation support gave you basic idea about what content negotiation is and how it works out-of-box. In this post I will show you how to extend Web API content negotiation support and make Web API to output contact data in vCard format.

In the end of my previous post we asked data in vCard format from Web API and got answer as JSON. No errors, just answer in the format that Web API was able to provide. In this posting we will add support for vCard data and I will introduce you some more concepts related to Web API. Our focus is on getting data back in vCard format.

Web API controller

One new thing in ASP.NET MVC 4 is new controller type that supports Web API. The new type is called ApiController and it doesn’t use ActionResults. ActionResults are targeted to wider content output. ApiController works with our model types and therefore it is targeted to API type communication. If it still sounds like mystery to you then take Web API controller as MVC based data service.

With Web API controller I use simple model for contacts:

public class ContactModel

{

public int Id { get; set; }

public string FirstName { get; set; }

public string LastName { get; set; }

}

And here is my Web API controller for contacts:

public class ContactsController : ApiController

{

public IEnumerable<ContactModel> Get()

{

return SampleDataProvider.Contacts;

}

public ContactModel Get(int id)

{

return SampleDataProvider.Contacts.FirstOrDefault(c => c.Id == id);

}

public void Post(ContactModel contact)

{

SampleDataProvider.Save(contact);

}

public void Put(ContactModel contact)

{

SampleDataProvider.Save(contact);

}

public void Delete(int id)

{

SampleDataProvider.Delete(id);

}

For this posting this controller is enough. Extension point for content formats is not hidden in Web API controllers. What it means? Well, without affecting Web API controllers we can add support for different content formats over time.

Media type classes

To add vCard support to our Web API we have to use classes that can convert our contact model to vCard and that introduce this format to content negotiation mechanism. I don’t start dissecting internals of content negotiation deeper because it deserver separate posting. In this posting we will build up two media type classes that do the work we need.

MediaTypeMapping class

Our first class is media type mapper. This class extends MediaTypeMapping – the base class for all media type mappers. In this class we say that vCard format is supported 100% if client accepts this format.

public class VCardMediaTypeMapping : MediaTypeMapping

{

public VCardMediaTypeMapping() : base("text/x-vcard")

{ }

protected override double OnTryMatchMediaType(HttpResponseMessage response)

{

if (response.RequestMessage.Headers.Accept.Count(m => m.MediaType == "text/x-vcard") > 0)

return 1.0;

return 0.0;

}

protected override double OnTryMatchMediaType(HttpRequestMessage request)

{

throw new NotImplementedException();

}

Our next class is media type formatter.

MediaTypeFormatter class

MediaTypeFormatter is base class for all media type formatters. Media type formatters take object and convert it to format they support. In our case we need media type formatter that takes our contact model and outputs vCard.

public class vCardMediaTypeFormatter : MediaTypeFormatter

{

public vCardMediaTypeFormatter()

{

SupportedMediaTypes.Clear();

SupportedMediaTypes.Add(new MediaTypeHeaderValue("text/x-vcard"));

}

protected override bool CanWriteType(Type type)

{

return (type == typeof(IEnumerable<ContactModel>));

}

protected override Task OnWriteToStreamAsync(Type type, object value, Stream stream, HttpContentHeaders contentHeaders, FormatterContext formatterContext, TransportContext transportContext)

{

return Task.Factory.StartNew(() =>

{

WriteVCard((IEnumerable<ContactModel>)value, stream);

});

}

private void WriteVCard(IEnumerable<ContactModel> contactModels, Stream stream)

{

var enumerator = contactModels.GetEnumerator();

while (enumerator.MoveNext())

{

var contactModel = enumerator.Current;

var buffer = new StringBuilder();

buffer.AppendLine("BEGIN:VCARD");

buffer.AppendLine("VERSION:2.1");

buffer.AppendFormat("N:{0};{1}\r\n", contactModel.LastName, contactModel.FirstName);

buffer.AppendFormat("FN:{0} {1}\r\n", contactModel.FirstName, contactModel.LastName);

buffer.AppendLine("END:VCARD");

using (var writer = new StreamWriter(stream))

{

writer.Write(buffer);

}

One thing to notice is CanWriteType() method. Don’t expect that this method is only called to find out if your model types are supported. This method is also called with generic types where your model types appear. By example, support for IEnumerable<ContactModel> is checked before writing out list of contacts. Why ask about collections? The point is simple – there may be types that cannot be listed by just adding converted objects to output stream.

Introducing new media type to web application

Before testing our application we must introduce to web application that we have support for new media type. This is the point where we put all pieces together and this is why we don’t have to modify our Web API controllers when we add new media formats to our application. Add the following code block to Application_Start method in Global.asax file.

var vcard = new vCardMediaTypeFormatter();

vcard.MediaTypeMappings.Add(new VCardMediaTypeMapping());

GlobalConfiguration.Configuration.Formatters.Add(vcard);

What we are doing here is simple. We create new instance of our vCard formatter and add mapping to it that sais that this formatter is able to output vCard. After that we add our formatter to global formatters collection so content negotiation system is able to use it.

Testing our application

Now it’s time to test our application. I’m using same application as in my previous example where we got the following result when asking vCard from Web API:

Last time we got data back in JSON format. We asked vCard that is not supported OOB.

Now let’s try again and let’s see what is the type of returned content and how it looks:

Content type of response is this time vCard.

Response body is now formatted as vCard.

Okay, here it is – list of contacts as vCard items.

Conclusion

Extending Web API content negotiation with support for new media types gives us the way to support clients better and provide them with richer output formats support. Web API controllers are good for building Web API-s and they are very natural to use. Support for content formats is introduced on application global settings level and we don’t have to modify our Web API controllers when new media formatter is added to system. When developing our web based API we put focus on internals of this API and functionalities it provides. Output formatters are implemented separately and used by Web API through content negotiation mechanism.

ASP.NET Web API: How content negotiation works?

DigiMortal — Thu, 19 Apr 2012 10:12:50 GMT

One cool new feature that ASP.NET Web API introduces is support for content negotiation. Content negotiation is mechanism that allows web server to serve content in different format using same URL. In this posting I will show you how to use ASP.NET Web API to serve content in JSON and XML formats.

How content negotiation works

Content negotiation takes place when browser or some other HTTP-client tells server what content formats it accepts. HTTP-client uses Accept header to list all formats it can read. Accept: */* means that client is okay with every content format that server is able to provide. By example, one HTTP-client may accept content in JSON and the other in XML.

Two possible things can happen as a result of negotiation. Client and server agree with format or they don’t. In latter case server gives content out in its default format and it is up to client to get something done with this answer (log an error, by example).

Web API and content negotiation

In this posting we will focus on basic content negotiation support offered by ASP.NET Web API. I will show you how to extend Web API content negotiation in later postings. First we take a look how things work out-of-box and then we try to make things work like we want. We will play with built-in features in this posting.

Let’s suppose we have simple database with contact data and we want to use this database from some other system or from some browser-based AJAX-application. On contact data form I have button that helps me making AJAX-requests to Web API.

Here is the code behind Get Data button:


$.ajax({
    type: 'GET',
    url: "api/contacts/"
});

This code just asks data from Web API and returns some data. When we click the button we get the following response:

Now let’s change the code behind button and let’s specify that we want data back in XML:

$.ajax({
    beforeSend: function (req) {
         req.setRequestHeader("Accept", "text/xml");
     },
     type: 'GET',
     url: "api/contacts/"
});

Browser sends now Accept header with value text/xml. The answer from server is here:

Okay, we got data in JSON and XML and both of these formats are widely accepted by tools on different platforms.

What if client and server doesn’t agree?

Now let’s try out what happens when we ask something that Web API doesn’t support out-of-box. Perfect fit for contacts should be vCard:

$.ajax({
    beforeSend: function (req) {
        req.setRequestHeader("Accept", "text/x-vcard");
    },
    type: 'GET',
    url: "api/contacts/"
});

The result is here:

What we got is same JSON we saw in our first experiment. Web API was not able to convert response to vCard and instead of failing or throwing nasty exceptions it gave us our default answer – JSON.

Conclusion

Built-in content negotiation helps us server same content in different formats to different clients. Clients have to say what format they expect and as long as Web API is able to convert results to this format the client gets content in format it asked it. Providing more than one content format with our API is only good – it makes other developers way easier to use our API with tools they have and this way our API finds more serious users easily.

ASP.NET MVC 4: Short syntax for script and style bundling

DigiMortal — Sat, 17 Mar 2012 11:43:06 GMT

ASP.NET MVC 4 introduces new methods for style and scripts bundling. I found something brilliant there I want to introduce you. In this posting I will show you how easy it is to include whole folder with stylesheets or JavaScripts to your page.

I’m using ASP.NET MVC 4 Internet Site template for this example. When we open layout pages located in shared views folder we can see something like this in layout file header:

Let’s take the last line and modify it so it looks like this:

After saving the layout page let’s run browser and see what is coming in over network.

As you can see the request to folder ended up with result code 200 which means that request was successful. 327.2KB was received and it is not mark-up size for error page or directory index. Here is the body of response:

I scrolled down to point where one script ends and another one starts when I made the screenshot above. All scripts delivered with ASP.NET MVC project templates start with this green note. So now we can be sure that the request to scripts folder ended up with bundled script and not with something else.

Conclusion

Script and styles bundling uses currently by default long syntax where bundling is done through Bundling class. We can still avoid those long lines and use extremely short syntax for script and styles bundling – we just write usual script or link tag and give folder URL as source. ASP.NET MVC 4 is smart enough to combine styles or scripts when request like this comes in.

Windows 8 Metro development–are they serious?

DigiMortal — Sun, 11 Mar 2012 20:27:51 GMT

When Windows 8 Consumer Preview came out I downloaded it same day and installed on virtual machine. Of course, I also installed new Visual Studio 11 beta on it. Then I started playing with metro applications and I am very confused and a little bit disappointed about how broken and limited everything will be on WinRT right now. Here are some of my thoughts.

Metro apps are extremely buggy

Over years I have seen no such a pile of bugs in Microsoft product that should be Release Candidate (RC). Windows 7 beta and RC were brilliant. They worked like charm and after couple of weeks with beta I started using it as my main operating system. Okay, there were some small crashed and BSOD-s but still it was extremely stable.

Now Windows 8 is different. Everything else seems to work almost normally but when we start with Metro then everything falls down. Some of my findings are here:

Suddenly with reason I was not able to identify videos doesn’t play normally in Metro applications. Audio stream is played normally but picture is black. If I run Windows Media Player – this is usual Windows application – on same machine and try to watch videos then everything works fine.
Problem with video playback exists also on IE10. It doesn’t matter if I run it from desktop or from new start screen. It worked before for some days and then problems started. By the way – Build application fails exactly same way.
Couple of days more and IE10 doesn’t open from new start screen anymore. It opens for a moment and then shuts down. Best it can do is to stay open and show blue starting screen but nothing more.
Other Metro apps almost like work. Sometimes they crash, sometimes they are extremely slow and doesn’t react to new mouse gestures. My virtual machine has enough resources to run Windows 8 normally.

I have no good idea what is going on behind curtains or why Microsoft released so buggy version of Windows 8 but considering that they have time about four months to develop + one month to test and debug Windows 8, I am not very sure how bright will be its launch. I mean third-parties need also time to build their apps and test them on stable versions. Thinking this way I am not very sure how competition with Apple iPads will look like or what will be the result.

WinRT API-s: Another bad surprise

Now, let’s go and try to build something useful for my business. Let’s build Metro application that communicates with web services. Is it possible to make something work that uses web services built on previous versions of ASP.NET? Is it possible to use NTLM? Is it possible to use SSL with basic authentication? No, guys, forget it for now. Here are some of my really bad findings:

Support for ASP.NET web services is completely broken if you need some more advanced features like authentication.
NTLM authentication doesn’t work. What is more annoying is one blog post I read where one of Microsoft dudes told about Windows authentication in Metro something like this: we don’t plan to support it but if people ask then there will be some support for Windows authentication. Okay, guys, you just made head shot to SharePoint, Office 365 and Dynamix CRM.
I reconfigured my web services so they use basic authentication. And guess what – again same errors about how communication on socket level fails. When I enabled anonymous access to web services then suddenly I was able to communicate with them. And with me, of course, the whole world.
There is no way to reference libraries built on working versions of .NET. If you have libraries that do something useful then you have to create special Metro version of them. So you end up with two parallel code-bases that do exactly the same thing. Yes, you are just human being and therefore the worst machine to handle duplications but this is the way how you must live with your Metro applications right now.

I’m not very sure why Windows 8 and Metro development is such a bad mess. I don’t know why it is impossible to build secure business applications on Metro. I really hope that Microsoft is in hurry with many developments on Windows 8 and Consumer Preview was just one unhappy nightly build that was pushed to market. If things are not going way better for a time when stable version is made public then first and most important battle for market is lost for Microsoft.

Creating gadget-like blocks for Windows Home Server 2011 web add-in user interface

DigiMortal — Sat, 25 Feb 2012 10:59:31 GMT

To keep user interface of your Windows Home Server 2011 (WHS) web add-in similar to other parts of UI you may need styled blocks like shown on WHS web interface home page. In this post I will show you HTML mark-up and CSS you need to create your own gadget block.

Example of gadget-like block

Here is the example of custom gadget-like block from the UI of my WHS YouTube Downloader. There is no out-of-box control or some other UI component you can use on different pages that renders you simple area to show some custom content.

I extracted mark-up and styles of gadget and made my own fixes to make block look nice. Although I’m not very happy because of massive use of tables my solution still works and it is simple to use.

Mark-up for gadget-like block

Here is the HTML mark-up for gadget-like block.

<div class="Homepage-GadgetBoxBase Homepage-GadgetBox My-Sidebar">
    <table class="Homepage-GadgetTable">
        <tbody>
            <tr class="Homepage-GadgetTopRow">
                <td class="Homepage-GadgetTLCell"/>
                <td class="Homepage-GadgetTMCell single-line">
                    <a title="Title link description">Title</a>
                </td>
                <td class="Homepage-GadgetTRCell"/>
            </tr>
        </tbody>
    </table>
    <table class="Homepage-GadgetTable">
        <tbody>
            <tr class="Homepage-GadgetMiddleRow">
                <td class="Homepage-GadgetMLCell"/>
                <td class="Homepage-GadgetMCell">
                    <div class="My-Gadget-Content">
                        Content here
                    </div>
                </td>
                <td class="Homepage-GadgetMRCell"/>
            </tr>
        </tbody>
    </table>
    <table class="Homepage-GadgetTable">
        <tbody>
            <tr class="Homepage-GadgetBottomRow">
                <td class="Homepage-GadgetBLCell"/>
                <td class="Homepage-GadgetBMCell"/>
                <td class="Homepage-GadgetBRCell"/>
            </tr>
        </tbody>
    </table>
</div>

You can wrap this box to some base user control and output all container mark-up around inherited controls when render method is called.

Fixing styles

To get the gadget-like block to be rendered correctly we need some additional styles. Looking at source of WHS home page we can see that all gadgets organize their own content containers styling. Here are styles I use for gadget-like block shown above.

You can create your own CSS file for style fixes like this and provide with your add-in installer.

Writing simple named pipes server in C#

DigiMortal — Fri, 24 Feb 2012 11:04:17 GMT

I solved a little problem last night when playing with named pipes. I created named pipe that writes all output to file. Named pipe is opened for all users in machine. In this posting I will show you simple class that works as pipe server.

In .NET Framework languages we can use System.IO.Pipes namespace classes to work with named pipes. Here is my simple pipe server that writes all client output to file.

public class MyPipeServer

{

public void Run()

{

var sid = new SecurityIdentifier(WellKnownSidType.WorldSid, null);

var rule = new PipeAccessRule(sid, PipeAccessRights.ReadWrite,
AccessControlType.Allow);

var sec = new PipeSecurity();

sec.AddAccessRule(rule);

        using (NamedPipeServerStream pipeServer = new NamedPipeServerStream
              ("testpipe",PipeDirection.InOut, 100,
               PipeTransmissionMode.Byte, PipeOptions.None, 0, 0, sec))

{

pipeServer.WaitForConnection();

var read = 0;

var bytes = new byte[4096];

using(var file=File.Open(@"c:\tmp\myfile.dat", FileMode.Create))

while ((read = pipeServer.Read(bytes, 0, bytes.Length)) > 0)

{

file.Write(bytes, 0, read);

file.Flush();

}

Real-life pipe scenarios are usually more complex but this simple class is good to get things running like they should be.

Setting up Windows Home Server 2011 development environment

DigiMortal — Thu, 23 Feb 2012 10:46:29 GMT

For Windows Home Server 2011 (WHS) there are new API-s available you can use to extend WHS web and desktop interfaces. Actually there is no Windows Home Server SDK anymore – now we have common Windows Server Solutions (WSS) SDK that works also for Windows Small Business Server, Windows Storage Server and Windows MultiPoint Server. In this posting I will show you how to create development environment for Windows Home Server 2011.

Step by step guide

To set up development environment for WHS follow the steps given below.

Create new virtual machine for WHS2011. You can use whatever virtualization solution you like (Hyper-V, VMWare Player, VirtualBox). Make sure to give at least 160GB HDD and 2GB of RAM to WHS2011 image. This is needed only during installation. You can later change the size of virtual HDD and then resize it to smaller size.
Install WHS2011. Nothing special here, just follow the installation steps (next-next-next).
Configure WHS2011. Configure RDC access to WHS2011. It faster and way better than those slow and weird sized windows that virtualization software offers you.
Install Visual Studio 2010. Install VS2010 with SP1. Also make sure to apply all important updates to WHS2011 and VS2010.
Download and install WSS SDK. Now download and install Windows Server Solutions SDK.
Create project templates folder for VS2011. Open Windows Explorer and move to folder C:\Users\<MY USERNAME>\Documents\Visual Studio 2010\Templates\ProjectTemplates\Visual C#. Create subfolder names as Windows Server Solution.
Copy WSS templates. Move to folder C:\Program Files (x86)\Microsoft SDKs\Windows Server Solutions\6.1\Templates and copy all subfolders to your VS2010 templates directory you created before.
Check if templates are there. Run VS2010 and open new project dialog. See if all WSS templates are there.

If you did everything right then you should see Windows Server Solutions folder in new project dialog of VS2010. RWW is folder for web add-ins. I’m not sure why the name like this but you can change it if you wish.

That’s it. Now we have virtual machine for Windows Home Server development. You can find more information from Windows Server Solutions SDK site and from We Got Served – site dedicated to Windows Home Server. To get one not-so-easy example take a look at my WHS YouTube Downloader – it is open-source project hosted in Codeplex.

Just released: WHS YouTube Downloader beta

DigiMortal — Wed, 22 Feb 2012 08:03:52 GMT

I just released to Codeplex the first beta of my Windows Home Server 2011 web add-in called WHS YouTube Downloader. Log in to WHS web interface, add YouTube videos to download queue, do something useful while home server downloads videos and watch them later when downloads are done. Sounds easy? Well, okay, it is easy!

Features

Currently there are implemented following features:

web add-in has form integrated to WHS web interface (yes, it’s done using official tools, no hacks),
there is home page gadget that shows contents of download queue,
users can choose shared media library where videos are saved,
users can select video format before file download,
download progress is shown on downloader page,
file downloads are parallel.

Click on image to see it at original size.

Some limitations:

only shared media libraries of Windows Home Server are supported as download folders,
currently all communication between web interface and downloader service host uses port 8732, so make sure this port is not used by any other program or service,
files can be saved in formats that YouTube offers – there is no transcoder that converts between file formats.

I plan to release first stable version during next two weeks. Meanwhile I appreciate all testing feedback and feature requests. And, of course, I will update product documentation to better support home users who are not IT gurus. :)

Windows Home Server needs new licensing scheme

DigiMortal — Tue, 17 Jan 2012 15:04:00 GMT

Fast development of technology and quickly spreading fast internet with new devices and technology open new ways for us to connect our homes with other family members. Windows Home Server is product that needs heavy refresh and one thing that Windows Home Server team must take seriously is changing current very limited licensing scheme. Here is the overview of situation and what needs to be done to get better licensing that fits for families better today.

Family is connected now

One main point that is changed over time: our houses are connected better than before.

By example, my brother has some computers at home, my cousin has some computers at home, my girlfriend parents have some computers at home etc. Homes have good connections now and more people are able to stay connected with my home. People I’m talking about are also called my family.

For some people in family all this computer stuff is complex and they need something simple to share their media with others and to see what others have put online. This is perfect scenario for Windows Home Server.

Why should we all have separated accounts to keep and share same media we all like? Why should we exchange files over chat clients? Why we should use public services that may come and go? We usually don’t share many aspects of our lives with public space. This is where we want one central for family – something that is easy for everyone to use.

Better and cheaper hardware

The other thing is hardware – it is getting more and more powerful. I have 2TB of mirrored disk space available in my home server. It’s huge space for me and I can extend it. If I discard mirroring then my home server may have up to 8TB of free space. Believe me, it’s huge task for me and my family to get this 2TB of space filled with something valuable.

I am sure that during next couple of years way more storage will be available to buy for same price. Also other hardware is getting cheaper and cheaper. And also web connections getting better and better. It means that we have more and more devices in our homes that we want to connect.

Big picture

This is where we are standing now:

we have good internet connections at our homes,
we are able to but powerful hardware that we are not able to fully use with only small subset of our family,
kids and their parents know way more about computers than before,
we have different devices we use to browse the web and communicate with each other,
still family IT-guy is usually almost the only one who manages devices of more than one home,
families produce way more multimedia than before and members of family want to share their media between each other,
it is also good to take control over backups and maintenance of all family computers so also other homes that form my family have their computer safe and updated.

As you can see, situation is changed.

New licensing model

New licensing model for Windows Home Server should be package based like it is for Windows Server. Base package should be 10 licenses as it is right now. But there must be option to buy more licenses. Five license packs should be fine. It it is possible to buy one license at time it is also okay. It may even be better because then we can but exactly the number of licenses we need.

Creating dynamic pivot reports on SQL Server

DigiMortal — Mon, 02 Jan 2012 10:08:54 GMT

In one of my current projects I have some pivot reports that show count of issues in different states. Grouping depends on report. States are dynamic – admins can define new states and save them to states table. This means that I cannot hardcode names of states to queries. Instead I need dynamic pivots. In this posting I will show you how to write reporting procedures that offer dynamic pivoting capabilities.

The trick here is to create dynamic list of all possible states and use this list in dynamically generated pivot query. Here is fragment of my database, names of tables should be self-describing.

Here’s the query:

CREATE PROCEDURE XSP_REPORT_REQUESTS_BY_CATEGORY
AS
BEGIN

DECLARE @PivotColumnHeaders VARCHAR(MAX)
SELECT @PivotColumnHeaders =    COALESCE(
@PivotColumnHeaders + ',[' + cast(STATUS_NAME as varchar) + ']',
'[' + cast(STATUS_NAME as varchar)+ ']'
   )
FROM DOC_STATUSES

DECLARE @PivotTableSQL NVARCHAR(MAX)
SET @PivotTableSQL = N'
SELECT
*
FROM
(SELECT
    dc.CATEGORY_NAME AS [Category],
    ds.STATUS_NAME As name,
    req.ID as ID
FROM
    REQUESTS_FOR_PROPOSAL req
    INNER JOIN DOC_STATUSES ds ON
        req.STATUS_ID = ds.ID
    INNER JOIN DOC_CATEGORIES dc ON
        req.CATEGORY_ID = dc.ID
) AS Source
PIVOT(
    COUNT(ID)
    FOR name IN ('+@PivotColumnHeaders+')
) AS PIVOTTBL'

EXECUTE(@PivotTableSQL)

END

Output of this reporting procedure is table like this:

I don’t like this dynamic SQL in stored procedure because it can be hard to debug. But this far this solution works fine for me and I can always use views to get more complex querying logic out from reporting procedures.

ASP.NET MVC: Helper method to display date ranges

DigiMortal — Sat, 31 Dec 2011 10:53:34 GMT

I have events web site where I want to show events start and end time to visitors. I wrote simple extension method called DisplayTimeRange() to display event time range on user-friendly manner. My goal is to show times as 01.01.2012 10:00 – 14:00 and 01.01.2012 15:00 – 01.03.2012 18:00. It’s practically displaying time ranges is shortest possible way. In this posting I will show you how to do it using extension method.

For events that happen only on one date I want output like this:

For events that cover more than one date I want output like this:

Here is my extension method for HtmlHelper. I called it DisplayDateRange and currently it generates output like shown above (styling depends on you).

public static MvcHtmlString DisplayDateRange(this HtmlHelper helper, DateTime from, DateTime to)

{

var buffer = new StringBuilder(100);

buffer.Append(@"<div class=""dateRange"">");

buffer.Append(from.ToShortDateString());

buffer.Append(" ");

buffer.Append(from.ToShortTimeString());

buffer.Append(" - ");

if (from.Date == to.Date)

{

buffer.Append(to.ToShortTimeString());

}

else

{

buffer.Append(to.ToShortDateString());

buffer.Append(" ");

buffer.Append(to.ToShortTimeString());

}

buffer.Append("</div>");

return new MvcHtmlString(buffer.ToString());

}

This extension method can be easily extended also to nullable DateTime types if you need it.

DateTime formatting may seem not so perfect but it was the only way how to avoid weird long date and time outputs with seconds (we really don’t need seconds here). If you have good idea about how to format dates shorter in code then feel free to drop me a comment here.

Windows Azure error: An unsupported response was received. The response header 'MSDeploy.Response' was '' but 'v1' was expected.

DigiMortal — Sat, 31 Dec 2011 10:20:00 GMT

You may get the following error when deploying your web application from Visual Studio to Windows Azure using WebDeploy:

Remote agent could not be contacted. Make sure the remote agent service is installed and started on the target computer.

An unsupported response was received. The response header 'MSDeploy.Response' was '' but 'v1' was expected.
The request was aborted: The request was canceled.
COM object that has been separated from its underlying RCW cannot be used.

If you monitor your HTTPS traffic you can find out that response to WebDeploy request was error 401 (not authenticated). Although I don’t know what is the exact source of this error there is simple solution: close Visual Studio and then run it again. Now you should be able to deploy your application.

The selected database contains foreign keys that create a cycle

DigiMortal — Fri, 30 Dec 2011 09:41:17 GMT

You may get the following error when creating data scripts with MSSQL 2008: The selected database contains foreign keys that create a cycle. Publishing data only is not supported for databases with cyclical foreign key relationships. This problem is caused by self-referencing tables and it is given even if you don’t export data from one of such tables. Here is simple and very dirty solution.

If some of tables in the list of exported tables has circular references or some of these tables refers to table with circular references then this error occurs. As a very dirty workaround you can temporarily remove circular foreign keys and create them later again. Not very nice solution but works for me.

Deploying independent web applications to Windows Azure using single web role

DigiMortal — Thu, 29 Dec 2011 18:57:17 GMT

I found very good blog post by Andy Cross’ Blog where he describes how to deploy multiple web sites in a single Windows Azure web role. I like the idea but there are some things that should be understood and done differently if you plan to use same web role for totally different web applications that you want to run on your Windows Azure instance. In this posting I will show you how to deploy independent web applications to Windows Azure instance using single web role.

Problems with independent sites

If your sites are in same solution or they are related to each other then use the solution than Andy Cross provides. But if you want to run different sites on same Windows Azure instance you have some things to consider first:

Adding different sites to same solution is not good idea because sites can belong to different projects maintained by different people.
Usually code is kept in source code repository and you don’t want to have files of one project in folder of other.
You don’t always want to build all sites together and then publish them to cloud again.

Having these considerations in mind we can go step further from Andy’s solution.

Using special deployment project for same server sites

My solution is simple. I create new Windows Azure project on Visual Studio 2010 and add one WebRole to this solution. I call it DummyRole because it does practically nothing. You can use this project to redirect browser from your <something>.cloudapp.net address to default site.

Image on right shows my folder structure:

AzurePublishing – this is solution folder,
DummyRole – this is dummy web role mentioned before (I was not able to modify cloud project so it doesn’t have reference to some project in solution),
MsdnAzureDeploy – this folder contains cloud deployment project,
packages – this is created by Visual Studio, I left it there,
Publish – root folder for web applications that are deployed with web role,
www.example.com – publishing folders for web sites you want to deploy to server.

Every web site has its own folder under Publish folder and you can use Visual Studio web application publishing to publish web site files to correct subfolders.

Now it’s time to modify our deployment package contents. You can see here web role called Redirect (this is the dummy one) and service configuration files. There are no publishing folder visible because cloud projects doesn’t support custom folders.

Expecting that your cloud project is set up correctly and you can deploy dummy site with no problems, we can take the next step and modify our service definition.

We have to add our publishing folders to service definition manually. Each web application folder is separate site in our case.

Here is the example content for service definition file:

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

<Sites>

</Bindings>

</Site>

</Bindings>

</Site>

</Bindings>

</Site>

</Sites>

</Endpoints>

</Imports>

</WebRole>

</ServiceDefinition>

Some things to note:

our end-point is port 80 (HTTP)
dummy web app has no host header specified and it is accessible from <something>.cloudapp.net,
our two example web applications have host headers specified and during deployment IIS will be automatically configured so addresses point to correct applications (you have to make CNAME records in your domain keeper site),
publishing folders location are relative to deployment project folder.

Make sure you have all paths correctly specified and try to deploy your cloud solution to Windows Azure. If your deployment succeeds then try to access your sites by URL-s you gave in service definition file and make sure everything works normally.

Conclusion

Although multiple web roles on same server are not supported by Windows Azure we can gather our sites under same web role and publish them all together. The solution shown here is not perfect but it works. Be careful with deployments and make sure your deployment packages contain always the versions that are allowed to be published. Also make your deployments to test instance first, test everything and then put your test instance to production.