More about 'OnMessage' method of Service Bus

If you are using Service Bus, you should know that you have the ability to be notified when a message is available in the queue or in a subscription. Using this feature you don’t need to call the "Receive" method and catch the timeout exception when there are no new messages are available.

OnMessageOptions messageOptions = new OnMessageOptions()
  {
    AutoComplete = true,
    ExceptionReceived += LogErrorsOnMessageReceived
  };
queueClient.OnMessage((message) => 
  {
                ...
  }, messageOptions);

As you can see, you register to an event that will be called when a new message is available. If there are more than 1 messages available the event will be triggered more than one. Each notification will run on a different thread. To be able to control the number of concurrent messages that can be received by a client you should change the value of "MaxConcurrentCalls".

OnMessageOptions messageOptions = new OnMessageOptions()
  {
    AutoComplete = true,
    ExceptionReceived += LogErrorsOnMessageReceived
    MaxConcurrentCalls = 5
  };
queueClient.OnMessage((message) => 
  {
                ...
  }, messageOptions);

But what about the costs?
When using Service Bus, you pay for each transaction. Because of this each call of “Receive” method will consume a transaction. Even if there are no available messages and the call finish with a timeout exception, you will have to pay for one transaction.
Base on this, we should know that a similar thing is happening when we are using “OnMessage”. The behind implementation of this method use “Reveive” method and has a timeout value. Because of this, even if you register to “OnMessage” once you will notify that more than one transactions are consumed even if you don’t have messages in the Service Bus.
This is happening because “OnMessage” calls “Receive” method that will consume a transaction when a message is available or when a timeout exception occurs. The default timeout value is 60 seconds. This timeout value can be easily change using MessagingFactory.
From the cost perceptive you should not have any kind of problems. The cost of each client that use “OnMessage” method and has the timeout value set to 60 seconds is 4.3 cents per month.
In conclusion “OnMessage” is very useful because offer out of the box a mechanism that give us the possibility to be notified when a message is available – until now we had to implement this mechanism every time. You should not forget that this mechanism will handle each new message on a different thread and there are times when you want to control the concurrent level.  Also it generates some costs, but the cost is similar with the “Receive” mechanism – in the end “OnMessage” use “Receive”.

Read More

Http Request in .NET Compact Edition ended with "Unable to read data from the transport connection … Unknown error (0x0)"

We are leaving in a world that begin to be dominates by smart devices – device2device communication is not something new. Today I would like tack about a problems that we had when we integrated 2 smart devices.
One of the devices expose an HTTP endpoint that can be used to communicate with him. Based on a REST API you can send to him different requests. From our desktops all the communication worked perfectly with this device.
When we imported the client code to a Smart Device Project (special project used to write components for Windows Compact Edition and .NET Compact Framework 3.5) we had a big surprise. Each HTTP request to the first device ended with the following error code:

“Unable to read data from the transport connection … Unknown error (0x0)”
…
at System.Net.HttpWebRequest.finishGetResponse()
at System.Net.HttpWebRequest.GetResponse()…

> The code that generated the error code was:

        public void SetColor(Color color)
        {
            if (color != Color.Red
                && color != Color.Green)
            {
                throw new ArgumentException("Color is not supported", "color");
            }
            try
            {
                byte[] messageContent = UTF8Encoding.UTF8.GetBytes(string.Format(MessageBody,
                    color == Color.Red ? RedCode : GreenCode));
                WebRequest request = WebRequest.Create(new Uri(
                                        string.Format("http://{0}/api/{1}/lights/{2}/state",
                                        ConfigurationManager.AppSettings["hueIP"],
                                        ConfigurationManager.AppSettings["hueUser"],
                                        ConfigurationManager.AppSettings["hueNumber"])));
                request.Method = "Put";
                request.Timeout = 10000;
                request.ContentType = "application/json";
                request.ContentLength = messageContent.Length;
                using (Stream stream = request.GetRequestStream())
                {
                    stream.Write(messageContent, 0, messageContent.Length);
                }
            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.Message);
            }
        }

Because we use HttpWebRequest we expected to have a same a similar behavior with “normal” .NET, but it seems that this is not true. When you are working in “normal” .NET a part of the requests method string is automatically converted to UpperCase. In the moment when a request is made, the request method “Put” is converted to “PUT”. But, in a Smart Device project this is not happening – because of code optimization. So you end up with an HTTP request that has the method set to “Put”.
In general, the system will not have any kind of problems with this, because will know how to handle a request method written CamelCase.  In our case the second smart device it seems that cheeks the request method only with PUT written UpperCase.
In conclusion, when you work with a specific protocol, I recommend to always use the exact specification of the protocol and don’t assume that different stacked will make your job for you.

Read More

Control the color of Philips Hue Lamp based on the user status - Friday night undercover project

Yesterday I had the opportunity to put my hands on some lamp from Philips – Hue Lamps. Basically, you have one or more lamps that can be controlled over the network. For each lamp you can control the color, brightness and so on. The communication is done over a simple HTTP API that is well documented. When you will buy one or more lamps you will receive also a small device that needs to be connected to your network. That small device is used to communicate by wireless with your lamps.
I had the idea to write an application which controls the color of the lamp based on user status. For example when you are in a call, the color of the lamp will be red, otherwise green. I integrated the application with Skype, Outlook calendar and Lync.
If you want to play with this application you can download it from here: https://huelampstatus.codeplex.com/
You will need to install Skype API SDK, Lync 2013 API SDK and you need to have Outlook 2013. The application is not finished yet, but is a good starting point. Until now, on my machine worked pretty okay. Because of Skype API SDK don’t forget to build solution for a 86x processor (COM Nightmare).

Demo Video

Hue Lamp Integration
The communication with Hue Lamp is made pretty simple, you only need to make a PUT request.

 public class HueControl
    {
        private const string MessageBody = @"
{{
    ""hue"": {0},
    ""on"": true,
    ""bri"": 200
}}";
        private const int RedCode = 50;
        private const int GreenCode = 26000;

        public void SetColor(Color color)
        {
            if (color != Color.Red
                && color != Color.Green)
            {
                throw new ArgumentException("Color is not supported", "color");
            }
            try
            {
                byte[] messageContent = UTF8Encoding.UTF8.GetBytes(string.Format(MessageBody,
                    color == Color.Red ? RedCode : GreenCode));
                WebRequest request = WebRequest.Create(new Uri(
                                        string.Format("http://{0}/api/{1}/lights/{2}/state",
                                        ConfigurationManager.AppSettings["hueIP"],
                                        ConfigurationManager.AppSettings["hueUser"],
                                        ConfigurationManager.AppSettings["hueNumber"])));
                request.Method = "PUT";
                request.Timeout = 10000;
                request.ContentType = "application/json";
                request.ContentLength = messageContent.Length;
                using (Stream stream = request.GetRequestStream())
                {
                    stream.Write(messageContent, 0, messageContent.Length);
                }
            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.Message);
            }
        }
    }

The time consuming things are integration with Skype, Lync and Outlook calendar.

Skype Integration
For Skype, the hardest thing is to put your hands on the SDK (they don't accept new members anymore). You can use this sample code to put the hands on the SDK: http://archive.msdn.microsoft.com/SEHE/Release/ProjectReleases.aspx?ReleaseId=1871
After this all that you need to do is:

public class SkypeStatusChecker : IStatusChecker
    {
        private Skype _skype;

        public SkypeStatusChecker()
        {
            _skype = new Skype();
            _skype.Client.Start(true, true);
            _skype.Attach(6, true);

            _skype.CallStatus += OnCallStatusChange;
        }

        public ChangeStatus ChangeStatus { get; set; }

        private void OnCallStatusChange(Call pCall, TCallStatus status)
        {
            Trace.TraceInformation("Skype statusType: " + status);
            if (status == TCallStatus.clsInProgress)
            {
                SendNotification(StatusType.Busy);
                return;
            }

            if (status == TCallStatus.clsFinished)
            {
                SendNotification(StatusType.Free);
                return;
            }
        }

        private void SendNotification(StatusType statusType)
        {
            if (ChangeStatus != null)
            {
                ChangeStatus.Invoke(this, new ChangeStatusEventArgs(statusType));
            }
        }
    }

When the user will be involved in a call the status of Skype call is “clsInProgress”. When a call is finished the notification status that you receive from Skype is “clsFinished”. I used this to states to change the lamp color.

Lync Integration
In the Lync case you will need to get your activities and check if the status is “Available” or not.

 public class LyncStatusChecker : IStatusChecker
    {
        private StatusType _oldStatusType = StatusType.Free;
        private object _padLock = new object();

        public LyncStatusChecker()
        {
            Timer timer = new Timer();
            timer.Interval = TimeSpan.FromSeconds(1).TotalMilliseconds;
            timer.Elapsed += OnTimeElapsed;
            timer.Start();
        }

        public ChangeStatus ChangeStatus { get; set; }

        private void OnTimeElapsed(object sender, ElapsedEventArgs e)
        {
            try
            {
                LyncClient client = LyncClient.GetClient();

                List<object> states = (List<object>)client.Self.
                    Contact.GetContactInformation(ContactInformationType.CustomActivity);

                var status = GetStatus(states);

                lock (_padLock)
                {
                    if (status == _oldStatusType)
                    {
                        return;
                    }

                    Trace.TraceInformation("Lync statusType: {0}", status);
                    SendNotification(status);
                    _oldStatusType = status;
                }
            }
            catch (Exception err)
            {
                Trace.TraceError(err.ToString());
            }
        }

        private StatusType GetStatus(List<object> states)
        {
            StatusType statusType = StatusType.Free;
            if (states.Count == 0)
            {
                throw new Exception("States of Lync is 0");
            }
            if (states.FirstOrDefault(x => ((LocaleString) x).Value == "Available") == null)
            {
                statusType = StatusType.Busy;
            }
            return statusType;
        }

        private void SendNotification(StatusType statusType)
        {
            if (ChangeStatus != null)
            {
                ChangeStatus.Invoke(this, new ChangeStatusEventArgs(statusType));
            }
        }
    }

Outlook Integration
As I expected, the Outlook API is a nightmare, is very complicated and is pretty hard to find what you are looking for. The solution that I implemented gets the Outlook calendar and check if the user has a meeting in this moment. I don't like how I get the current user status, but it works.

    public class OutlookStatusChecker : IStatusChecker
    {
        private StatusType _oldStatusType = StatusType.Free;
        private object _padLock = new object();

        public OutlookStatusChecker()
        {
            Timer timer = new Timer();
            timer.Interval = TimeSpan.FromSeconds(1).TotalMilliseconds;
            timer.Elapsed += OnTimeElapsed;
            timer.Start();
        }

        public ChangeStatus ChangeStatus { get; set; }

        private void OnTimeElapsed(object sender, ElapsedEventArgs e)
        {
            CheckStatus();
        }

        private void CheckStatus()
        {
            try
            {
                Application outlookApp = new Application();
                NameSpace nameSpace = outlookApp.GetNamespace("MAPI");

                MAPIFolder calendarFolder = nameSpace.GetDefaultFolder(OlDefaultFolders.olFolderCalendar);
                Items calendarItems = calendarFolder.Items;
                calendarItems.IncludeRecurrences = true;
                calendarItems.Sort("[Start]", Type.Missing);
                DateTime now = DateTime.Now;
                DateTime todayStart = new DateTime(now.Year, now.Month, now.Day, 00, 00, 01);
                DateTime todayEnds = new DateTime(now.Year, now.Month, now.Day, 23, 59, 58);

                Items currentCalendarItems = calendarItems.Restrict(
                            string.Format(@"[Start] < ""{0}"" AND [End] > ""{1}"" AND [Start] >=""{2}"" AND [End] < ""{3}"" ",
                                    now.ToString("g"), now.AddMinutes(1).ToString("g"),
                                    todayStart.ToString("g"), todayEnds.ToString("g")));

                IEnumerator itemsEnumerator = currentCalendarItems.GetEnumerator();
                itemsEnumerator.MoveNext();

                StatusType statusType = itemsEnumerator.Current == null ? StatusType.Free : StatusType.Busy;

                lock (_padLock)
                {
                    if (statusType == _oldStatusType)
                    {
                        return;
                    }

                    Trace.TraceInformation("Outlook statusType: {0}", statusType);
                    SendNotification(statusType);
                    _oldStatusType = statusType;
                }
            }
            catch (Exception err)
            {
                Trace.TraceError(err.ToString());
            }
        }

        private void SendNotification(StatusType statusType)
        {
            if (ChangeStatus != null)
            {
                ChangeStatus.Invoke(this, new ChangeStatusEventArgs(statusType));
            }
        }
    }

Conclusion
 The things that I really liked was the API of Hue Lamps, that is very simple to use and well documented. Great job Philips.  

Read More

Today Software Magazine - number 14 is launched

The number 14 of Today Software Magazine is on the market. Even if is a great weather outside, people still have time for this great magazine – congratulations.

In the new number of TSM you can find information related to agile development, Haskell or load testing using Windows Azure - http://www.todaysoftmag.ro/tsm/ro/14

In this number of the magazine I wrote an article about Load Testing using Visual Studio 2013 and Windows Azure. This is a great service lunched by Azure team. Even if the article is in Romanian I already translated it. You can find the article here: http://vunvulearadu.blogspot.ro/2013/08/load-test-using-windows-azure-and.html

Also, I already made a presentation related to this subject: http://vunvulearadu.blogspot.ro/2013/08/post-event-summer-codecamp-at-cluj.html    

I hope than you will enjoy reading the new number of Today Software Magazine.

Read More

Legacy code, improvement task that are not finished

Until now I was involved in several projects that contained a lot of legacy code. On each project of this type people tried to improve the code, refactoring it and so on. I think that all of us know this story.
Having a code base with 3 million lines of code or 10 millions lines of code will contain a lot of crape. The code improvement action will never finish, this action will continue until the end of the project (end of maintenance phase) or end of the world.
It is very easily to find problems in a code that was not written by you. In cases like this you can propose a solution. If the architect or the person that is responsible on the project will accept your proposal, sometimes you will have allocated time for this task. We can have one, two, ten or more improvement tasks that run in the same time – assigned to different team members.
But what is happening when an issue is discovered and you receive a phone call from the client with a 911 problem? You will put the improvement task on hold. The same thing can happen when you have a backlog, you start working to the improvement task, but something happens and you have to put the task on hold.
Putting a project on hold is not a problem, but forgetting an improvement task that is partial done can generate an uglier code that you think so. In this case the “forgetting” term don’t refer only to the developer that forgets about the task itself. For example we can have a case when the management will not allocate team anymore for the given task.
In cases like this it is important to look over the changes and decide what you should do with the changes that were already done on the given task. Letting the changes in the code will not be all the time a good approach. You can end up with method, classes or functionality that is not used or with code that do the same thing in two different ways. When a new developer will come on the project and will look over the code he will not know what is happing there - people code and go, we are agile.
Developers will try to improve the code, having 100 great ideas how code can be improved and will start 200 task of code improving in the same time. What is important, when you start a task, you should also finish it. Starting a lot of improvement tasks without finishing them will increase the “legacy” part of the project.
Be prepared to fight for the improvement task. The code should add value to a project (functional/non-functional), it is not only developer fad.

Read More

Load Test using Windows Azure and Visual Studio 2013

In a perfect world I would except to be able to run a load test or a stress test using a cloud provider without being forced to change any line code from my tests. 

In this article we will find out how to do this thing using the new cloud service. How a person without knowledge of cloud will be able to run a load test with 50.000 users for 24 hours with minim costs, without being obliged to purchase and configure 10, 20 nodes.

What is a load test?
What is a load test in fact? An expression that I think it fits when we need to answer this question would be: ”Are you ready to be so popular?”.  The main scope of this kind of test is to define and validate the maximum load that a system can have without affecting the performance. Even though the developer tells that the system can handle without any problem 1000 users in the same time, the load test can prove the contrary even on simple scenarios.
There is a tiny difference between the load test and stress test. Many times the load test finishes with a stress test that has the purpose to observe the behavior of the system in the moment when the load increases above the maximum supported capacity.

What the market offers us now?
At this moment it is full of different solutions for automated testing and for running load tests. Products like Selenium, LoadStorm or Neoload dominate the market. Besides them there are many others and I don’t think 10 pages will be enough to enumerate them.
If we use an on-premise solution then we need to be prepared to resolve things like the acquisition and reservation of the resources for the load-test. In a small company it will be very hard to buy 10 servers just to run the load-test. A big company, even if it has the financial resources it will take a while until this resources will be available and sometimes it might be too late. Besides all this factors the configuration of each machine and deploy can be the labyrinth from which we won’t be able to find a way out.

What is the Microsoft proposal?

On this extremely mature market, Microsoft appeared with an ingenious solution. If they already have a powerful and robust infrastructure for cloud why don’t use it to run load tests using Azure. Even though they are not the first ones that are offering this kind of solution, Microsoft has an advantage. They allow you to run load tests using Azure without using a new configuration. All you have to do is to have an account on Visual Studio Team Foundation Service (http://tfs.visualstudio.com/) which will be used for the receipt.
 Before a load test using Microsoft could have been done only through Load Test Ring. This if formed from a controller that controls the tests- Load Test Controller and one or more agents on which our tests run. An architecture that is based on master-slave. The new version of Visual Studio 2013 provides us a new option- instead of running our test in our own Load Test Ring we can run them on Azure, without a new configuration. We don’t have to deploy any virtual machine or to configure different services.
 
Load Test Web Service
Load Test Web Service is the new Azure service that helps us. Through this service, Visual Studio 2013 loads our tests on the cloud. Behind this service is a pool of test agents that is used to run our tests. This thing happens behind the scene and we don’t have to do anything for this to run. All the results from our test together with other performance counters are available for us.

Which are the main characteristics?
Before looking over different functionalities that are supported I propose to first take a look at the most important options that are supported now.
We have the possibility to define UI tests and more. Beside the fact that we can record our UI tests we can also write our custom tests and hit different endpoints. The tested endpoint doesn’t have to be only HTTP or HTTPS. We can also test a WCF or REST endpoint and also a web service. The only condition is that the endpoint must be accessible via internet.
Visual Studio 2013 brings a project template- Web Performance and Load Test Project. This type of project will allow us to define and run load tests on cloud.

How to create a new load test?
The easiest way to create a load test for a web application is to create one or more Web Performance Tests. This type of test can be UI tests which are very easy to create and to automate. Using the UI recorder that comes with Visual Studio 2013 we can create a Web Performance Test in just a few seconds. This type of test can be modified at any time and if we want we can generate code for the test. Through this method the ones that wish to write code to modify the code can do this very easily. Of course that functionality like automatically detection of the dynamic elements that the page has or to extract different constants as parameters is supported out of the box.
For each test of this type we can generate different sources like database, CSV or XML file. You can also use the tests written in Selenium for example. Each test can call other test and this way we can reuse the logic that we already have for testing.
Until now we saw how we can create a test can be used for the load test. It is time for us to see what a load test allows us to do.

Which are the main functionalities?
The first thing we need to do in order to create a load test is to THINK. We can define different profiles and time intervals through which we should be able to simulate a real user. For example we can simulate a delay of X seconds after each test. We have available different profiles which we can use.
The way we simulate a load test can be made through different methods. We have the possibility to run a test with a specific number of users or we can define the number of users to increase at every step. Of course that most of the times we will have to run different scenarios in the same time. That why we can select the tests that we want to run and in what proportion, but also the way that this test have to run. For example we can specify how many times a test should run in a time interval or which is the number of users that have to run a specific test in every moment while the load test is running.
We can simulate different browsers that the clients might have and different types of connections. The most interesting thing is that we have the possibility to add and access not just performance counters from the clients but also the ones from the servers on which our application is running. This way we can monitor and see the counters from both the client and the servers.

How to run a load test in cloud?

Until now we saw the main options that we have available to run a load test, but we didn’t saw how to run this type of test. All we have to do to run the load test on cloud is to open the Local.testsettings and on General tab to select “Run tests using Visual Studio Team Foundation Service”. This is the only thing we have to do to run the test on cloud. Of course that we have to be logged uni in Visual Studio with an account that is connected tp Visual Studio Team Foundation Service.

What is the price?
For this moment the service is on preview. Each user has 2000 virtual minutes per month that can use for the load tests. There aren’t fixed prices for this. If you need more minutes for load tests all you have to do is to enter in the early adoption program without additional costs. You will have 200.000 virtual minutes per month that you can use. Accepting the request takes very little time (in my case around 6 hours).
The first time I heard about virtual minutes I wondered what these are. A virtual minute is the duration of the load test multiplied with the number of users.
Once we run the tests we will have access to all the results including performance counters, failed tests, error messages and different diagrams. All the results can be exported into an Excel that will automatically contain the diagrams that you can show it to the clients.

I invite you to try the new cloud service for load tests. I was pleasantly surprised by this service and I think it will make our life easier.

Read More

[Post Event] Summer Codecamp at Cluj-Napoca (July 31, 2013)

Last afternoon we had another Codecamp event in Cluj-Napoca. Around 70 people came to find out more about Team Foundation Server 2012, Virtual Machine Manager 2012 and how we can make load tests using Visual Studio 2013 and Azure infrastructure.
Special thanks for THE sponsors – YONDER and CORESYSTEMS.

Recorded sessions:
Managementul testelor cu Team Foundation Server 2012 si System Center Virtual Machine Manager 2012, Adrian Stoian

Load Tests using Visual Studio 2013 and Azure Radu Vunvulea

The slides of my session:

Load tests using Visual Studio 2013 and Azure from Radu Vunvulea

And in the end you can find some pictures from the event:

Read More