Damir Dobric Posts

WebSockets in ASP.NET and JavaScript

2012-01-29T17:55:17Z

Windows 8 operative system will provide the full support for WebSockets (see also WebSockets.org). Simplified, It is a web technology which provides full-duplex communication over TCP initiated by preceding HTTP request. There are many innovative and amazing scenarios which can be easily achieved by using this technology. Fro example it is possible to implement chat-scenarios form browser to browser in the real time. previously, such scenarios by using various polling algorithms. As described in this post Microsoft has implemented WebSockets on different places in Windows 8 and .NET 4.5 Stack. This post describes how Web Socket can be hosted in an ASP.NET application and how it can be consumed by browser as a client.
Following are topics covered by this post:

1. What do you need to get started?
2. How to initialize Web Socket protocol
3. How to implement Web Socket Handler
4. How to initialize custom Web Socket Handlers
5. How to receive and send messages
6. How to shut down custom Web Socket Handler
7. How to implement JavaScript client

What do you need to get started?

Sample shown in this post requires Windows8 (client or server), IE10, IIS8 and ASP.NET 4.5.

Before you start you need to enable WebSocket Protocol at the machine. To do that, go to windows features, expand World Wide Web Services | Application development Features and activate WebSocket Protocol.

How to initialize WebSocket protocol?

Upcoming version of System.Net, which is generally used by ASP.NET contains on the HttpContext the new property “IsWebSocketRequest” (since ver. 4.5). This property is internally mapped to property System.Net.HttpListener.IsWebSocketRequest. Wherever there is an access within ASP.NET application to HttpContext instance, you can check if the request is of WebSocket -type:

if(context.IsWebSocketRequest){
// Do something
}

This single line of code is very simple one, but there are few more or less undocumented facts behind the scene, which sometimes might be useful. When the snippet shown above is executing the IIS is not executing WebSocket-stream as you might expect. This is why IsWebSocketRequest-name is a bit wired. WebSocket is TCP based network stream which is different from common HTTP request which can be cached by HttpContext. This sounds wired, but it is not. Before WebSocket communication is started it has to be initiated. Because WebSocket protocol is an upgrade to HTTP, the spec requires using of HTTP to initiate WebSocket protocol.
Exactly this HTTP request is defined as WebSocketRequest. After successful completion of this request, WebSocket full-duplex is established.

WebSocketRequest is the commong HttpRequest with a little sugar. Here is an example of the real WebSocketRequest. When such request is sent by client the property IsWebSocketRequest will return true.

Cache-Control: no-cache
Connection: Upgrade
Upgrade: Websocket
Host: daenetwebsocketconsumer
User-Agent: Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; WOW64; Trident/6.0)
Origin: localhost
Sec-WebSocket-Key: cDdQwtBTScmm1pzAJWvC/g==
Sec-WebSocket-Version: 8

Implementation of this property will Internally do following check in pseudo-code:

IF Headers.Exists(“Upgrade”) AND HEADERS[“UPGRADE”].ToLower() == “websocket” THEN RETURN true

Another two properties Sec-WebSocket-Key and Sec-WebSocket-Version are also part of the request , but they will not be checked by this property. They will be internally handled to ensure the proper and compatible protocol communication.

The first one holds unique client context, so different clients can be distinguished. It represents some kind of session key.
The second one defines the WebSocket implementation version. The current working draft provides a number of different versions in the specification. For example at the day of writing of this post the last specified version is called HyBi 17. The Sec-WebSocket-Version would have a value 13 for HyBi 17. In the example above I used the Internet Explorer 10 (IE10) which obviously sends the version 8. According to specification number 8 is related to HyBi 10, which is currently supported by IE10 on Windows 8 preview.

To setup WebSocket-Duplex in ASP.NET application create one for example MySocketInitializer.ASHX (IHTTPHandler) file and put following code in there:

public void ProcessRequest(HttpContext context)
{
           if(context.IsWebSocketRequest)
           {
              context.AcceptWebSocketRequest(new YourWebSocketHandlerImplementation());
           }
}

The implementation of method IHttpHandler.ProcessRequest will invoke a (new) method AcceptWebSocketRequest by giving the instance of your WebSocket implementation (YourWebSocketHandlerImplementation ). This line of code starts up the Web Socket protocol.

How to implement Web Socket Handler?

The web socket handler is in ASP.NET stack the concrete implementation of abstract class Microsoft.Web.WebSockets.WebSocketHanlder. Note that there is also an implementation of the same functionality in System.ServiceModel.WebSockets.WebSocketService. The second one is the implementation of the same functionality in WCF. In this post I will focus on the handler implementation only.
Following snippet shows the declaration of the handler class.

namespace Microsoft.Web.WebSockets
{
    public class WebSocketHandler
    {
        public WebSocketHandler();

        public Exception Error { get; set; }
        public int MaxIncomingMessageSize { get; set; }
        public AspNetWebSocketContext WebSocketContext { get; set; }

        public void Close();
       public virtual void OnClose();
        public virtual void OnError();
        public virtual void OnMessage(byte[] message);
        public virtual void OnMessage(string message);
        public virtual void OnOpen();
        [EditorBrowsable(EditorBrowsableState.Never)]
        public Task ProcessWebSocketRequestAsync(AspNetWebSocketContext webSocketContext);
        public void Send(byte[] message);
        public void Send(string message);
    }
}

As you see there are few virtual methods which you should/can implement.

OnOpen

Method OnOpen should be used to perform any kind of initialization. This can be for example initialization of variables which will hold running sessions.

OnClose

In opposite, the method OnClose should be used clear the state of the handler when closed. Note that when OnClose is called, the handler is still running. That means, you can send messages within this methods to any connected client. For example this message can be something like: “bye – I’m going offline”.

OnMessage

This method should be overwritten, because this is the place where to catch messages sent from WebSocket clients.

Send

The method send is solely used to send the message to dedicated client. Note that architecture of Web Sockets in ASP.NET provides one WebScoketHandler instance per client. For example, if you implement the browser-multiplayer-game every player will get its own WebSocketHander instance.

How to initialize the custom Web Socket Handler?

When implementing the handler, there are few important tasks to do:

1. Pass arguments in constructor.
2. Add the WebSocketHandler instance to the list of connected instances
3..Notify clients

It is mostly required to grab same data from HTTP request and pass it as argument to the WebSocket constructor. For example in one game this could be the name of the user: In ASHX handler (IHTTPHandler) we would initialize the WebSocketHandler as follows:

public void ProcessRequest(HttpContext context)
{
if(context.IsWebSocketRequest)
{
context.AcceptWebSocketRequest(
new YourWebSocketHandlerImplementation(context.Cookies[“UserName”)));
}
}

This is the place where you can decouple HTTP from WebSocket protocol. Here you can grab everything you need from request and pass it to WebSocketHandler.
As next we need to persist the client WebSocket session. Following snippet shows the full implementation of the WebSocketHandler:

public class YourWebSocketHandlerImplementation : WebSocketHandler

{

private static WebSocketCollection m_Sessions = new WebSocketCollection ();

public string m_Player;

public YourWebSocketHandlerImplementation (string argument)

{

m_Player = argument;

}

public override void OnOpen()

{

m_Sessions.Add(this);

m_Sessions.Broadcast(“New player joined the game”));

this.Send(“Welcome new player”);

}

As already mentioned we can design the constructor as we want. This is the place where we receive all required parameters from IHTTPHandler. In the method OnOpen we cover three tasks. First we persist the instance of the handler to list of type WebSocketCollection. You do not have to do it this way, but if you wants to broadcast messages to all connected clients, this class provides a helpful method Broadcast(). This method automatically enumerates all WebSocketHandler instances in the list and sends the message to all of them. With following line of code we notify all already connected players that new player has joined the game:

m_Sessions.Broadcast(“New player joined the game”));

If we want to send the message to dedicated client you can do it as follows:

this.Send(“Welcome new player”);

How to receive and Send messages

Till now we have seen how to start up and how to initialize the custom WebSocketHandler. Now we are ready to receive messages from connected clients. To do that you have to override the method OnMessage.

public override void OnMessage(string message)

{

m_Sessions.Broadcast(“User” + m_Player + “ sent following message: “ + message));

m_Sessions.Send(“You sent: “ + message);
}

In the first line we broadcast the received message to all connected users. In the second line we send echo of the message to the sender. This all is fine, but in the real world, you will have to deal with more complex messages. In fact you will always have to implement some kind sub protocol on top of Web Socket.
The easiest way to do that is to use JSON.

In my example I want to give the client the ability to send message to some specific user or to broadcast the message to all users. To do this I invented a simple protocol which can be modeled as follows:

enum MessageType
{
   Send,
   Broadcast,
   Join,
   Leave
}

class Message
{
public MessageType Type { get; set; }

public string Value { get; set; }

public string UserName { get; set; }

}

The class MessageType defines different types of messages. By this attribute I’m able to style the message by proprietary type.Depending on that value handler and client can perform some action. The message itself contains the UserName property which defines the name of the player in the game. The MessageType defines the type of message and Value is the message itself.

When the message is received by method OnMessage we can deserialize it as follows:

public override void OnMessage(string message)
{
    var ser = new JavaScriptSerializer();

    var msg = m_Ser.Deserialize<Message>(message);
    switch (msg.Type)
    {
                case MessageType.Broadcast:
                    m_Sessions.Broadcast(m_Ser.Serialize(new
                    {
                        Type = msg.Type,
                        UserName = m_Nick,
                        Value = msg.Value
                    }));

                    break;
                case MessageType.Send:
                    var channel =
                    m_Sessions.FirstOrDefault(n => ((YourWebSocketHandlerImplementation)n).m_Nick == msg.UserName);
                    if (channel != null)
                        channel.Send(m_Ser.Serialize(new
                        {
                            Type = msg.Type,
                            UserName = msg.UserName,
                            Value = msg.Value
                        }));
                    break;
                default:
                    return;
            }
        }
}

In this example the JavaScriptSerializer is used to materialize the typed instance message send over WebScoket protocol. If the message is of type Broadcast, it is sent to all connected clients. If it is of type Send, then we grab the appropriate WebSocket instance from the list of all sessions and use it to send the message to this dedicated user.

How to shut down the Web Socket?

If required you can perform any destructing operation in the method OnClose. There is nothing what you have to implement in this method. Depending of your application you can implement anything here. Following example shows how to notify all other connected users that one user is going down.

public override void OnClose()
{
m_Sessions.Broadcast(m_Ser.Serialize(new

{

type = MessageType.Leave,

from = m_Nick,

value = m_Nick + " has left the server."

}));

m_Sessions.Remove(this);
}

Note that method close as any other method in the Web Socket Handler is tight to one session. While executing OnClose the socket is still fully functional. That means you can use it to send messages. In example above we broadcast one message to all connected users and finally remove the socket instance from the list of active sessions.

How to implement JavaScript client?

To this point this article briefly described how to implement the custom WebSocketHandler and how to build the custom messaging (protocol) on top of WebSocket protocol. This topic describes how to implement JavaScript client which can communicate with your custom socket implementation.
In general the WebSocket API should be supported by browsers with HTML5 support. The browser which I used in this sample is IE10, which supports HyBi 10 (or Ver. 8) od WebSocket spec.

Open Web Socket connection

To open the WebSocket connection create the instance of WebSocket API:

var connection = new WebSocket(“ws://websockethost:80/daenet.websocketsample/MySocketInitializer.ashx”);

The argument in constructor is the implementation of IHTTPHandler interface, which is responsible to register the custom implementation of the WebSocket.
After executing of the line above, the underlying implementation of WebSocket protocol in the browser will send the WebSocket compatible request (as described above) to url :“ws://websockethost:80/daenet.websocketsample/MySocketInitializer.ashx”:

The figure below shows simplified diagram of sequence initiated by creating WebSocket instance:

As you see when the WebSocket instance i s created browser will implicitelly send WebSocketRequest to ASHX file and ASP.NET will execute method ProcessRequest (see above “How to initialize WebSocket protocol”). This method will install the Web Socket Handler which will handle all messages.
Note that after this sequence one permanent TCP connection is open between client and web server.

Receive Message

Now we can hook the handler which will be invoked each time some message is received:

connection.onmessage = function (message) {
var data = window.JSON.parse(message.data);
};

Optionally if required the received message can be deserialized in a type by calling JSON.parse(message).
The figure below shows the sequence initiated when the method WebSocketHanlder.Send() is invoked at the server side. Note that the message send from server is transferred through open TCP connection.

Send Message

Following snippet shows how to send the message:

connection.send(“hello”);

And this example shows how to send the message formatted as JSON.

connection.send(window.JSON.stringify({ type: 1, Value: “Hello”, UserName = “damir” }));

The diagram below shows the sequence initiated when the send function is invoked.

Finally, when the socket needs to be closed following code has to be executed:

connection.close();

When the function close() is invoked in Javascript, the call is propagated to server side and your implementation of the WebSocketHandler.OnClose() is invoked (see “how to shut down the web socket”).

Putting all together

Following picture shows very simple application in engineer design which demonstrate using of web sockets. The application demonstrates using of all important WebSocket functions. It implement some kind of chat application. Following picture shows all supported scenarios.

Following HTML/Javascript code implements all described at this picture. The application requires the WebSocket Handlerwhich we described in this article.

<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
    <title>WebSocket Sample </title>
    <script src="Scripts/jquery-1.6.3.min.js"></script>
    <script src="Scripts/jquery.cookie.js" type="text/javascript"></script>
    <script src="Scripts/json2.min.js" type="text/javascript"></script>
    <script>
        var username;
        $(function () {
            "use strict";
            username = prompt("Please enter your username:");
            $.cookie('username', username);

            $("#userName").val(username);

            // Machine ‘websockethost’ must support WebSocket protocol. For example Windows 8 with IIS8
            var host = "ws://websockethost:80/daenet.websocketsample/MySocketInitializer.ashx";

            $("#join").click(function () {

                var connection = new WebSocket(host);

                connection.onmessage = function (message) {
                    var data = window.JSON.parse(message.data);
                    $("<li/>").html("[" + data.UserName + "]: " + data.Value).appendTo($("#messages"));
                };

                $("#broadcast").click(function () {
                    connection.send(window.JSON.stringify({ type: 1, Value: $("#msg").val() }));
                });

                $("#send").click(function () {
                    connection.send(window.JSON.stringify({ type: 0, Value: $("#msg").val(), UserName: $("#nick").val() }));
                });

                $("#close").click(function () {
                    connection.close();
                });
            });

        });
</script>
</head>
<body>
    <h2>Daenet WebSocket Sample</h2>
     <form>
         <h2 id="username" style="font-family: 'Segoe UI'">user: [<input type="text" id="userName" />]
        <input type="button" id="join" value="Join session" /></h2>

        <label for="msg">Message to be sent:</label>
        <input type="text" id="msg" size="50" />
        <br />
        <input type="button" id="broadcast" value="Broadcast message to all users" /> 
        <br/>
      <label for="nick">User to send the message:</label>
        <input type="text" id="nick" value="user?" />
        <input type="button" id="send" value="Send message to user" />
        <br />
         <input type="button" id="close" value="Close session" />
        <br />

    </form>

    <ul id="messages">
    </ul>

</body>
</html>

Troubleshooting Windows Azure drive initialization

2012-01-16T21:58:34Z

Issue I: Drives do not support https

Exception of type 'Microsoft.WindowsAzure.CloudDrive.Interop.InteropCloudDriveException' was thrown.

[HttpException (0x80004005): ERROR_HTTPS_NOT_SUPPORTED]

Solution

Use HTTP be removing ‘S’ (see below).

Issue II: UnauthorizedAccessException on local cache initialization:

When you try to initialize the drive in Windows Azure you will implement peace of code like this one:

LocalResource localCache = RoleEnvironment.GetLocalResource("MyAzureDriveCache");

CloudDrive.InitializeCache(localCache.RootPath, localCache.MaximumSizeInMegabytes);

Depending on type and value of ‘MyAzureDriveCache, the cache initialization of the drive can succeed or fail. If this variable is a string which defines the physical path like “c:\mycachefolder”, you will probably run into following issue.

[UnauthorizedAccessException]
Cannot access the path … Access denied.

Solution:

If the drive mount is created within IIS host, this will for sure fail. To avoid this issue, you have to ensure that MyAzureCache is defined in config-Resources and not in settings.

This is how this does looks like in ServiceDefinition.csdef:

    <LocalResources>
      <LocalStorage name="MyAzureDriveCache" cleanOnRoleRecycle="false" sizeInMB="100" />
    </LocalResources>

Issue III:

Cannot combine incompatible absolute URIs base 'http://xy.blob.core.windows.net/' relative 'http://xy.blob.core.windows.net/documents/drive.vhd'.When trying to combine 2 absolute URIs, the base URI should be a valid base of the relative Uri.

You have used the Drive URI like:
http://xy.blob.core.windows.net/documents/drive.vhd

You should use following URI:
documents/drive.vhd

Please note that following is not allowed too (note the slash at the beginning): /documents/drive.vhd

Issue IV: How to upload Page-Blob

After all, when you think all issues have been fixed, you might get following error:

ERROR_BLOB_NOT_PAGEBLOB

This is one of errors which really describes the exact problem. You are trying to mount to blob which is uploaded as block-blob and not as Page-Blob.

Issue V: How to upload huge blobs?

Take a look on Kevin's sample which asynchronously transfers huge amount of data:
http://blogs.msdn.com/b/kwill/archive/2011/05/30/asynchronous-parallel-block-blob-transfers-with-progress-change-notification.aspx

Windows Server AppFabric v1.1 Setup Issue

2012-01-16T13:16:57Z

If you had previously installed Windows Server AppFabric 1.0 (WSA 1.0) the update to v 1.1 can fail. Before you start the installation of WSA 1.1 be sure that the Task Scheduler does not contain the task with the name “Consolidator”.

If this task does exist, remove it and then start the installation.

Service Bus MessageQueue Error issuing token

2012-01-14T22:51:33Z

When you try to receive the message from Windows Azure Service Bus queue or to send it you might get some error like 'Error:Code:403’.

This can happen if you try to perform any queue related operation like:

BrokeredMessage message = myMessageReceiver.Receive(new TimeSpan(hours: 0, minutes: 0, seconds: 60));

The full error you get as exception looks like:

The token provider was unable to provide a security token while accessing 'https://xsamples-sb.accesscontrol.windows.net/WRAPv0.9/'. Token provider returned message: 'Error:Code:403:SubCode:T0:Detail:ACS50000: There was an error issuing a token. ACS60000: An error occurred while processing rules for relying party 'http://xsamples.servicebus.windows.net/demoqueue' using issuer 'LOCAL AUTHORITY'. ACS60001: No output claims were generated during rules processing. :TraceID:4b8f5f82-b688-43a3-9cee-95d7d63b5e0f:TimeStamp:2012-01-14 22:24:11Z'.

This will probably never happen if you use default issuer key and and issuer name “owner”. This account is properly setup for you. The good thing is that this account has all permission on ServiceBus. That are: Manage (can do anything like create queue), Send (can send messages) and Listen (can receive messages).

If you have seen exception shown above, you are probably connecting to ServiceBus by user which you have created in ACS. The reason for this error is missing association between ServiceBus application (under this name ACS sees service bus in your namespace).

To fix this go to ACS management portal in context of namespace of your service bus

and select “Relaying Party Applications”

Then select ServiceBus application :

Then scroll to the end to “Role Groups” and notice the check-box state next to your role group. The default one is “Default Rule Group for ServiceBus"
which is provisioned when you create your service bus namespace. The just next one “Sender and Receiver” is custom group, which defines the account which can send messages only (this permission is the reason why I have created it).

I have forgotten to check the box . That means I didn’t associate account in that group to ServiceBus. If this is the case, the strange error shown above will appear.

Hope this helps

Working with Windows Azure Federations

2012-01-14T11:31:45Z

Windows Azure SQL Server provide powerful “shard” - database architecture SQL Azure provides horizontal partitioning by using federations feature which has been briefly introduced by Cihan in this post. My intension in this post is to show how to make usage of this feature within a .NET application.

For this demo I created one federation:
Federation Name: Federation2
Distribution Name:FED2DIST1

Click on federation to open federation members.
Previously I have created the table in the originally only existing member (LOW)

USE FEDERATION [Federation2] ([FED2DIST1] = -9223372036854775808) WITH FILTERING = OFF, RESET
GO

CREATE TABLE dbo.Table1(
        ID bigint NOT NULL,
        Column1 nvarchar(50) NULL,
        Column2 nvarchar(15) NULL,
CONSTRAINT [PK_Table1] PRIMARY KEY CLUSTERED
(
     ID ASC
)
) FEDERATED ON ([FED2DIST1] = ID)
GO

This default member will hold all records with -9223372036854775808 < ID < 5,
because is is currently spitted to maximum with ID = 5. Fore demo purposes I spitted the federation to 4 members as shown at the picture below:

Now, the crucial question is “how to write an application which is able to deal with all this artifacts”?
Following code shows how to read partition information:

using (SqlCommand cmd = connection.CreateCommand())
{

// First set the connection to Federation Root

cmd.CommandText = "USE FEDERATION ROOT WITH RESET";
cmd.ExecuteNonQuery();

// Now we will retrieve federation specific data
cmd.CommandText = @"SELECT f.name, fmc.federation_id, fmc.member_id, fmc.range_low, fmc.range_high " +
"FROM sys.federations f " +
"JOIN sys.federation_member_distributions fmc " +                                                            "ON f.federation_id=fmc.federation_id " +
"ORDER BY fmc.federation_id, fmc.range_low, fmc.range_high";

using (SqlDataReader reader = cmd.ExecuteReader())
{
     Console.WriteLine("Federation Name\t\tFederation ID\tMEMBER ID\tRANGE_LOW\tRANGE_HIGH");

     while (reader.Read())
     {
         Console.WriteLine(reader["name"] + "\t" +

reader["federation_id"] + "\t" +

reader["member_id"] + "\t" +

reader["range_low"] + "\t" +

reader["range_high"] + "\t");

}

Following picture shows the result:

In fact the only new thing how have to know is statement: “USE FEDERATION”. This setups your connection to specific federation inside of database.
Similarly you can use following code to read data from specific table inside of federation. Note that different federations can have different schemas!

private string federationName = "Federation2";

private string distributionName = "FED2DIST1";

private long federationKey = 5; // Start value of one distribution. This would be a member 5-7 in th epicture above

// Before we start to work with federation, we have to execute ‘USE FEDERATION’ statement

cmd.CommandText = "USE FEDERATION " + federationName +
"(" + distributionName + "=" + federationKey + ") WITH RESET, FILTERING = OFF";
cmd.ExecuteNonQuery();

// Now, all statemens are routed to selected federation.

cmd.CommandText = @"SELECT * FROM table1";

using (SqlDataReader reader = cmd.ExecuteReader())

{

while (reader.Read())

{

//...

}

Federation Pricing: http://blogs.msdn.com/b/cbiyikoglu/archive/2011/12/12/billing-model-for-federations-in-sql-azure-explained.aspx

Failed to initialize Windows Azure storage emulator

2012-01-13T16:21:38Z

When working with Storage Emulator you might get following error when trying to start the application locally (F5).

Windows Azure Tools: Failed to initialize Windows Azure storage emulator. Unable to start Development Storage. Failed to start Storage Emulator: the SQL Server instance ‘localhost\SQLExpress’ could not be found. Please configure the SQL Server instance for Storage Emulator using the ‘DSInit’ utility in the Windows Azure SDK.

This will happen if the Windows Azure SDK didn’t installed correctly or if SQL database has not been previously installed at the development machine. To fix the problem open WinAzure SDK command prompt and start DSInit as shown below:

Syntax:
DSInit [/sqlinstance:<DatabaseInstanceName> | /server:<Machine name>] [/silent] [/forcecreate]

In my case: Dsinit /server:AZURETRAINING

If all works fine, following popup should appear:

DiagnosticMonitor takes too long to start

2012-01-06T11:45:39Z

If you try to start diagnostic monitoring by calling DiagnosticMonitor.Start(..) it can happen that this call takes too long (2 Minutes). After this time the call will just return successfully. Unfortunately you will figure out later that diagnostic monitoring does not work at all.

In fact there is not any error and nothing works.

This will happen if you setup an not existing account name in diagnostic connection string. The TCP/HTTP call will in this case try to resolve the storage with THEACCOUNT prefix (which does not exist) and fail time-out.

Unfortunately the Start() will return with no exception.

<Setting name="Microsoft.WindowsAzure.Plugins.Diagnostics.ConnectionString"
value="DefaultEndpointsProtocol=https;AccountName=THEACCOUNT;..

You can figure out this behavior in console of Compute Emulator.

How to cleanup IntelliTraces of WindowsAzure application

2012-01-06T10:10:56Z

When working with IntelliTrace Visual Studio will download required files from Windows Azure related store. These files are in general large and should be cleaned-up regularly. Files are downloaded on demand within Server Explorer as shown at the next picture:

The download location of files is:

C:\Users\youraccountname\AppData\Local\Temp\Downloaded WAT Diagnostics Logs

The picture below shows how much space these just few deployments can take:

You can dele them. If some of them are still in use skip deletion or close VS instance which keeps them open.

Windows Azure Role Deployment failure

2012-01-05T22:27:45Z

If you get this error while deploying the role to Windows Azure, you might be wandering.

Error: Windows Azure is currently performing an operation on this deployment that requires exclusive access. Http Status Code: Conflict OperationId: …

Solution:

The solution is very simple one. You have probably forgotten to setup the right storage account in the role configuration:

<Setting name="CloudStorageAccount" value="UseDevelopmentStorage=true" />

Fun with Visual Studio 2010 compiler

2012-01-04T10:38:16Z

I have following line of code, which obviously cannot be compiled, because the variable x has already been declared.

This is what I thought too. So, I was looking for declaration and didn’t find it. Hmmm?!?
So, the only reasonable explanation of this could be, that I just declare it but cannot find it. Hmmm, not very possible, but let’s assume it.
Ok, if the variable has been declared it must be possible to declare the other one and assign existing ‘x’ to it:

Uupps.

How to draw TextControl in WPF?

2011-12-31T00:31:13Z

When working with WPF and highly 2D graphic oriented applications, you will definitely have a requirement to mix the text with graphic.
For example you want to draw a line an write some text on the top of line.
It is not a big science to make this somehow working. However the programming model to create one line and one peace of text are a bit different. This can make your code ugly.

For example, imagine you are drawing a line and wants to put the text at the line. Next code sample shows how to draw the line.

Line line1 = new Line()
line1.X1 = xMin;
line1.Y1 = yMin;
line1.X2 = xMax;

line1.Y2 = yMin;

line1.Stroke = new SolidColorBrush(controller.ViewData.AxisColor);

line1.StrokeThickness = 2;

m_Grid.Children.Add(line1);

Now, it you would like to to have a same code to draw the text. For example:

TextBlock text = new TextBlock(number, xMin, yMin, "Segoi UI", fontSize, color);

m_Grid.Children.Add(text);

Unfortunately this will not work, because there is no Text Control which would work this way. To make it working you could put a canvas-element around parent (in this sample m_Grid) and set properties like Canvas.Left, Canvas.Top etc..This is a nice workaround, but if your graphic elements behave in a dimension which is not a pixel (for example millimeter), such kind of code would be very difficult and probably ugly for implementation at least when you have to rescale form your dimension back to pixels.

Solution
We implemented the class DrawableTextBlock which is common TextBox with few more arguments.

The custom control has to derive from FramworkElement. Adiitionally it has to override VisualChildrenCount and GetVisualChild.
In the constructor we create VisualCollection and put a single element which is drawn text.

/// <summary>
/// Creats the instance of drawable text control.
/// </summary>
/// <param name="text"></param>
/// <param name="x">X-Position of control</param>
// <param name="y">y-Position of control</param>
/// <param name="font">The font family like 'Verdana', 'Segoi UI', etc.</param>
/// <param name="fontSize">The size of the font.</param>
/// <param name="color">The color of the font.</param>
public DrawableTextBlock(string text, double x, double y, string font, double fontSize, Color color)
{
m_Elements = new VisualCollection(this);
m_Elements.Add(createDrawingText(text, x, y, font, fontSize, color));
}

The text is drown as follows.

        private Visual createDrawingText(string text, double x, double y, string font, double fontSize, Color color)
        {
            FormattedText formattedText = new FormattedText(

text,

CultureInfo.GetCultureInfo("en-us"),

FlowDirection.LeftToRight,

new Typeface(font),

fontSize,

Brushes.Black);

DrawingVisual drawingVisual = new DrawingVisual();

using (DrawingContext drawingContext = drawingVisual.RenderOpen())

{
drawingContext.DrawText(formattedText, new Point(x, y));

return drawingVisual;

}

Two remaining methods must be overridden to make all working:

/// <summary>

/// Mus be override to provide visuals to be rendered.

/// </summary>

        protected override int VisualChildrenCount
        {
            get { return m_Elements.Count; }
        }

/// <summary>

/// Gets the specific visual.

/// </summary>

/// <param name="index"></param>

/// <returns></returns>

protected override Visual GetVisualChild(int i)
{

if (I < 0 || i>= m_Elements.Count)

            {
                throw new ArgumentOutOfRangeException();
            }

return m_Elements;

}

The full sample for this post can be downloaded here.

Windows Server AppFabic 1.1

2011-12-24T09:39:34Z

AppFabric 1.1 is the new version of Windows Server AppFabric 1.0 first release. The new release 1.1 provides new features, many bug fixes and improved memory management.

Graceful shutdown

One of my favorite features is so called Cache Graceful Shutdown. If you never used the cache in cluster this feature will not be important.
If the cache cluster is build on many nodes, there will be a moment when one node needs to be shutdown. As long all items cached on all nodes are in sync (means all items are distributed to all nodes) the shutdown is not an issue at all. But in the real life systems are dynamic. That means new items are put into the cache and old items are removed. That means item distribution process (sync) is running continuously. Under this assumption shutdown of one node would destroy all items cached at that node which have not been synchronized with other nodes. To solve this problem, v1.1 of cache provides a new parameter Graceful of power-shell command Stop-CacheHost.

From the client side point of view, old 1.0 clients are compatible with the server version 1.1. However, both cache client libraries 1.0 and 1.1 should not be installed on one machine.

No more GAC
Cache client assemblies are no more installed in GAC. GAC registration has prevented using Windows Azure AppFabric Cache assemblies side by side with Windows Server AppFabric Caches assemblies.

Installation Path
Installation path is moved from C:\Windows\System32\AppFabric to .\Program Files\AppFabric 1.1.

For the full list of issues please take a look here.

For documentation purposes here is one which I need often:

custom WCF bindings and behaviors Schema Issue

If your services use custom elements, it is not possible to configure these elements in AppFabric directly. To do that convert custom element sections to MWA-compatible schemas and place that schema in %SystemRoot%\System32\inetsrv\config\schema. MWA will automatically pick up this schema and parse the custom section in configuration correctly. These sections can also be edited by using IIS Configuration Editor, which is inside of IIS Manager( not the AppFabric Configuration Editor).

Windows Azure ServiceBus Connect setup

2011-12-18T13:56:41Z

When installing ServiceBus Connect feature (a peace of Cloud Middle-Ware) following three artifacts will be installed:

1. Developer SDK
2. Runtime
3. Management tools

Developer SDK
You need it for VS to develop EAI applications. Developer SDK contains following components:
1.    Windows Azure ServiceBus EAI & EDI Labs SDK
2.    Microsoft WCF LOB Adapter SDK
3.    Microsoft BizTalk Adapter Pack
4.    Microsoft BizTalk Adapter Pack (64 bit), by 64 bit setup

Runtime

The ServiceBus Connect Runtime is required to connect to an on-premise Line of Business Application from an EAI application. This feature will install the following components:
1.    Windows Azure ServiceBus EAI & EDI Labs SDK
2.    Microsoft WCF LOB Adapter SDK
3.    Microsoft BizTalk Adapter Pack
4.    Microsoft BizTalk Adapter Pack (64 bit), if this is a 64 bit install
5.    Microsoft ServiceBus Connect

Kindly make sure that following pre-requisites are already installed on this system before proceeding:
1.    Windows Server AppFabric
2.    Internet Information Services (IIS), version 7.0 or higher. Following IIS features need to be enabled
a.    “IIS Metabase and IIS 6 configuration compatibility” or “IIS 6 Metabase Compatibility”
b.    Windows Authentication
3.    .NET Framework 3.5.1 Features should be enabled

Management Tools

The Management Tools feature provides PowerShell extensions for ServiceBus Connect. This feature will install the following component:
1. PowerShell extensions for Microsoft ServiceBus Connect

Pre-requisites

1.    Windows Server AppFabric
2.    Internet Information Services (IIS), version 7.0 or higher. Following IIS features need to be enabled
3.    “IIS Metabase and IIS 6 configuration compatibility” or “IIS 6 Metabase Compatibility”
4.    Windows Authentication
5.   IIS 6 Metabase compatibility
5. NET Framework 3.5.1 Features should be enabled.
6. VS 2010

Note that the official list in the CTP setup does not describe all you need. The list 1-5 shown above contains all what I have installed to make it working.

Documentation: http://msdn.microsoft.com/en-us/library/windowsazure/hh689864.aspx

Last but not least:
If you get some error like this one: “Setting cached product context: User non-assigned for product: 4C27B055404F218479F149E738A578E7” it means that you have probably downloaded x64 package trying to install on x86 machine.

Announcing the Service Bus EAI & EDI Labs Release

2011-12-17T13:57:02Z

Today Microsoft announced the first version of Windows Azure Service Bus EAI & EDI release. The release provides support for EAI and EDI in Cloud.:

Enterprise Application Integration (EAI)
Rich message processing capabilities
Ability to connect private cloud assets to the public cloud.
Electronic Data Interchange (EDI)
(B2B) scenarios in the form of a finished service built for trading partner management.

SDK Download

New Labs environment requires Windows Live ID registration.

More information:
http://blogs.msdn.com/b/windowsazure/archive/2011/12/16/announcing-the-service-bus-eai-amp-edi-labs-release.aspx

Where is my Snippet?

2011-12-13T15:19:05Z

Just for documentation purposes:

Folder with snippets:
C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC#\Snippets\1033\Visual C#

Snippet file example: model.snippet
”model” is shortname

<?xml version="1.0" encoding="utf-8"?>
<CodeSnippets xmlns="http://schemas.microsoft.com/VisualStudio/2005/CodeSnippet">
<CodeSnippet Format="1.0.0">
    <Header>
      <Title>model</Title>
      <Author>Damir Dobric</Author>
      <Description></Description>
      <HelpUrl></HelpUrl>
      <SnippetTypes />
      <Keywords />
      <Shortcut>model</Shortcut>
    </Header>
    <Snippet>
      <References />
      <Imports />
      <Declarations>
        <Literal Editable="true">
          <ID>TypeName</ID>
          <Type>System.Type</Type>
          <ToolTip></ToolTip>
          <Default>TypeName</Default>
          <Function></Function>
        </Literal>
        <Literal Editable="true">
          <ID>PropertyName</ID>
          <Type>System.String</Type>
          <ToolTip></ToolTip>
          <Default>TypeYourPropertyName</Default>
          <Function></Function>
        </Literal>
      </Declarations>
      <Code Language="csharp" Kind="" Delimiter="$">
<![CDATA[
      private $TypeName$ m_$PropertyName$;

      public $TypeName$ $PropertyName$
      {
          get
        {
        return m_$PropertyName$;
          }
        set
        {
            if (m_$PropertyName$ != value)
            {
                this.m_$PropertyName$ = value;
            RaisePropertyChanged("$PropertyName$");
              }
          }
    }]]></Code>
    </Snippet>
</CodeSnippet>
</CodeSnippets>