Windows Azure and Cloud Computing Posts for 2/22/2012+

Posted On Thursday, February 23, 2012 By . Under OakLeaf Systems    

A compendium of Windows Azure, Service Bus, EAI & EDI Access Control, Connect, SQL Azure Database, and other cloud-computing articles. image222

image433

Note: This post is updated daily or more frequently, depending on the availability of new articles in the following sections:

Azure Blob, Drive, Table, Queue and Hadoop Service

Janikiram MSV described Windows Azure Storage for PHP Developers in a 2/23/2012 post:

imageConsumer web applications today need to be web-scale to handle the increasing traffic requirements. One of the key components of the contemporary web application architecture is storage. Social networking and media sites are dealing with massive user generated content that is growing disproportionately. This is where Cloud storage can help. By leveraging the Cloud storage effectively, applications can scale better.

imageWindows Azure Storage has multiple offerings in the form of Blob, Table and Queues. Blob are used to store binary objects like images, videos and other static assets while Table is used for dealing with the flexible, schema-less entities. Queues allow asynchronous communication across the role instances and components of Cloud applications.

In this article, we will see how PHP developers can talk to Azure Blob storage to store and retrieve objects. Before that, let’s understand the key concepts of Azure Blobs.

Azure Blobs are a part of Windows Azure Storage accounts. If you have a valid Windows Azure account, you can create a storage account to gain access to the Blobs, Tables and Queues. Storage accounts come with a unique name that will act as a DNS name and storage access key that is required for authentication. Storage account will be associated with the REST endpoints of Blobs, Tables and Queues. For example, when I created a Storage account named janakiramm, the Blob endpoint is http://janakiramm.blob.core.windows.net. This endpoint will be used to perform Blob operations like creating and deleting containers and uploading objects.

Windows Azure Management Portal

Storage Account

Windows Azure Storage Endpoints

Azure Blobs are easy to deal with it. The only concepts you need to understand are containers, objects and permissions. Containers act as buckets to store binary objects. Since Containers are accessible over the public internet, the names should be DNS compliant. Every Container that is created is accessible through a scheme which looks like http://.blob.core.windows.net/.Containers group multiple objects together. You can add metadata to the Container which can be upto 8KB in size.

If you do not have the Windows Azure SDK for PHP installed, you can get it from the PHP Developer Center of Windows Azure portal. Follow the instructions and set it up on your development machine.

PHP SDK

Let’s take a look at the code to create a Container from PHP.

Start by setting a reference to the PHP SDK with the following statement.

require_once ‘Microsoft/WindowsAzure/Storage/Blob.php’;  

Create an instance of Storage Client with the access key.

$storageClient = new Microsoft_WindowsAzure_Storage_Blob(‘blob.core.windows.net’, ‘<endpoint>’, ‘<accesskey>’);

To list all the containers and print the names, we will use the following code

$containers=$blob->listContainers();

for ( $counter = 0; $counter < count($containers); $counter += 1)

print($containers[$counter]->name)."\n";

Uploading a file to the Blob storage is simple.

$obj=$blob->putBlob(‘<container>’,'<key>’,'<path_to_the_file>’);

print($obj->Url);

To list all the blobs in a container, just call listBlobs() method.

$blobs=$blob->listBlobs(‘<container>’);

for ( $counter = 0; $counter < count($blobs); $counter += 1)

print($blobs[$counter]->name)."\n";

Finally, you can delete the blob by passing the container name and the key.

$blob.deleteBlob(‘<container>’,'<blob_name>’);

PHP Developers can consume Windows Azure storage to take advantage of the scalable, pay-as-you-go storage service.

image_thumb3_thumb

<Return to section navigation list>

SQL Azure Database, Federations and Reporting

Russell Solberg @RusselSolberg described how SQL Azure & Updated Pricing resulted in moving his company’s CRM database to SQL Azure in a 2/17/2012 post (missed when published):

imageOne of the biggest challenges I face daily is how to build and architect cost effective technical solutions to improve our business processes. While we have no shortage of ideas for processes we can enhance, we are very constrained on capital to invest. With all that said, we still have to operate and improve our processes. Our goal as a business is to be the best at what we do which means we also need to make sure we have appropriate scalable technical solutions in please to meet the demands of our users.

imageOver the past few years our Customer Relationship Management (CRM) database has become our Enterprise Resource Planning (ERP) system. This system tells our staff everything they need to know about our customers, potential customers, and what activities need to be completed and when. This system is an ASP.NET web application with a SQL database on the back end. In the days leading up to our busy season, we had an Internet outage (thanks to some meth tweakers for digging up some copper!) and only one of our offices had access to our system. At this time, I knew that our business required us to rethink the hosting of our server and services.

After working with various technical partners, we determined we could collocate our existing server in a data center for a mere $400 per month. While this was a workable solution, the only perk this would really provide us was redundant power and internet access which we didn’t have in our primary location. We still had huge redundancy issues with our server in general, and by huge I mean non-existent. In other words, if a hard disk failed, we were SOL until Dell was able to get us a replacement. Since our busy season of work had just begun, I decided that we’d roll the dice and address the concerns in the 1Q of 2012.

Enter Azure

When Azure was announced from Microsoft, I initially brushed off the platform. I found the Azure pricing model way too difficult to comprehend and I really wasn’t willing to spend the hours, weeks, or months trying to put it all together. Things have changed though!

On February 14th, 2012 Microsoft announced that it was reducing the pricing of SQL Azure and I decided to see if I could figure out what that meant. While digging into this, I came across a nice article written by Steven Martin that did a good job explaining the costs. After reading the article, I decided to evaluate the pricing calculator again. Winner Winner Chicken Dinner!

I could move our entire database to the SQL Azure platform for $9.99 per month! This would at least handle some of the disaster recovery and scalability concerns. The only other piece to the puzzle would be our ASP.NET web application. While I have scalability concerns with that, disaster recovery isn’t really a concern because the data drives the app. In other words, a Windows PC can running IIS would work until the server is fixed. But what if the cost wasn’t an issue on the Azure platform? Would it be worth it? Five months ago, I couldn’t have told you the cost. With the updated pricing calculator, I can see that running 2 extra-small instances of our ASP.NET web app will cost $60.00 per month. VERY AFFORDABLE!

While I’ve not deployed our solutions to Azure yet, it is something that I’ve got on the list to complete within the next 60 days. Hosting our entire application for less than $70 per month (ok, a penny less… but still!) is amazing! I’ll write another blog entry once we’ve tested the Azure system out, but very promising!!!!!

What if your database was 30GB?

<Return to section navigation list>

MarketPlace DataMarket, Social Analytics, Big Data and OData

Yi-Lun Luo posted More about REST: File upload download service with ASP.NET Web API and Windows Phone background file transfer on 2/23/2012:

imageLast week we discussed RESTful services, as well as how to create a REST service using WCF Web API. I’d like to remind you what’s really important is the concepts, not how to implement the services using a particular technology. Shortly after that, WCF Web API was renamed to
ASP.NET Web API, and formally entered beta.

imageIn this post, we’ll discuss how to upgrade from WCF Web API to ASP.NET Web API. We’ll create a file uploading/downloading service. Before that, I’d like to
give you some background about the motivation of this post.

The current released version of Story Creator allows you to encode pictures to videos. But the videos are mute. Windows Phone allows users to record sound using microphone, as do many existing PCs (thus future Windows 8 devices). So in the next version, we’d like to introduce some sound. That will make the application even cooler, right?

The sound recorded by Windows Phone microphone only contains raw PCM data. This is not very useful other than using XNA to play the sound. So I wrote a
prototype (a Windows Phone program) to encode it to wav. Then I expanded the
prototype with a REST service that allows the phone to upload the wav file to a
server, where ultimately it will be encoded to mp4 using Media Foundation.

With the release of ASP.NET Web API beta, I think I’ll change the original
plan (write about OAuth this week), to continue the discussion of RESTful
services. You’ll also see how to use Windows Phone’s background file transfer to
upload files to your own REST services. However, due to time and effort
limitations, this post will not cover how to use microphone and how to create
wav files on Windows Phone (although you’ll find it if you download the
prototyp), or how to use Media Foundation to encode
audio/videos (not included in the prototype yet, perhaps in the future).

You can download the prototype here. Once again, note this is just a prototype, not a sample. Use it as a reference only.

The service Review: What is REST service

imageFirst let’s recall what it means by a RESTful service. This concept is independent from which technology you use, be it WCF Web API, ASP.NET Web API, Java, or anything else. The most important things to remember are:

  • REST is resource centric (while SOAP is operation centric).
  • REST uses HTTP protocol. You define how clients interact with resources
    using HTTP requests (such as URI and HTTP method).

In most cases, the upgrade from WCF Web API to ASP.NET Web API is simple. Those two do not only share the same underlying concepts (REST), but also share a lot of code base. You can think ASP.NET Web API as a new version of WCF Web API, although it does introduce some break changes, and has more to do with ASP.NET MVC. You can find a lot of resources here.

Today I’ll specifically discuss one topic: How to build a file upload/download
service. This is somewhat different from the tutorials you’ll find on the above
web site, and actually I encountered some difficulties when creating the
prototype.

Using ASP.NET Web API

The first thing to do when using ASP.NET Web API is to download ASP.NET MVC 4 beta, which includes the new Web API. Of course you can also get it from NuGet.

To create a project that uses the new Web API, you can simply use Visual Studio’s project template.

This template is ideal for those who want to use Web API together with ASP.NET MVC. It will create views and JavaScript files in addition to files necessary for a service. If you don’t want to use MVC, you can remove the unused files, or create an empty ASP.NET application and manually create the service. This is the approach we’ll take today.

If you’ve followed last week’s post to create a REST service using WCF Web API, you need to make a few modifications. First remove any old Web API related assembly references. You have to add references to the new version:

System.Web.Http.dll, System.Web.Http.Common, System.Web.Http.WebHost, and
System.Net.Http.dll.

Note many Microsoft.*** assemblies have been renamed to
System.***. As for System.Net.Http.dll, make sure you reference the new version, even if the name remains the same. Once again, make sure you set Copy Local to true, if you plan to deploy the service to Windows Azure or somewhere else.

Like assmblies, many namespaces have been changed from Microsoft.*** to
System.***. If you’re not sure, simply remove all namespaces, and let Visual
Studio automatically find which ones you need.

The next step is to modify Global.asax. Before, the code looks like this, where ServiceRoute is used to define base URI using ASP.NET URL Routing. This allows you to remove the .svc extension. Other parts of URI are defined in UriTemplate.

routes.Add(new ServiceRoute( "files", new HttpServiceHostFactory(),
typeof(FileUploadService)));

In ASP.NET Web API, URL Routing is used to define the complete URI, thus
removes the need to use a separate UriTemplate.

public static void RegisterRoutes(RouteCollection routes){
routes.MapHttpRoute(
name: "DefaultApi",
routeTemplate: "{controller}/{filename}",
defaults: new { filename = RouteParameter.Optional }
);
}

The above code defines how a request is routed. If a request is sent to

http://[server name]/files/myfile.wav, Web API will try to find a class named

FilesController ({controller} is mapped to this class, and it’s case insensitive).

Then it will invoke a method which contains a parameter filename, and map

myfile.wav to the value of the parameter. This parameter is optional.

So you must have a class FilesController. You cannot use names like

FileUploadService. This is because now Web API relies on some of ASP.NET MVC’s

features (although you can still host the service in your own process without

ASP.NET). However, this class does not have to be put under the Controllers

folder. You’re free to put it anywhere, such as under a services folder to make

it more like a service instead of a controller. Anyway, this class must inherite

ApiController (in WCF Web API, you didn’t need to inherite anything).

For a REST service, HTTP method is as important as URI. In ASP.NET Web API,

you no longer use WebGet/Invoke. Instead, you use HttpGet/AcceptVerbs. They’re almost identical to the counter parts in old Web API. One improvement is if your service method begins with Get/Put/Post/Delete, you can omit those attributes completely. Web API will automatically invoke those methods based on the HTTP method. For example, when a POST request is made, the following method will automatically be invoked:

public HttpResponseMessage Post([FromUri]string filename)

You may also notice the FromUri attribute. This one is tricky. If you omit

it, you’ll encounter exceptions like:

No ‘MediaTypeFormatter’ is available to read an object of type ‘String’

with the media type ”undefined”.

This has to do with ASP.NET MVC’s model binding. By default, the last parameter in the method for a POST/PUT request is considered to be request body, and will deserialized to a model object. Since we don’t have a model here, an exception is thrown. FromUri tells MVC this parameter is actually part of URI, so it won’t try to deserialize it to a model object. This attribute is optional for requests that do not have request bodies, such as GET.

This one proved to be a trap for me, and web searches do not yield any useful

results. Finally I asked the Web API team directly, where I got the answer

(Thanks Web API team!). I’m lucky enough to have the oppotunity to talk with the team directly. As for you, if you encoutner errors that you’re unable to find

the answer yourself, post a question in the forum! Like all new products, some Web API team members will directly monitor that forum.

You can find more about URL Routing on http://www.asp.net/web-api/overview/web-api-routing-and-actions/routing-in-aspnet-web-api.

Implement file uploading

Now let’s implement the file uploading feature. There’re a lot ways to handle

the uploaded file. In this prototype, we simply save the file to a folder of the

service application. Note in many cases this will not work. For example, in

Windows Azure, by default you don’t have write access to folders under the web

role’s directory. You have to store the file in local storage. In order for

multiple instances to see the same file, you also need to upload the file to

blob storage. However, in the prototype, let’s not consider so many issues.

Actually the prototype does not use Windows Azure at all.

Below is the code to handle the uploaded file:

        public HttpResponseMessage Post([FromUri]string filename)
        {
            var task = this.Request.Content.ReadAsStreamAsync();
            task.Wait();
            Stream requestStream = task.Result;
 
            try
            {
                Stream fileStream = File.Create(HttpContext.Current.Server.MapPath("~/" + filename));
                requestStream.CopyTo(fileStream);
                fileStream.Close();
                requestStream.Close();
            }
            catch (IOException)
            {
                throw new HttpResponseException("A generic error occured. Please try again later.", HttpStatusCode.InternalServerError);
            }
 
            HttpResponseMessage response = new HttpResponseMessage();
            response.StatusCode = HttpStatusCode.Created;
            return response;
        }

Unlike last week’s post, this time we don’t have a HttpRequestMessage

parameter. The reason is you can now use this.Request to get information about

request. Others have not changed much in the new Web API. For example, to obtain

the request body, you use ReadAsStreamAsync (or another ReadAs*** method). Note

in real world product, it is recommended to handle the request asynchronously.

This is again not considered in our prototype, so we simply let the thread wait

until the request body is read.

When creating the response, you still need to pay attention to status code.

Usually for a POST request which creates a resource on the server, the

response’s status code is 201 Created. When an error occurs, however, you need

to return an error status code. This can be done by throwing a

HttpResponseException, the same as in previous Web API.

File downloading and Range header

While the audio recoding feature does not need file downloading, this may be

required in the future. So I also implemented it in the prototye. Another reason

is I want to test the Range header (not very relavent to Story Creator, but one

day it may prove to be useful).

Range header is a standard HTTP header. Usually only GET requests will use

it. If a GET request contains a Range header, it means the client wants to get

partial resource instead of the complete resource. This can be very useful

sometimes. For example, when downloading large files, it is expected to pause

the download and resume sometime later. You can search for 14.35 on



http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html, which exlains the

Range header.

To give you some practical examples on how Range header is used in real

world, consider Windows Azure blob storage. Certain blob service requests

support the Range header. Refer to



http://msdn.microsoft.com/en-us/library/windowsazure/ee691967.aspx for more

information. As another example,

Windows

Phone background file transfer may (or may not) use the Range header, in

case the downloading is interrupted.

The format of Range header is usually:

bytes=10-20,30-40

It means the client wants the 10th to 20th bytes and the 30th to 40th bytes

of the resource, instead of the complete resource.

Range header may also come in the following forms:

bytes=-100

bytes=300-

In the former case, the client wants to obtain from the beginning to the

100th byte of the resource. In the latter case, the client wants to obtain from

the 300th bytes to the end of the resource.

As you can see, the client may request for more than one ranges. However in

practice, usually there’s only one range. This is in particular true for file

downloading scenarios. It is quite rare to request for discrete data. So many

services only support a single range. That’s also what we’ll do in the prototype

today. If you want to support multiple ranges, you can use the prototype as a

reference and implement additional logic.

The following code implements file downloading. It only takes the first range

into account, and ignores the remaining.

        public HttpResponseMessage Get([FromUri]string filename)
        {
            string path = HttpContext.Current.Server.MapPath("~/" + filename);
            if (!File.Exists(path))
            {
                throw new HttpResponseException("The file does not exist.", HttpStatusCode.NotFound);
            }
 
            try
            {
                MemoryStream responseStream = new MemoryStream();
                Stream fileStream = File.Open(path, FileMode.Open);
                bool fullContent = true;
                if (this.Request.Headers.Range != null)
                {
                    fullContent = false;
 
                    // Currently we only support a single range.
                    RangeItemHeaderValue range = this.Request.Headers.Range.Ranges.First();
 
 
                    // From specified, so seek to the requested position.
                    if (range.From != null)
                    {
                        fileStream.Seek(range.From.Value, SeekOrigin.Begin);
 
                        // In this case, actually the complete file will be returned.
                        if (range.From == 0 && (range.To == null || range.To >= fileStream.Length))
                        {
                            fileStream.CopyTo(responseStream);
                            fullContent = true;
                        }
                    }
                    if (range.To != null)
                    {
                        // 10-20, return the range.
                        if (range.From != null)
                        {
                            long? rangeLength = range.To - range.From;
                            int length = (int)Math.Min(rangeLength.Value, fileStream.Length - range.From.Value);
                            byte[] buffer = new byte[length];
                            fileStream.Read(buffer, 0, length);
                            responseStream.Write(buffer, 0, length);
                        }
                        // -20, return the bytes from beginning to the specified value.
                        else
                        {
                            int length = (int)Math.Min(range.To.Value, fileStream.Length);
                            byte[] buffer = new byte[length];
                            fileStream.Read(buffer, 0, length);
                            responseStream.Write(buffer, 0, length);
                        }
                    }
                    // No Range.To
                    else
                    {
                        // 10-, return from the specified value to the end of file.
                        if (range.From != null)
                        {
                            if (range.From < fileStream.Length)
                            {
                                int length = (int)(fileStream.Length - range.From.Value);
                                byte[] buffer = new byte[length];
                                fileStream.Read(buffer, 0, length);
                                responseStream.Write(buffer, 0, length);
                            }
                        }
                    }
                }
                // No Range header. Return the complete file.
                else
                {
                    fileStream.CopyTo(responseStream);
                }
                fileStream.Close();
                responseStream.Position = 0;
 
                HttpResponseMessage response = new HttpResponseMessage();
                response.StatusCode = fullContent ? HttpStatusCode.OK : HttpStatusCode.PartialContent;
                response.Content = new StreamContent(responseStream);
                return response;
            }
            catch (IOException)
            {
                throw new HttpResponseException("A generic error occured. Please try again later.", HttpStatusCode.InternalServerError);
            }
        }

Note when using Web API, you don’t need to manually parse the Range header in

the form of text. Web API automatically parses it for you, and gives you a From

and a To property for each range. The type of From and To is Nullable<long>, as

those properties can be null (think bytes=-100 and bytes=300-). Those special

cases must be handled carefully.

Another special case to consider is where To is larger than the resource

size. In this case, it is equivalent to To is null, where you need to return

starting with From to the end of the resource.

If the complete resource is returned, usually status code is set to 200 OK.

If only part of the resource is returned, usually status code is set to 206

PartialContent.

Test the service

To test a REST service, we need a client, just like testing other kinds of

services. But often we don’t need to write clients ourselves. For simple GET

requests, a browser can serve as a client. For other HTTP methods, you can use

Fiddler. Fiddler also helps to

test some advanced GET requests, such as Range header.

I think most of you already know how to use Fiddler. So today I won’t discuss

it in detail. Below are some screenshots that will give you an idea how to test

the Range header:

Note here we request the range 1424040-1500000. But actually the resource

size is 1424044. 1500000 is out of range, so only 4 bytes are returned.

You need to test many different use cases, to make sure your logic is

correct. It is also a good idea to write a custom test client with all test

cases written beforehand. This is useful in case you change service

implementation. If you use Fiddler, you have to manually go through all test

cases again. But with some pre-written test cases, you can do automatic tests.

However, unit test is beyond the scope of today’s post.

Windows Phone Background File Transfer

While we’re at it, let’s also briefly discuss Windows Phone background file transfer. This is also part of the prototype. It uploads a wav file to the service. One goal of the next Story Creator is to show case some of Windows Phone Mango’s new features. Background file transfer is one of them.

You can find a lot of resources about background file transfer. Today my focus will be pointing out some points that you may potentially miss.

When to use background file transfer

Usually when a file is small, there’s no need to use background file transfer, as using a background agent do introduce some overhead. You will use it when you need to transfer big files (but it cannot be too big, as usually using phone network costs users). Background file transfer supports some nice features, like automatic pause/resume downloading as the OS thinks it’s needed (requires service to support Range header), allows user to cancel a request, and so on.

In the prototype, we simply decide to use background file transfer to upload

all files larger than 1MB, and use HttpWebRequest directly when the file size is

smaller. Note this is rather an objective choice. You need to do some test and

maybe some statictics to find the optimal border between background file

transfer and HttpWebRequest in your case.

            if (wavStream.Length < 1048576)
            {
                this.UploadDirectly(wavStream);
            }
            else
            {
                this.UploadInBackground(wavStream);
            }
Using background file transfer

To use background file transfer, refer to the document on



http://msdn.microsoft.com/en-us/library/hh202959(v=vs.92).aspx. Pay special

attention to the following:

The maximum allowed file upload size for uploading is 5MB (5242880 bytes).

The maximum allowed file download size is 20MB or 100MB (depending on whether

wifi is available). Our prototype limits the audio recording to 5242000 bytes.

It’s less than 5242880 because we may need additional data. For example,

additional 44 bytes are required to write wav header.

                if (this._stream.Length + offset > 5242000)
                {
                    this._microphone.Stop();
                    MessageBox.Show("The recording has been stopped as it is too long.");
                    return;
                }

In order to use background file transfer, the file must be put in isolated

storage, under /shared/transfers folder. So our prototype saves the wav file to

that folder if it needs to use background file transfer. But if it uses

HttpWebRequest directly, it transfers the file directly from memory (thus a bit

faster as no I/O is needed).

In addition, for a single application, at maximum you can create 5 background

file transfer requests in parallel. If the limit is reached, you can either

notify the user to wait for previous files to be transferred, or manually queue

the files. Our prototype, of course, takes the simpler approach to notify the

user to wait.

The following code checks if there’re already 5 background file transfer

requests and notifies the user to wait if needed. If less than 5 are found, a

BackgroundTransferRequest is created to upload the file. The prototype simply

hardcodes the file name to be test.wav. Of course in real world applications,

you need to get the file name from user input.

        private void UploadInBackground(Stream wavStream)
        {
            // Check if there're already 5 requests.
            if (BackgroundTransferService.Requests.Count() >= 5)
            {
                MessageBox.Show("Please wait until other records have been uploaded.");
                return;
            }
 
            // Store the file in isolated storage.
            var iso = IsolatedStorageFile.GetUserStoreForApplication();
            if (!iso.DirectoryExists("/shared/transfers"))
            {
                iso.CreateDirectory("/shared/transfers");
            }
            using (var fileStream = iso.CreateFile("/shared/transfers/test.wav"))
            {
                wavStream.CopyTo(fileStream);
            }
 
            // Transfer the file.
            try
            {
                BackgroundTransferRequest request = new BackgroundTransferRequest(new Uri("http://localhost:4349/files/test.wav"));
                request.Method = "POST";
                request.UploadLocation = new Uri("shared/transfers/test.wav", UriKind.Relative);
                request.TransferPreferences = TransferPreferences.AllowCellularAndBattery;
                request.TransferStatusChanged += new EventHandler<BackgroundTransferEventArgs>(Request_TransferStatusChanged);
                BackgroundTransferService.Add(request);
            }
            catch
            {
                MessageBox.Show("Unable to upload the file at the moment. Please try again later.");
            }
        }

Here we set TransferPreferences to AllowCellularAndBattery, so the file can

be transferred even if no wifi is available (thus the user has to use phone’s

celluar network) and battery is low. In real world, please be very careful when

setting the value. 5MB usually will not cost the user too much. But if you need

to transfer larger files, consider to disallow cellular network. Battery is

usually less of a concern in case of file transfer, but it is still recommended

to do some test and gather practical data.

Once a file transfer is completed, the background file transfer request will

not be removed automatically. You need to manually remove it. You may need to do that quite often, so a global static method (such as a method in the App class) will help.

        internal static void OnBackgroundTransferStatusChanged(BackgroundTransferRequest request)
        {
            if (request.TransferStatus == TransferStatus.Completed)
            {
                BackgroundTransferService.Remove(request);
                if (request.StatusCode == 201)
                {
                    MessageBox.Show("Upload completed.");
                }
                else
                {
                    MessageBox.Show("An error occured during uploading. Please try again later.");
                }
            }
        }

Here we check if the file transfer has completed, and remove the request if

it has. We also check the response status code of the request, and display

either succeed or failed information to user.

You invoke this method in the event handler of TransferStatusChanged. Note

you do not only need to handle this event when the request is created, but also

need to handle it in case of application launch and tomestone. After all, as the

name suggests, the request can be executed in background. However, if your

application is not killed (not tomestoned), you don’t need to handle the events

again, as your application still remains in memory.

Below is the code handling application lifecycle events and check for

background file transfer:

        // Code to execute when the application is launching (eg, from Start)
        // This code will not execute when the application is reactivated
        private void Application_Launching(object sender, LaunchingEventArgs e)
        {
            this.HandleBackgroundTransfer();
        }
 
        // Code to execute when the application is activated (brought to foreground)
        // This code will not execute when the application is first launched
        private void Application_Activated(object sender, ActivatedEventArgs e)
        {
            if (!e.IsApplicationInstancePreserved)
            {
                this.HandleBackgroundTransfer();
            }
        }
        private void HandleBackgroundTransfer()
        {
            foreach (var request in BackgroundTransferService.Requests)
            {
                if (request.TransferStatus == TransferStatus.Completed)
                {
                    BackgroundTransferService.Remove(request);
                }
                else
                {
                    request.TransferStatusChanged += new EventHandler<BackgroundTransferEventArgs>(Request_TransferStatusChanged);
                }
            }
        }

Finally, in a real world application, you need to provide some UI to allow

users to monitor background file transfer requests, and cancel them if

necessary. A progess indicator will also be nice. However, those features are

really out of scope for a prototype.

Upload files directly

Just to make the post complete, I’ll also list the code that uses

HttpWebRequest to upload the file directly to the service (same code you can

find all over the web).

        private void UploadDirectly(Stream wavStream)
        {
            string serviceUri = "http://localhost:4349/files/test.wav";
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(serviceUri);
            request.Method = "POST";
            request.BeginGetRequestStream(result =>
            {
                Stream requestStream = request.EndGetRequestStream(result);
                wavStream.CopyTo(requestStream);
                requestStream.Close();
                request.BeginGetResponse(result2 =>
                {
                    try
                    {
                        HttpWebResponse response = (HttpWebResponse)request.EndGetResponse(result2);
                        if (response.StatusCode == HttpStatusCode.Created)
                        {
                            this.Dispatcher.BeginInvoke(() =>
                            {
                                MessageBox.Show("Upload completed.");
                            });
                        }
                        else
                        {
                            this.Dispatcher.BeginInvoke(() =>
                            {
                                MessageBox.Show("An error occured during uploading. Please try again later.");
                            });
                        }
                    }
                    catch
                    {
                        this.Dispatcher.BeginInvoke(() =>
                        {
                            MessageBox.Show("An error occured during uploading. Please try again later.");
                        });
                    }
                    wavStream.Close();
                }, null);
            }, null);
        }

The only thing worth noting here is Dispatcher.BeginInvoke. HttpWebRequest

returns the response on a background thread (and actually I already start the

wav encoding and file uploading using a background worker to avoid blocking UI

thread), thus you have to delegate all UI manipulations to UI thread.

Finally, if you want to test the protypte on emulator, make sure your PC has

a microphone. If you want to test it on a real phone, you cannot use localhost

any more. You need to use your PC’s name (assume your phone can connect to PC using wifi), or host the service on internet such as in Windows Azure.

Conclusion

I didn’t intend to write such a long post. But it seems there’re just so many

topics in development that makes me difficult to stop. Even a single theme

(RESTful services) involves a lot of topics. Imagine how many themes you will

use in a real world application. Software development is fun. Do you agree? You

can combine all those technologies together to create your own product.

While this post discusses how to use ASP.NET Web API to build file

upload/download services, the underlying concept (such as the Range header) can be ported to other technologies as well, even on non-Microsoft platforms. And the service can be accessed from any client that supports HTTP.

If I have time next week, let’s continue the topic by introducing OAuth into

the discussion, to see how to protect REST services. And in the future, if

you’re interested, I can talk about wav encoding on Windows Phone, and more

advanced encodings on Windows Server using Media Foundation. However, time is

really short for me…

Jonathan Allen described ASP.NET Web API – A New Way to Handle REST in a 2/23/2012 post to InfoQ:

imageWeb API is the first real alternative to WCF that .NET developers have seen in the last six years. Until now emerging trends such as JSON were merely exposed as WCF extensions. With Web API, developers can leave the WCF abstraction and start working with the underlying HTTP stack.

Web API is built on top of the ASP.NET stack and shares many of the features found in ASP.NET MVC. For example, it fully supports MVC-style Routes and Filters. Filters are especially useful for authorization and exception handling.

imageIn order to reduce the amount of mapping code needed, Web API supports the same Model binding and validation used by MVC (and soon to be released NET Web Forms 4.5). The flip side of this is the content negotiation features. Web API automatically supports XML and JSON, but the developer can add their own formats as well. The client determines which format(s) it can accept and includes them in the request header.

imageMaking your API queryable is surprisingly easy. Merely have the service method return IQueryable<T> (e.g. from an ORM) and it Web API will automatically enable OData query conventions.

ASP.NET Web API can be self-hosted or run inside IIS.

The ASP.NET Web API is part of ASP.NET MVC 4.0 Beta and ASP.NET 4.5, which you can download here.

image_thumb15_thumb

<Return to section navigation list>

Windows Azure Access Control, Service Bus and Workflow

imageNo significant articles today.

<Return to section navigation list>

Windows Azure VM Role, Virtual Network, Connect, RDP and CDN

imageNo significant articles today.

<Return to section navigation list>

Live Windows Azure Apps, APIs, Tools and Test Harnesses

Jason Zander (@jlzander) posted a Sneak Preview of Visual Studio 11 and .NET Framework 4.5 Beta in a 2/23/2012 post:

imageToday we’re giving a “sneak peek” into the upcoming beta release of Visual Studio 11 and .NET Framework 4.5. Soma has announced on his blog that the beta will be released on February 29th! We look forward to seeing what you will build with the release, and will be including a “Go Live” license with the beta, so that it can be used in production environments.

imageVisual Studio 11 Beta features a clean, professional developer experience. These improvements were brought about through a thoughtful reduction of the user interface, and a simplification of common developer workflows. They were also based upon insights gathered by our user experience research team. I think you will find it both easier to discover and navigate code, as well as search assets in this streamlined environment. For more information, please visit the Visual Studio team blog. [See post below.]

In preparation for the beta, today we’re also announcing the Visual Studio 11 Beta product lineup, which will be available for download next week. You can learn about these products on the Visual Studio product website. One new addition you will notice is Team Foundation Server Express Beta, which is free collaboration software that we’re making available for small teams. Please see Brian Harry’s blog for the complete announcement and more details on this new product.

In the Visual Studio 11 release, we’re providing a continuous flow of value, allowing teams to use agile processes, and gather feedback early and often. Storyboarding and Feedback Manager enable development teams to react rapidly to change, allowing stakeholder requirements to be captured and traced throughout the entire delivery cycle. Visual Studio 11 also introduces support for teams working together in the DevOps cycle. IntelliTrace in production allows teams to debug issues that occur on production servers, which is a key capability for software teams delivering services.

I encourage you to view the presspass story with additional footage from today’s news events, including a highlight video and product screenshots. Then stay tuned for an in-depth overview of the release with the general availability announcement on February 29th.

Monty Hammontree posted Introducing the New Developer Experience to the Visual Studio blog on 2/23/2012:

In this blog post (and the one that will follow) we’d like to introduce a few of the broad reaching experience improvements that we’ve delivered in Visual Studio 11. We’ve worked hard on them over the last two years and believe that they will significantly improve the experience that you will have with Visual Studio.

Introduction

We know that developers often spend more of their time than they would like orienting themselves to the project and tools they are working with and, in some cases, only about 15% of their time actually writing new code. This is based on observations we’ve made in our research labs and observations that other independent researchers have made (for example, take a look at this paper). Obviously you need to spend some time orienting yourself to your code and tools, but wouldn’t it be good to spend more time adding new value to your applications? In Visual Studio 11 we’ve focused on giving you back more time by streamlining your development experience. Through thoughtful reduction in user interface complexity, and by the introduction of new experience patterns that simplify common workflows, we’ve targeted what we observed to be three major hurdles to developer efficiency.

The problem areas we targeted are:

  1. Coping with tool overload. Visual Studio provides a large amount of information and capabilities that relate to your code. The sheer breadth and depth of capabilities that Visual Studio provides, at times, makes it challenging to find and make effective use of desired commands, options, or pieces of information.
  2. Comprehending and navigating complex codebases and related artifacts (bugs, work items, tests etc.). Most code has a large number of dependencies and relationships with other code and content such as bugs, specs, etc. Chaining these dependencies together to make sense of code is more difficult and time-consuming than it needs to be due to the need to establish and re-establish the same context across multiple tools or tool windows.
  3. Dealing with large numbers of documents. It is very common for developers to end up opening a large number of documents. Whether they are documents containing code, or documents containing information such as bugs or specs, these documents need to be managed by the developer. In some cases, the information contained in these documents is only needed for a short period of time. In other cases documents that are opened during common workflows such as exploring project files, looking through search results, or stepping through code while debugging are not relevant at all to the task the developer is working on. The obligation to explicitly close or manage these irrelevant or fleetingly relevant documents is an ongoing issue that detracts from your productivity.
Developer Impact

In the remainder of this post we’ll describe in a lot more detail how we have given you more time to focus on adding value to your applications by reducing UI complexity in VS 11. In tomorrow’s post we’ll go into details regarding the new experience patterns we’ve introduced to simplify many of your common development workflows. The overall effect of the changes we’ve introduced is that Visual Studio 11 demands less of your focus, and instead allows you to focus far more on your code and the value that you can add to your applications.

Improved Efficiency through Thoughtful Reduction

Developers have repeatedly and passionately shared with us the degree to which tool overload is negatively impacting their ability to focus on their work. The effort to address these challenges began during development of VS 2010 and continues in VS 11 today. In VS 2010 we focused on putting in place the engineering infrastructure to enable us to have fine grained control over the look and feel of Visual Studio.

With this as the backdrop we set out in Visual Studio 11 to attack the tool overload challenge through thoughtful yet aggressive reduction in the following areas:

  • Command Placements
  • Colorized Chrome
  • Line Work
  • Iconography
Command Placements

Toolbars are a prominent area where unnecessary command placements compete for valuable screen real-estate and user attention. In VS 11 we thoughtfully, based on user instrumentation data, but aggressively reduced toolbar command placements throughout the product by an average of 35%.When you open Visual Studio 11 for the first time you’ll notice that there are far fewer toolbar commands displayed by default. These commands haven’t been removed completely; we’ve just removed the toolbar placements for these commands. For example, the cut, copy and paste toolbar commands have been removed since we know from our instrumentation data that the majority of developers use the keyboard shortcuts for these commands. So, rather than have them take up space in the UI, we removed them from the toolbar.

Default toolbars in VS 2010

The default toolbars in VS 2010

Default toolbars in VS 11

The default toolbars in VS 11

Feedback relating to the command placement reductions has been overwhelmingly positive. Developers have shared stories with us of discovering what they perceive to be new valuable features that are in fact pre-existing features that have only now gained their attention following the reductions. For example, during usability studies with the new toolbar settings, many users have noticed the Navigate Forward and Backward buttons and have assumed that this was new functionality added to the product when in fact this capability has been in the product for a number of releases.

Colorized Chrome

Allowing for the use of color within content to take center stage is increasing in importance as developers target Metro style clients such as Xbox, Windows Phone 7, and Windows 8. In targeting these platforms developers are creating user experiences that involve the use of bolder and more vibrant colors. These color palettes showcase much more effectively in a more monochromatic tool setting.

In VS 11 we have eliminated the use of color within tools except in cases where color is used for notification or status change purposes. Consequently, the UI within VS 11 now competes far less with the developer’s content. Additionally, notifications and status changes now draw user attention much more readily than before.

Strong use of color in VS 2010

Strong use of color in VS 2010

Reduced use of color in VS 11 focuses attention on the content

Reduced use of color in VS 11 focuses attention on the content

To do a great job of supporting the wide range of environments that you may work in and the wide range of content you may work with, we’ve provided two color schemes, each designed to allow your content to best take center stage. You can choose between a light shell and editor combination or a dark shell and editor combination from within Visual Studio Tools Options. You can still customize your editor settings in the same way that you are used to from previous versions of Visual Studio and load any profile changes you may have previously made.

The light color theme in VS 11

The light color theme in VS 11

The dark theme in VS 11

The dark theme in VS 11

Line Work

In previous versions of Visual Studio we made use of boxes, separators, bevels, gradients, and shadows to create user interface structure and emphasis. One unintended consequence was that the combined effect of this ‘line work’ drew attention away from developer content. In VS 11 we removed as much structural line work as possible. We transitioned to typography and whitespace as our primary techniques for creating structure and emphasis. This transition together with the toolbar reductions outlined above resulted in the recovery of 42 pixels of vertical screen real estate. In the case of a developer editing code this equates to between 2 and 3 extra lines of code being in view at any point in time.

An example of the use of lines and gradients to add UI structure and emphasis

An example of the use of lines and gradients to add UI structure and emphasis

Removing lines and gradients and using whitespace and typography to add UI structure and emphasis

Removing lines and gradients and using whitespace and typography to add UI structure and emphasis

Iconography

In addition to reducing structural line work we have reduced and simplified the artwork used within the iconography of VS 11. In this blog post we refer to icons following this simplified iconographic style as glyphs.

In VS 11 we have transitioned to glyph style iconography throughout the product. While we understand that opinions on this new style of iconography may vary, an icon recognition study conducted with 76 participants, 40 existing and 36 new VS users, showed no negative effect in icon recognition rates for either group due to the glyph style transition. In the case of the new VS users they were able to successfully identify the new VS 11 icons faster than the VS 2010 icons (i.e., given a command, users were faster at pointing to the icon representing that command). In this and subsequent studies more developers have expressed a preference for the glyph style icons over the former style, especially after having spent time getting used to the new glyph style icons.

Pictographic icons from VS 2010 on the top row with the equivalent VS 11 glyphs on the bottom row

Pictographic icons from VS 2010 on the top row with the equivalent VS 11 glyphs on the bottom row

Through reductions in toolbar command placements, line work, iconography, and color usage, VS 11 manages to simultaneously devote more space to content while at the same time engendering the impression that VS is lighter and less complex. In two recent extended usage studies developers indicated that these changes make VS feel both cleaner and simpler.

We designed Visual Studio 11 with a broader client and web based tool context in mind. In this release Visual Studio, Expression Blend, TFS Online, and additional supporting tools share common visual language elements such as iconography. Many design elements are shared or designed to be synergistic with other Microsoft offerings such as the new Windows Store for Developers.

Four examples of a common visual language across multiple products

Search

Given the complexity of today’s software development tools and solutions, thoughtful reduction needs to be complemented by other complexity management strategies such as contextual search. There are many situations where search is an obvious strategy to pursue in order to bypass mounting complexity. One such situation is the time it takes to browse for desired tool functionality within menus, toolbars, and configuration dialogs. Another is trying to find targets of interest within tool windows such as toolboxes, property grids, file explorers, etc. Yet another is trying to find targets of interest within lengthy code files.

In each of these cases, the ideal experience would be one in which developers can locate targets of interest with minimal disruption to their overall task flow. We accomplish this in VS 11 by integrating search in a more contextual manner and providing a more optimal experience through both the keyboard and the mouse. In doing so, we’ve enabled developers to bypass complexity while fostering rather than disrupting core task flow.

In VS 11, we focused on task flow friendly search in the following areas:

  • Quick Launch: Searching within commands and configuration options
  • Searching within tool windows
  • Searching within open files
Quick Launch: Searching Within Commands

With Quick Launch, developers are able to search through the entire catalog of commands in VS 11, as well as configurations options within Tools -> Options. While our reduction efforts have made it easier to find frequently used commands on the toolbar, search gives developers immediate access to any command within VS – even if they don’t know the exact full name of the command or its location.

Instead of being forced to manipulate the menus to find the command, search allows developers to focus on the content, and find the command that they want. This allows them to stay in the zone while they work on their task. Of course, when developers know where a command exists, the menus continue to work well for command access.

Recognizing that a developer’s hands are often on the keyboard at the very point when they need to search for a command, we optimized Quick Launch for keyboard usage in two ways. First, we assigned a simple keyboard shortcut to Quick Launch (Ctrl + Q). This allows the developer to quickly call up the search command without having to take their hands off the keyboard. Once a search has been executed, search results can be explored using the up/down arrow keys and a selection can be made by pressing Enter.

Secondly, we designed the Quick Launch results to educate developers as they browse the results. In the case of commands, if a particular command has a shortcut, the shortcut is listed next to the command along with the location of the command within the menu-bar. If desired, developers can pick up the shortcut and use it the next time they need the command, bypassing Quick Launch all together.

In the case of configuration options each result lists the popular options on that particular page, along with a summary description. This makes it much easier to choose between different results prior to choosing one.

All told, Quick Launch takes the often tedious task of browsing for commands and configuration options and streamlines it dramatically. The net result is that developers are able to get the command or configuration option they need quickly and get back to the core task at hand.

Quick Launch showing the results of a search for find

Quick Launch showing the results of a search for find

Searching Within Tool Windows

Another source of tool or content overload within today’s IDEs stems from trying to find targets of interest within tool windows such as toolboxes, error lists, file explorers, etc. As with commands, browsing through long lists within such tool windows disrupts the fast and fluid experience that developers crave.

In VS 11 we identified a number of tool windows that would benefit from contextualized search and prioritized them based on usage scenarios, feedback requesting search capabilities and the engineering costs of updating the UI of each appropriate tool window. Based on this prioritization we incorporated search into the following tool windows:

  • SOLUTION EXPLORER
  • REFERENCE MANAGER
  • TEAM EXPLORER
  • INTELLITRACE SUMMARY PAGE
  • TOOLBOX
  • PARALLEL WATCH WINDOW
  • ERROR LIST
  • C++ GRAPHICS EVENT LIST
  • CODE ANALYSIS

The toolbox, error list and solution explorer are now searchable, along with a number of other tool windows

Solution Explorer and Team Explorer are two areas where we anticipate search to have the greatest impact. With the Solution Explorer, search enables developers to quickly find a known piece of code, and then use it to browse relationships (we describe this in more detail in our post about simplification). With the Team Explorer, work items can be found quickly without having to craft a query before-hand.

Since practically every developer takes advantage of the Solution Explorer, we focused our keyboard enhancements on the search experience within that tool window as well. Search within the Solution Explorer can be activated at any time using Ctrl + ;. As with Quick Launch, developers can seamlessly arrow up and down through their results list.

Searching Within Open Files

In VS 11 we have also enhanced the experience of searching within files. Past versions of VS had multiple ways to search within files, each having capabilities that overlapped with the others.

In line with our overall emphasis on thoughtful reduction, we improved the user experience by consolidating features from multiple tool windows into one holistic experience. We consolidated two disparate feature areas – Incremental Search and Quick Find – and created a find UI at the top of the file to allow developers to navigate through search results while keeping their focus on the content (for more screenshots and video clips of search integrated into Visual Studio, see this blog post). Such an experience enables developers to focus on their content while performing potentially complex searches through that content.

The developer has performed a search for the term paint within the currently open file (PaintCanvas.cs)

The developer has performed a search for the term paint within the currently open file (PaintCanvas.cs)

In Summary

Through reductions in toolbar command placements, line work, iconography, and color usage Visual Studio 11 manages to simultaneously devote more space to your content while at the same time engendering the impression that VS feels lighter and less complex. Furthermore, by integrating search in a more contextual manner throughout Visual Studio 11 and by emphasizing flow inducing interaction techniques such as keyboard invocation and navigation we’ve better enabled you to bypass complexity while fostering rather than disrupting your workflow. We’re looking forward to hearing your feedback relative to our work in these areas.

Bruno Terkaly (@brunoterkaly) described Node.js– Socket Programming with C# and Javascript in a 2/22/2012 post:

Installing Node.js on Windows, Mac

imageThanks to Ryan Dahl’s presentations and materials, I have been able to follow along and learn a little about Node.js. I hope to show you what I learn as I learn it.

The first step is get the latest version of Node installed.

Node.js Website: http://nodejs.org

o31alsyz

Using Node.js interactively

Bring up a command prompt. Bring up a command prompt. v2gm3clg

Type in node start the interpreter. nugjogqo

Define a function. You can ignore the “undefined” message. anpet5bd

You can now call the function, passing in “212.”

pxfpmsav

Notice we get “100” as the answer, since 212 Fahrenheit is 100 Celsius.

Write Node.js scripts and running them

You can request the process id very simply.

cz4aghaf

If you want A LOT of information, just type in “process.” It is a lot of information.

qjgs4yvc

This will list a lot details about the process, including environment variables.



Running Node.js Scripts

Simply type in “node [node.js code file]”

c:\> node simpleServer.js



image

setTimeout.js 

setTimeout(function () { console.log(" world"); }, 2000);
console.log("Hello");

The point is that there is no “sleep” in Node. You cannot halt execution. The setTimeout() lets you do things in the background. In the code above the word “Hello” shows up immediately and “World” shows up 2 seconds later.

setInterval.js 

setInterval(function () { console.log(" world"); }, 2000);
console.log("Hello");

ibdqzodd

A simple HTTP Server – Demo

The code below creates a very basic web server.

image

The code below does the following:

image

image

Here is the output. Notice that on the left we execute simpleServer.js. On the right side we execute the code in simpleServer.js by navigating a browser to http://127.0.0.1:8000. Note the 8000, because that is the port we are listening on.

image



Inspecting http headers with Fiddler

Fiddler is an HTTP debugging proxy server application. It captures HTTP traffic and logs it for the user to review. Here is what to notice about the call we just made.

image

image

A Node.js TCP Server

We just demonstrated http. The next section is learning about TCP. TCP is considered a very lightweight protocol, free of the overhead of http. Notice in the code below we require ‘net,’ not ‘http.’ Everything else should look somewhat familiar from before.

 tcpServer.js

var net = require(‘net’);

var tcp_server = net.createServer(function(socket)

{

socket.write(‘hello\n’);

socket.end(‘world\n’);

});

tcp_server.listen(8000);

Let’s write a C# program to read those TCP bytes (“Hello World”)

static void Main(string[] args)
{
    TcpClient tcpClient = new TcpClient();
    tcpClient.Connect("127.0.0.1", 8000);
    NetworkStream clientStream = tcpClient.GetStream();

    byte[] message = new byte[4096];
    int bytesRead;
    bytesRead = 0;

    try
    {
        // Read up to 4096 bytes
        bytesRead = clientStream.Read(message, 0, 4096);
    }
    catch
    { 
        /*a socket error has occured*/ 
    }

    //We have rad the message.
    ASCIIEncoding encoder = new ASCIIEncoding();
    Console.WriteLine(encoder.GetString(message, 0, bytesRead));

    tcpClient.Close();
    tcpClient.Close();
}

Here is the TCP client reading and displaying the bytes.

image

Mick Badran (@mickba) listed Azure: Useful bits and Pieces on 2/22/2012:

imageFolks I’ve decided to list some useful links and tips that I’ve come across as part of our work we do. This list will grow and expand as time goes on.

Wes Yanaga reminded readers about a New MSDN Magazine Article: Supporting Mobile Device Applications Using Restful Services Running on Windows Azure in a 2/22/2012 post to the US ISV Evangelism blog:

Abstract

This article is about scalability and interoperability, two characteristics that are required in architectures to support the diversity of today’s popular mobile platforms, which potentially have millions of users. Figure 1 depicts this diversity, a common—yet challenging—scenario for today’s developers. Supplying Web-based services to mobile devices is a daunting task, requiring distinct and diverse tooling, languages and IDEs. Beyond this diversity is the need for elastic scale—in terms of available Web services and for data that can reach terabytes in size.

This insightful article was co-written by Ricardo Villalobos and Bruno Terkaly, who both work for the Developer & Platform Evangelism team.

Link to Article

http://bit.ly/AB2HY6

For More Azure Resources:

General Information

Online Training

Technical Resources

Marketing and Sales Resources

<Return to section navigation list>

Visual Studio LightSwitch and Entity Framework 4.1+

Jan Van der Haegen (@janvanderhaegen) described MyBizz Portal: The “smallest” LightSwitch application you have ever seen (Thank you!) in a 2/23/2012 post:

imageTime to get this blog on the road! My life has known a fun but chaotic couple of weeks, with lots of crazy events and opportunities that you’ll hear about later… First things first, a little thank you is in order…

Only a couple of weeks ago, 10 days before the LightSwitch Star Contest on CodeProject was about to end, I posted a small article that stated:

“This weekend, I’m going to try to allocate most of my time into the submission of “MyBizz Portal”, [...] My aim is to rank as high as possible in the category “Most Groundbreaking LightSwitch Application”, with an application that has one screen, a blank shell, the default LightSwitch theme and a single Silverlight Custom UserControl, so probably the smallest LightSwitch application you have ever seen.“

image_thumb1I never assumed it to be even remotely possible that I would win any of the prizes, but then a first mail hit my inbox, stating that I won the first prize in the January edition of the contest, rewarding me an awesome bundle of LightSwitch specific software… Most rewarding day of my life since I lost my virginity…

Until a second mail came… Apparently, not only did the judges like my entry, they liked it enough to award the “Grand Winner in the category Most Groundbreaking LightSwitch Application” label to MyBizz Portal! I received the awesome Acer laptop this morning, and just finished installing LightSwitch on it…

I’m not ashamed to admit that the personal publicity and recognition, are very rewarding, and I had a smile on my face for the rest of the week after those two mails. Also, the software licenses and the laptop will provide a nice financial boost to my startup (still on track to open virtual doors on April 2nd). But perhaps the biggest reward of them all, came in the form of a third mail, from Jay Schmelzer (Principal Diractor Program Manager – VS LightSwitch), asking if I could do an interview with Beth Massi, our LightSwitch goddess…

Since I knew she visiting The Netherlands the very next week, it made perfectly good sense to meet up for the interview and talk face-to-face. Not only was it an honor to meet such a fantastic, charismatic, pragmatic and a little bit lunatic (aren’t we all?) person, she gave me some great real-life tips that will last a life time (such as “The Business doesn’t care”, or “How do you feel about that?” – but these tips deserve a separate blog post)! Apparently, I left a good impression myself, as she blogged about our encounter in her latest trip report…

Beth Massi's blog - my brother always says: "Screenshot or it didn't happen"...

Beth Massi’s blog – my brother always says: "Screenshot or it didn’t happen"…

Return to section navigation list>

Windows Azure Infrastructure and DevOps

Rich Miller reported Microsoft Expands Dublin Cloud Computing Hub in a 2/23/2012 post to the Data Center Knowledge blog:

Microsoft will add 13.2 megawatts of capacity to its data center in Dublin, Ireland, which powers its online services throughout Europe and the Middle East, the company said today.

The new expansion will feature enhancements of energy efficiency features that debuted in the first phase of the Dublin facility, which was one of the first major data centers to rely almost entirely on outside air to cool servers.

imageMicrosoft will invest $130 million in the expansion, which is driven by the growth of its online services, including Windows Azure, Office365, Bing, Hotmail and Xbox Live. The company expects the additional 112,000 square feet of space to come online before the end of 2012.

The expansion is being built as a second structure adjacent to the existing 300,000 square foot, two-story data center, which opened in July 2009 and is approaching its total IT capacity of 16 megawatts of power. The new building will be significantly smaller, with just one story and a lighter construction frame.

Ditching the DX Cooling Units

It will also be missing a key feature – the DX (direct expansion) cooling units that supported the first phase. The Dublin data center was designed to be cooled with outside air, with the DX units available for backup cooling if the temperature rose above 85 degrees.

“What we found is that with the conditions in Dublin, we didn’t use the DX units even once,” said Dileep Bhandarkar, a Distinguished Engineer at Microsoft. “It’s an optimization of the previous design.”

The temperature hasn’t gone above the 85-degree mark, Bhandarkar said, adding that Microsoft has concluded that any unseasonably warm days in Dublin can be managed using adiabatic cooling systems built into the air handlers. Adiabatic cooling is a method of evaporative cooling in which fresh air from outside the data center passes through a filter that is wet, and the air is cooled as it passes through it.

The Dublin expansion will retain the data hall design of the project’s first phase, which featured servers within a hot aisle containment system atop a slab floor. Cold air enters through air handlers on the roof, drops into the data center.

Variations in Design

That’s a different design approach than Microsoft’s newest data centers in the United States, where it is using modular units known as IT-PACs that house servers within a 20-foot enclosure, allowing granular control of airflow within the container. The differences between the U.S. and Dublin designs is guided by the workloads each facility is handling, according to Bhandarkar.

But Microsoft’s focus on using fresh air for cooling extends to the new phases of its U.S. builds, including projects in Boydton, Virginia and West Des Moines, Iowa.

The new building in Dublin is designed to add capacity in 4.4 megawatt increments. The structure features concrete foundations and a concrete floor supporting a modular steel frame that is assembled on-site. The frame will be sheeted with a metal cladding and the roof will be concrete to hold the air handling units.

The Microsoft project will have a significant impact on the local economy in Dublin, where it is expected to generate 1.6 million man hous of construction work between now and December, creating up to 400 construction jobs. About 70 percent of those jobs will be focused on the building’s electrical infrastructure, with 20 percent on mechanical and the remainder performing miscellaneous construction and engineering support activities.

Here’s a look at the second data center structure at Microsoft’s Dublin campus, which will provide an additional 13 megawatts of capacity. (Source: Microsoft)

This view of the data hall in the first phase in Dublin illustrates Microsoft’s approach to a fixed hot-aisle containment pods. (source: Microsoft)

Himanshu Singh (pictured below) reminded readers to Don’t Miss Scott Guthrie’s Series of Blog Posts On Windows Azure in a 2/23/2012 post to the Windows Azure blog:

imageAs Corporate Vice President in Microsoft’s Server and Tools Business, Scott Guthrie oversees the development of several key Microsoft technologies, including Windows Azure. Scott recently started publishing a series of posts on his blog that dig into what you can do with Windows Azure and how to get started. They include some great information and links; check them out if you haven’t already done so. His first two posts in this series are –

  • Post 1 – Windows Azure links to an on-demand video of Scott’s keynote and includes an overview of Windows Azure from the ‘Learn Windows Azure’ online event.
  • Post 2 – Getting Started with Windows Azure covers how to sign-up and get started with Windows Azure using a no-obligation 3 month free trial offer.

imageScott is also on Twitter and often tweets quick updates and interesting links about Windows Azure, follow @scottgu to be sure you get his updates in your Twitter feed.

#SlowNewsDay, Himanshu?

<Return to section navigation list>

Windows Azure Platform Appliance (WAPA), Hyper-V and Private/Hybrid Clouds

image

No significant articles today.

<Return to section navigation list>

Cloud Security and Governance

No significant articles today.

<Return to section navigation list>

Cloud Computing Events

Paulette Suddarth described MVP Global Summit—A World-class Community Event! in a 2/23/2012 post to the Microsoft MVP Award Program Blog:

Editor’s note: the following is a guest post by MVP Award Program Events and Marketing Manager Paulette Suddarth

We’re now less than one week away from what is likely the largest community event in the world—the MVP Global Summit.

imageThis year, more than 1,500 MVPs will travel from 70 countries to meet with members of the Microsoft community. They share their valuable real-world feedback with our product teams to help drive improvements and innovation in Microsoft technologies, and they learn about what’s new and what’s coming in our products.

For MVPs, the focus is on learning—from Microsoft teams and from each other. That’s why one of the new features of this year’s MVP Global Summit is an evolution away from traditional keynote addresses to audience-focused panel discussions led by Microsoft senior executives. This year, corporate vice president of Microsoft’s Developer Division, S. Somasegar, corporate vice president of Visual Studio, Jason Zander, and corporate vice president of Server & Tools Business, Scott Guthrie, will be presenting at the MVP Global Summit, talking with MVPs about areas of specific interest to them.

That’s in addition to the 760 technical sessions planned this year, where MVPs and product team members will sit down together and engage in deep technical discussions about current and future innovations.

This is a time when MVPs get to “geek out” with each other—sharing tips and best practices and stories from the technology trenches. They also share their passion for community—technology communities and the wider communities of our world. This year, as in past years, many will arrive a couple of days early for the Global Summit in order to offer their time and energy at a GeekGive event—packing food for those in need at Northwest Harvest.

Windows Azure MVPs from Japan will be arriving at the Global Summit to share their stories about the work they did nearly a year ago to keep communications alive in the wake of the terrible tsunami and ensuing nuclear reactor crisis. You can read more about how they created mirror cloud web sites to alert residents about radiation levels and other critical information in this blog post.

From the Surface MVP, Dennis Vroegop, who committed countless hours to develop a promising tool for diagnosing autism in children to MVPs like Dave Sanders, whose Carolina IT user group routinely contributes thousands of dollars to the needy in their local community, MVPs share a commitment to supporting others. When they get together, as one MVP last year explained, “It’s like a family reunion, except you like everyone!”

I’ll be there.

David Pallman announced the start of a four-part Presentation: The Modern Web, Part 1: Mobility on 2/23/2012:

imageI’ve started a 4-part webcast series on The Modern Web (you can get webcast details and after-the-fact recordings at Neudesic.com). In each part I’ll talk about one of the four pillars (Mobility, HTML5, Social Networking, and Cloud Computing). Here is the presentation for Part 1: Mobility that is being given today:

The Modern Web, Part 1: Mobility

View more presentations from David

The Microsoft Server and Cloud Platform Team (@MSServerCloud) want you to Watch this Interview with Brad Anderson and find out why he’s excited for MMS 2012!, according to a 2/22/2012 post:

imageIt’s time once again for the Microsoft Management Summit! MMS 2012 will be held at the Venetian Hotel in Las Vegas, NV April 16th – 20th.

In this special edition of the Edge Show, Corporate Vice President Brad Anderson comes by with some breaking news about this year’s event!

  • Find out who the Keynote speaker(s) will be, the basic topics for both the day one and day two Keynotes.
  • Discover what’s new at this year’s MMS, including the opportunity for a new certification!
  • Why this is Brad’s favorite event and what is different about MMS than other events.

imageGet Registered NOW! MMS is about to sell out this year!

<Return to section navigation list>

Other Cloud Computing Platforms and Services

Richard Seroter (@rseroter) announced My New Pluralsight Course, “AWS Developer Fundamentals”, Is Now Available in a 2/23/2012 post:

imageI just finished designing, building and recording a new course for Pluralsight. I’ve been working with Amazon Web Services (AWS) products for a few years now, and I jumped at the chance to build a course that looked at the AWS services that have significant value for developers. That course is AWS Developer Fundamentals, and it is now online and available for Pluralsight subscribers.

In this course, I … cover the following areas: …

  • Compute Services. A walkthrough of EC2 and how to provision and interact with running instances.
  • Storage Services. Here we look at EBS and see examples of adding volumes, creating snapshots, and attaching volumes made from snapshots. We also cover S3 and how to interact with buckets and objects.
  • Database Services. This module covers the Relational Database Service (RDS) with some MySQL demos, SimpleDB and the new DynamoDB.
  • Messaging Services. Here we look at the Simple Queue Service (SQS) and Simple Notification Service (SNS).
  • Management and Deployment. This module covers the administrative components and includes a walkthrough of the Identity and Access Management (IAM) capabilities.

Each module is chock full of exercises that should help you better understand how AWS services work. Instead of JUST showing you how to interact with services via an SDK, I decided that each set of demos should show how to perform functions using the Management Console, the raw (REST/Query) API, and also the .NET SDK. I think that this gives the student a good sense of all the viable ways to execute AWS commands. Not every application platform has an SDK available for AWS, so seeing the native API in action can be enlightening.

I hope you take the time to watch it, and if you’re not a Pluralsight subscriber, now’s the time to jump in!

Matthew Weinberger (@M_Wein) reported VMware Cloud Foundry Micro PaaS Adds Java Debugging in an 2/23/2012 post to the TalkinCloud blog:

imageThe VMware Cloud Foundry team has released a new edition of Micro Cloud Foundry, which updates all the cloud languages and frameworks involved in the single-PC platform-as-a-service (PaaS) solution, streamlines offline support and, probably most notably, adds Java debugging features.

As a quick refresher, Micro Cloud Foundry is a tool for developers that runs a complete Cloud Foundry PaaS environment within a virtual machine on a single computer. Whatever changes you make on the microscale are guaranteed to work on a larger-scale Cloud Foundry deployment, but with the convenience of not having to do all your coding in the public cloud.

The new version — 1.2, to be more exact– brings the kind of Java debugger that developers have been using locally for ages now. “The user can set break points in the source code, suspend and resume running applications, view the application stack and perform code stepping operations,” so says the Cloud Foundry blog entry. Debugging occurs either via the command line or by way of the integrated SpringSource Tool Suite (STS).

As for the new runtimes: It brings Java 6, Ruby 1.8, Ruby 1.9, Node.js .4 and the newly available Node.js .6 runtimes up to parity with the CloudFoundry.com public service, while doing the same for the MongoDB, MySQL, Postgresql, RabbitMQ and Redis services. That blog entry has more technical detail for those so minded.

Cloud Foundry’s platform agnosticism and openness has won it a fair share of fans in the cloud ISV world. I can’t really see anybody being unhappy with what VMware’s team has brought to the table this time around.

Read More About This Topic

InfoChimps (@InfoChimps) announced a new Infochips Platform for DataMarket analytics on 2/23/2012:

How It Works

imageThe Infochimps Platform is designed to be scalable, flexible, and reliable. Whether hosted in your Cloud or ours, our solutions are built to fit your needs, including ETL, data storage, on-demand compute resources, and analytics.

Diagram

Meet the Infochimps Platform.

Related Resources: Product Sheet

imageTo create the Data Marketplace, our team of data scientists and engineers developed a powerful data system that could ingest and deliver massive amounts of data while performing complex, resource-intensive analytics along the way. Our unique technology suite and best practices are now available to you, unlocking the potential of the Big Data you already have and of the even bigger data available online.

Data Delivery Service

imageEnsure sure your data gets from A to B with scalable data transport. In addition to standard bulk data import, we utilize technologies like Apache Flume to extract, split, transform, and recombine multiple data streams at terabyte scale in real-time. Combined with our best-in-class proprietary software, Data Delivery Service makes it easy to extend the power of Flume, while seamlessly integrating into your existing data environment with flexible delivery options.

Database Management

imageTake advantage of the right database technology for the job, whether it’s HBase, Cassandra, Elastic Search, MongoDB, MySQL, or something else. We ensure your data storage environment can handle the scalability demands of your business. Whether we provide an on-premise or hosted solution, you will receive reliable monitoring, administration, and maintenance of your data storage.

Elastic Hadoop

imageGet Hadoop resources when you need them, whether scheduled, ad-hoc, or dedicated. This breadth in capability enables nightly batch jobs, compliance or testing clusters, science systems, and production systems. With Ironfan, Infochimps’ automated systems provisioning tool, as its foundation, Elastic Hadoop lets you tune the resources specifically for the job at hand. Now it’s easy to create map or reduce specialized machines, high compute machines, high memory machines, etc. as needed.

Analytics

imageTransform, analyze, and visualize your data with the best tools available. Use Pig, Infochimps’ Wukong, and other platforms with Hadoop to execute the data calculations and algorithms your business requires. Take advantage of our partner offerings like Datameer and Karmasphere or other third-party systems for additional ways to extract powerful value from your data.

Rahul Pathak reported AWS ElastiCache – Now Available in Two More Regions in a 2/22/2012 post:

Amazon ElastiCache is now available in two additional Regions: US West (Oregon) and South America (Sao Paulo). Caching systems perform best when they are right next to your application servers, so we’re excited to now have ElastiCache available in all AWS Regions.

In conjunction with this, we’re also adding new CloudFormation templates to allow you to set up complete, cache-enabled application stacks in both these Regions, quickly and predictably.

ElastiCache improves the performance of your applications by retrieving frequently used data from a fast, in-memory cache instead of relying entirely on disk-based databases. The service is ideal for increasing throughput for read-heavy workloads and it’s also used in compute intensive scenarios where you can speed up application performance by storing intermediate results in the cache.

If you already run Memcached in EC2, transitioning to ElastiCache is as simple as creating a cache cluster and updating your application configuration with the address of your new cache nodes. You can get more details and instructions in our "How Do I Migrate" FAQ.

If you’re new to caching, Memcached, and ElastiCache, Jeff wrote an excellent overview when we launched the service in August 2011 that will tell you all you need to get started. In addition, you’ll also find useful information in the recorded version of our "Turbo-charge Your Apps Using Amazon ElastiCache" webinar:

When running ElastiCache in a production environment keep in mind that more nodes give you higher availability while larger nodes ensure that more data can be kept in cache at any point in time. Fortunately, ElastiCache makes it easy to experiment with different configurations quickly and cost-effectively so you can find the setup that best meets your requirements and budget.

You can get started with Amazon ElastiCache by logging in to the AWS Management Console and creating a cache cluster in a matter of minutes.

Chris Czarnecki commented on Amazon Simple Workflow Service in a 2/22/2012 post to the Knowledge Tree blog:

imageAmazon continue its relentless release of new Cloud Computing services with the release of the Simple Workflow Service (SWF). This sophisticated service enables distributed asynchronous applications to be implemented as workflow. A workflow is built from three core components:

  • Workflow starters
  • Activity workers
  • Deciders

Workflow starters initiate the workflow. This can be any application. The classic example is a customer placing an order on an e-commerce site starting a workflow that completes with a shipped order and includes all the intermediate stages including payment processing, stock allocation and shipping.

Activity workers are the threads that perform the tasks required by the workflow. These are written by the software developers, in potentially any programming language, and can run anywhere (on-premise or cloud hosted) as long as they can access SWF through the provided API.

Deciders implement the workflows decision logic. The deciders look at the workflow history to determine what has been completed and make a decision as to what to do next.

imageWith the release of SWF, Amazon have provided an elegant solution to a difficult problem: how to build applications that make use of a number of distributed components that can be a mixture of on-premise and cloud hosted and monitor and co-ordinate them in a reliable and scalable manner.

What I like about Amazon AWS in general is that they make it straightforward to use. With SWF, then the service addresses an area that is complex and yet Amazon have provided a clean elegant solution. I look forward to using it soon.

<Return to section navigation list>

http://oakleafblog.blogspot.com/2012/02/windows-azure-and-cloud-computing-posts_23.html

« 
 »