• The time it takes us to investigate and determine whether we can recover the data at the primary location or if we should do the failover
• Failover the account by changing the DNS entries

1. Use RA-GRS
2. Find the IP location of your <storage account>-secondary endpoint
3. Create a new storage account on that same stamp/IP if possible or a different stamp in the same data center the -secondary is located in
4. Use the secondary endpoint on the RA-GRS to copy the blob to the new storage account created above making it a writable copy
5. Deploy your VM to that new data center (preferably through script) and bring it back up using the new storage.

1. If you can’t get on the same stamp the RA-GRS uses, then copies between stamps in the same data center take time. See this article - there is a chart there that detail the time to copy between stamps and data centers.
2. Recovery Point Objective is 15 minutes for RA-GRS, but there is no SLA on Geo-replication, so there may be some data loss since Geo-Replication is asynchronous. From another blog post:
   1. Recover Point Objective (RPO): In GRS and RA-GRS the storage service asynchronously geo-replicates the data from the primary to the secondary location. If there was a major regional disaster and a failover had to be performed, then recent delta changes that had not been geo-replicated could be lost. The number of minutes of potential data lost is referred to as RPO (i.e., the point in time to which data can be recovered to). We typically have a RPO less than 15 minutes, though there is currently no SLA on how long geo-replication takes.

"ServicePointManager doesn't support proxies with https scheme"

This was odd since they did not specify https as the scheme for their proxy.  Instead, they had specified their proxy specifically in their devenv.exe.config file as https://myproxy.corp.com

Turns out that the Package Manager tool in Visual Studio uses the proxy set in IE when it tries to connect to the NuGet package source.  In this particular environment the client proxies were being set by IEAK and had INS file settings that looked like this:

[Proxy]

HTTP_Proxy_Server=proxy.corp.com:8235

FTP_Proxy_Server=proxy.corp.com:8235

Secure_Proxy_Server=proxy.corp.com:8235

Socks_Proxy_Server=proxy.corp.com:8235

Use_Same_Proxy=1

Proxy_Enable=1

The problem was that the scheme was not specified.  To correct this, the proxies listed in the INS file should have looked like this:

[Proxy]

HTTP_Proxy_Server=https://proxy.corp.com:8235

FTP_Proxy_Server=https://proxy.corp.com:8235

Secure_Proxy_Server=https://proxy.corp.com:8235

Socks_Proxy_Server=https://proxy.corp.com:8235

Use_Same_Proxy=1

Proxy_Enable=1

This issue was originally BLOG'd about by Jeff Sanders and pointed out to me by Tim Lovell-Smith.  Thanks for the help!

 // Create a new request to the mentioned URL.
 WebRequest myWebRequest=WebRequest.Create("https://www.contoso.com");
 
 WebProxy myProxy=new WebProxy();
 
 // Obtain the Proxy Prperty of the Default browser. 
 myProxy=(WebProxy)myWebRequest.Proxy;
 
 

that throws the following exception on the last line of code when you run it:

"Unable to cast object of type 'WebProxyWrapper' to type 'System.Net.WebProxy'"

If you need to get the code to work without the exception, try this:

 Uri address = new Uri(https://www.bing.com);
 HttpWebRequest request = (HttpWebRequest)WebRequest.Create(address);
 IWebProxy myProxy = request.Proxy;
 Uri proxyUri = myProxy.GetProxy(address);

Note, if there is no proxy set, the proxy returned in proxyUri will be equal to the URL address.  You can confirm this though a simple comparison of the URIs like this:

if (address.Equals(proxyUri))

 I will link the MSDN article to this BLOG so that the documentation can be corrected.

In Visual Studio, under Server Explorer, when you have the Azure tools installed you can use it to connect to a Storage Account in Windows Azure.  When you configuring it, there is an option called “Remember account key”.  Visual Studio keeps those settings for Azure in a file located in the following directory:

C:\Users\<username>\Documents\Visual Studio 2012\Settings\Windows Azure Connections.xml

If you backup and restored this file before reinstalling the OS, it would have everything it needs to connect to Azure on your behalf and get the list of storage accounts directly.  Once it has the thumbprint information associated with the subscription ID, it connects to the management portal directly using the Management API.

We found that the Microsoft.VSTS.TCM.AutomationStatus field was not a valid field to test when setting default values.  Instead, if you check for Microsoft.VSTS.TCM.AutomatedTestId, then you will be able to set your defaults.

The items in the view are created from a binding to the Data\InboxObject.  The sample only shows three conversations with a couple of messages in each conversation.  I’m going to shorten the text of the conversations here so that they can be displayed on single lines in this BLOG.

// (c) Copyright Microsoft Corporation.

// This source is subject to the Microsoft Public License (Ms-PL).

// Please see https://go.microsoft.com/fwlink/?LinkID=131993 for details.

// All other rights reserved.

using System.Collections.ObjectModel;

namespace PhoneToolkitSample.Data

{

    public class InboxObject : ObservableCollection<ConversationObject>

    {

        public InboxObject() : base()

        {

            ConversationObject one = new ConversationObject("3 messages, 0 unread");

            one.Add(new EmailObject("Anne Wallace", "Lunch Today?", "Sure!"));

            one.Add(new EmailObject("Me", "Lunch Today?", "OK, ask Dave?"));

            one.Add(new EmailObject("Bruno Denuit", "Lunch Today?", "I vote for Thai."));

            ConversationObject two = new ConversationObject("1 messages, 0 unread");

            two.Add(new EmailObject("Adriana Giorgi", "Fun trip?", "Lucky you ..."));

            ConversationObject three = new ConversationObject("4 messages, 1 unread");

            three.Add(new EmailObject("Belinda Newman", "hawaii pics!", "Good times."));

            three.Add(new EmailObject("Richard Carey", "hawaii pics!", "Cool fish."));

            three.Add(new EmailObject("Christof Sprenger", "hawaii pics!", "Can't wait to get back."));

            three.Add(new EmailObject("Melissa Kerr", "hawaii pics!", "Check it and tag"));

            Add(one);

            Add(two);

            Add(three);

        }

    }

}

Now, what happens if you have 60 conversations you need to display instead of three?  A slight modification to the code will get us there:

public class InboxObject : ObservableCollection<ConversationObject>

{

    public InboxObject() : base()

    {

        for (int i = 0; i < 20; i++)

        {

            ConversationObject one = new ConversationObject("3 messages, 0 unread");

            one.Add(new EmailObject("Anne Wallace", "Lunch Today?", "Sure!"));

            one.Add(new EmailObject("Me", "Lunch Today?", "OK, ask Dave?"));

            one.Add(new EmailObject("Bruno Denuit", "Lunch Today?", "I vote for Thai."));

            ConversationObject two = new ConversationObject("1 messages, 0 unread");

            two.Add(new EmailObject("Adriana Giorgi", "Fun trip?", "Lucky you ..."));

            ConversationObject three = new ConversationObject("4 messages, 1 unread");

            three.Add(new EmailObject("Belinda Newman", "hawaii pics!", "Good times."));

            three.Add(new EmailObject("Richard Carey", "hawaii pics!", "Cool fish."));

            three.Add(new EmailObject("Christof Sprenger", "hawaii pics!", "Can't wait to get back."));

            three.Add(new EmailObject("Melissa Kerr", "hawaii pics!", "Check it and tag"));

            Add(one);

            Add(two);

            Add(three);

        }

    }

}

In the emulator runs the code runs without any problem.  My Windows Phone 7 device is an LG Quantum and running this code there took 11-14 seconds.  That’s 11-14 seconds of the user staring at a blank screen.  My guess this isn’t the smooth slick user experience you want your users to have, so how do you go about fixing that? 

Digging into the sample, the first thing I did was profile the application on the device itself.  It was pretty clear that the UI thread was the culprit (MeasureOverride to be specific).  The UI control calculates its layout every time you add an individual item; there currently isn’t a way around this.  What I needed was an AsyncObservableCollection that could be smart enough to load the items of the collection when the UI was idle.  But how do you detect that the UI is idle on the WP7? 

On the WP7 device, when the UI is inactive, there are no spinning cycles, so if there is no work to do, then nothing is done.  In the above code, all of the items are being created and added all on the UI thread, so the application isn’t responsive until the code completes.  Additionally, using a construct like Deployment.Current.Dispatcher.BeginInvoke doesn’t help us either since doing this will still create all the objects on the UI thread and then queue the additions to the UI thread as soon as we complete.  What we need is a way to put the items onto the UI thread after we’ve created them a little at a time so as not to block the UI thread from user input.  That’s where AsyncObservableCollection comes in.

//-----------------------------------------------------------------------------

//

// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF

// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO

// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A

// PARTICULAR PURPOSE.

//

// Copyright (c) Microsoft Corporation. All rights reserved.

//

//

//-----------------------------------------------------------------------------

using System.Collections.Generic;

using System.Collections.ObjectModel;

using System.Linq;

using System.Threading;

using System.Windows;

using System.ComponentModel;

using System;

namespace PhoneToolkitSample.Data

{

    public class AsyncObservableCollection<T> : ObservableCollection<T>

    {

        // Only one of these should exist for all instances

        static AutoResetEvent myEvent = null;

        public void FillAsync(IEnumerable<T> list)

        {

            // Create event on first use

            if (null == myEvent)

            {

                myEvent = new AutoResetEvent(false);

            }

            Thread t = new Thread(new ThreadStart(() =>

            {

                // First wait is to pause the thread to allow non-bound

                // actions to transition into view on the UI thread.

                WaitForUI();

                int i = 0;

                foreach (T item in list)

                {

                    T copy = list.ElementAt(i);

                    Deployment.Current.Dispatcher.BeginInvoke(() => { this.Add(copy); });

                    WaitForUI();

                    i++;

                }

            }));

            t.Name = "FillAsync";

            t.Start();

        }

        private void WaitForUI()

        {

            // Wait for the UI thread to free up before adding another

            Deployment.Current.Dispatcher.BeginInvoke(() => { UIFree(); });

            myEvent.WaitOne();

            // A short sleep to stay responsive on the UI thread

            Thread.Sleep(10);

        }

        public void UIFree()

        {

            // Called on the UI thread as soon as the add is completed

            myEvent.Set();

        }

    }

}

Let me explain what is going on in this class.  The main method in this class is FillAsync.  FillAsync creates a background thread to add items into the expander view on the UI thread by using the BeginInvoke method on the Dispatcher.   After an item is added through this method, we call a separate method called WaitForUI.  WaitForUI is a slick way to verify that the UI has completed adding the previously added item and gives the UI a chance to respond to user input, typically scrolling.  The AsyncObservableCollection object creates an AutoResetEvent that is triggered once the UI has freed up.  To trigger this event, we need to get the UI to set the event when it is free.  To do this, we queue up a call to UIFree through the BeginInvoke method on the Dispatcher as well.   A picture may help:

The background thread dispatches the Add method followed by a dispatch to FreeUI method and then waits for the event to trigger.  The UI thread receives the add call, completes it, calls UIFree which in turn sets the event.  This triggers the event and the background thread ends blocking in the WaitAny call, sleeps for 10ms and then continues through the main loop to add the next item.  This process repeats until all the items are finally added through the background thread.  We give ourselves a 10ms sleep in the background thread to help the UI be a little more responsive.

Now to hook this all up, you need to change the InboxObject so that it derives from AsyncObservableCollection.  Then create a new List object called conversations of type ConversationObject and instead of adding the new ConversationObjects to the base of the ObservableCollection through the add method, add the object to this new list object.  Once all of the conversations are completed, you can then call FillAsync with your List object and allow the items to be added to the UI in the background.  The result is that we immediately begin to see the items populate on the device and we are allowed to start scrolling with just a little stuttering.  This is a much better result than waiting 10+ seconds before anything is displayed on the device.  The new code for the InboxObject is shown below.

// (c) Copyright Microsoft Corporation.

// This source is subject to the Microsoft Public License (Ms-PL).

// Please see https://go.microsoft.com/fwlink/?LinkID=131993 for details.

// All other rights reserved.

using System.Collections.ObjectModel;

using System.Collections.Generic;

namespace PhoneToolkitSample.Data

{

    public class InboxObject : AsyncObservableCollection<ConversationObject>

    {

        public InboxObject() : base()

        {

            List<ConversationObject> conversations = new List<ConversationObject>();

            for (int i = 0; i < 20; i++)

            {

                ConversationObject one = new ConversationObject("3 messages, 0 unread");

                one.Add(new EmailObject("Anne Wallace", "Lunch Today?", "Sure!"));

                one.Add(new EmailObject("Me", "Lunch Today?", "OK, ask Dave?"));

                one.Add(new EmailObject("Bruno Denuit", "Lunch Today?", "I vote for Thai."));

                ConversationObject two = new ConversationObject("1 messages, 0 unread");

                two.Add(new EmailObject("Adriana Giorgi", "Fun trip?", "Lucky you ..."));

                ConversationObject three = new ConversationObject("4 messages, 1 unread");

                three.Add(new EmailObject("Belinda Newman", "hawaii pics!", "Good times."));

                three.Add(new EmailObject("Richard Carey", "hawaii pics!", "Cool fish."));

                three.Add(new EmailObject("C<shorten>r", "h pics!", "Can't wait to get back."));

                three.Add(new EmailObject("Melissa Kerr", "hawaii pics!", "Check it and tag"));

                conversations.Add(one);

                conversations.Add(two);

                conversations.Add(three);

            }

            // Fill the UI in the background

            this.FillAsync(conversations);

        }

    }

}

There is one major drawback with this code as it is presented; you end up making a copy of each of the items before it is presented to the UI thread.  For simplicity in demonstrating this technique, I’ve left this drawback in the code.

https://support.microsoft.com/kb/2544407

The directory object for MSMQ (called msmq) is contained in Active Directory when in domain mode.  That object is located at the LDAP path derived from the algorithm below:

<fqdn>/X/<machine name>/msmq

Where X is evaluated as:

if <machine name> is a domain controller then

   x = "Domain Controllers"

else

   x = "Computers"

 In my case, I had a domain named “PKMSMQ.PKING.COM”.  My domain controller was the computer “MSMQ-AD”, and that was the machine I installed MSMQ on.  Realize that is not recommended to install MSMQ on the domain controller, but I took a short cut here instead.  My complete LDAP object path in this case is:

LDAP://CN=msmq,CN=MSMQ-AD,OU=Domain Controllers,DC=PKMSMQ,DC=PKING,DC=COM

If I had been working on a server within that domain, My LDAP object path would have looked like this:

LDAP://CN=msmq,CN=MSMQSERVER,CN=Computers,DC=PKMSMQ,DC=PKING,DC=COM

Notice the difference here.  'Domain Controllers' is an organizational unit and 'Computers' is just a container.  I missed that difference in my original post.

Some simple code to adjust the value is shown below:

// Get the object and the value

DirectoryEntry de = new DirectoryEntry(<YOUR LDAP PATH>);

int value = (int) de.Properties["mSMQQuota"].Value;

// Remove one from the value and set it

value--;

de.Properties["mSMQQuota"].Value = value;

de.CommitChanges();

// Close the directory entry

de.Close();

Hope this helps someone!

<UPDATED - Feb 9. 2012>

Some additional details on this solution were discovered after I published this article.  In some cases (Windows 7 machines), mSMQQuota is not set.  Instead a default value is used and this code:

 int value = (int) de.Properties["mSMQQuota"].Value;

will cause an exception to be thrown.  To set the value int this case, you can avoid the exception by not checking the value first and just setting it.  The default value is 1048576 KB and setting the value is as easy as:

de.Properties["mSMQQuota"].Value = 1048576;

de.CommitChanges();

A better code sample in this case is shown below:

// Get the object and the value

DirectoryEntry de = new DirectoryEntry(lblObjName.Text);

bool result = false;

try

{

    result = de.Properties.Contains("mSMQQuota");

}

catch (Exception ex)

{

    // If we throw an exception here, MSMQ may not be installed in AD mode

    MessageBox.Show(this, string.Format("{0}{1}{2}",

        "The msmq configuration object was not found.  ",

        "MSMQ may not be installed in AD mode.\r\n\r\n",

        ex.Message),

        "MSMQ Directory App", MessageBoxButtons.OK,

        MessageBoxIcon.Exclamation);

    de.Close();

    return;

}

if (!result)

{

    // Property is not set yet

    DialogResult dr = MessageBox.Show(this, string.Format("{0}{1}",

        "mSMQQuota is not found.  Property is not set yet.  ",

        "Do you wish to set it to the default value of 1048576 KB?"),

        "MSMQ Directory App", MessageBoxButtons.YesNo,

        MessageBoxIcon.Question);

    if (DialogResult.Yes == dr)

    {

        de.Properties["mSMQQuota"].Value = 1048576;

        de.CommitChanges();

    }

}

else

{

    int value = (int)de.Properties["mSMQQuota"].Value;

    // Remove one from the value and set it

    value--;

    de.Properties["mSMQQuota"].Value = value;

    de.CommitChanges();

    MessageBox.Show(this, string.Format(

        "mSMQQuota changed to {0} on object: {1}",

        value, lblObjName.Text), "MSMQ Directory App",

        MessageBoxButtons.OK,

        MessageBoxIcon.Information);

}

// Close the directory entry

de.Close();

This covers the problem of MSMQ not being installed and setting the quota value when once does not already exist.  An additional issue is when the schema for your directory includes other organizational units.  When this happens, the simplistic naming rules shown here do not find the correct computer objects.  A better solution is to search for the computer in the directory.  This can be done by using the DirectorySearcher class in the .Net Framework.  A code sample to find the correct path to a computer within the domain can be found below.

 // Find the domain we are working in

DirectoryEntry de = new DirectoryEntry("LDAP://rootDSE");

string root = de.Properties["defaultNamingContext"].Value.ToString();

de.Close();

// Query the domain for all the machines in the domain

de = new DirectoryEntry("LDAP://" + root);

DirectorySearcher ds = new DirectorySearcher(de,

string.Format("(&(objectCategory=computer)(CN={0}))",

    txtFindComputer.Text));

SearchResultCollection coll = ds.FindAll();

// Validate there is only one item in the collection

if (coll.Count > 1)

{

    // If more than one machine is found, abort processing.

    // You could display a list of the machines found

    // and let the user pick which one to adjust

    MessageBox.Show(this, string.Format(

        "{0} computers matched the computer name.  Processing Aborted.",

        coll.Count), "MSMQ Directory App",

        MessageBoxButtons.OK,

        MessageBoxIcon.Exclamation);

}

else if (coll.Count == 1)

{

    // One computer found, populate our LDAP Object Path

    DirectoryEntry targetComputer = coll[0].GetDirectoryEntry();

        lblObjName.Text = targetComputer.Path.Insert(7, "CN=msmq,");

    targetComputer.Close();

    MessageBox.Show(this, string.Format(

        "Computer {0} found.  LDAP Object Path updated.",

        txtFindComputer.Text), "MSMQ Directory App",

        MessageBoxButtons.OK,

        MessageBoxIcon.Information);

}

else

{

    // No computers found matching that name

    MessageBox.Show(this, string.Format(

        "No computers matched the computer name {0}.  Processing Aborted.",

        txtFindComputer.Text),

        "MSMQ Directory App",

        MessageBoxButtons.OK,

        MessageBoxIcon.Information);

}

de.Close();

I have updated the code sample below to include these updates as well.  Enjoy!

MSMQ Directory App.zip

System.Web.HttpException:
The URL-encoded form data is not valid. ---> System.InvalidOperationException: Operation is not valid due to the current state of the object.
   at System.Web.HttpValueCollection.ThrowIfMaxHttpCollectionKeysExceeded()
   at System.Web.HttpValueCollection.FillFromEncodedBytes(Byte[] bytes, Encoding encoding)
   at System.Web.HttpRequest.FillInFormCollection()
   --- End of inner exception stack trace ---
   at System.Web.HttpRequest.FillInFormCollection()
   at System.Web.HttpRequest.get_Form()

The key here is ThrowIfMaxHttpCollectionKeysExceeded.  If that is in your stack trace, you know that you have exceeded the value the patch imposes.

To keep this exception from being thrown, you need to change the value of aspnet:MaxHttpCollectionKeys in the web.config of your application to a value that is as high as the highest allowed count of keys in your hash table. 

To help you figure out what value you should use in production, I have created a HTTP Module that counts the number of keys in that collection for each request and stores the high water mark in the event log once the module is unloaded.  I have included a sample that shows how this works.

For you to test this in your application, you need to build the MS11-1000Helper.DLL and place it in your web application’s Bin directory.  Once you have done this, you need to add the following to your web.config file to enable the HTTP Module:

<system.web>

    <httpModules>

      <add type="MS11_100_Helper.CounterModule, MS11-100-Helper" name="CounterModule" />

    </httpModules>

</system.web>

Additionally, you need to add the following to your appSettings:

<appSettings>

    <!--

      This is a super high number to use as a starting point in TESTING your application. 

      You should never have a number like this in your PRODUCTION web.confg.

      Instead, you should use this HTTP module (MS11-100-Helper.dll) to help you determine

      the appropriate number to use for your setting in PRODUCTION.

    -->

    <add key="aspnet:MaxHttpCollectionKeys" value="9999" />

</appSettings>

Then you should TEST your application.  If you are dynamically generating Forms items in your application, you need to test with the highest amount of generated UI as you expect to ever see while your application is being run. 

After you have tested the above scenario, you need to close the browser and terminate the web server (stop the development server or issue an IISRESET).  Once you have done this, the high water mark should be written to the event log “Applications and Services Logs/CounterSourceLog” and you should have an Information entry that looks like this:

Largest Value Seen = X

Where X is some number. 

You can then use this number to help you set the value of aspnet:MaxHttpCollectionKeys in production. 

I would personally set the number to be a little higher than the value here, but that depends on the application.  If you don’t have a lot of dynamically generated forms controls, then the number is probably pretty close to what you can use for your deployed application.  You might want to add just a few more to the value just in case you have a last minute tweak that puts you over the limit.

If you have pages that can dynamically generate a ton of controls without limit (indicating a bad design), then this isn't going to help you much.

Just be sure to remove the module and 9999 limit from your production code!!! 

There are a couple of additional caveats with this as far as being the end all to this issue. 

First, realize that MS11-100 is a workaround to help limit a DOS attack.  The final fix will be to randomize the hash tables used in the ASP.Net will be in a change that comes later.  Once that change is available, this workaround may not be needed.

Second, this helper only counts the keys in the Form collection.  If you are running into an issue where you are seeing an exception thrown for Json, then this code will not help you.

Third, if the high water mark is less than 1000, I wouldn't recommend changing the default app setting of aspnet:MMaxHttpCollectionKeys.  A DOS attacker will probably be hitting numbers much higher than this to cause the issue to occur, which is why we choose the number to begin with.

Fourth, anytime you make an application change, you should reuse this tool in TEST to help you figure out the value of the setting in production.

Special thanks to Wyn Lewis-Bevan for the idea on developing this helper!

MS11-100-Helper.zip

REQUIREMENT: On any error, display the error message as richly formatted text and allow for URLs to take the user to additional assistance.

No problem, there is a RichTextBox control in .Net that will do this for you.  You make up all the text as RTF, load it at run-time as needed, follow the guidance on MSDN here for linking to the web and you have a nifty dialog that will satisfy the above requirement in a very short period of time.

You then receive some additional information about the requirement:

REQUIREMENT: On any error, display the error message as richly formatted text and allow for arbitrary text to act as a hyperlink to take the user to additional assistance.

No problem - you just modify your RFT to create the hyperlinks and you're all set.  Then you see the result:

Wait a minute.  That's not what's in my RTF file.  You specified this:

Unfortunately the RichTextBox control doesn't handle the anchor tag the way you can if you were authoring this as HTML.  So, what are you supposed to do?  There are some solutions on the web, for modifying the RichTextBox control, but you want to avoid licensing issues.  This is where I see Scotty from Star Trek saying, 'How many times do I have to tell you, the right tool for the right job!'.  If you need links to look like they would on a web page, then create a WebBrowser control to display the text instead of the RichTextBox control!  It couldn't be simpler.  Sway out the controls and to handle the user clicking on the link generically, you only need to write a couple of lines of code. 

In your form load method, add the event handler:

webBrowser1.Navigating += new WebBrowserNavigatingEventHandler(webBrowser1_Navigating);

And your event handler should have this code:

private void webBrowser1_Navigating(object sender, WebBrowserNavigatingEventArgs e)

{

   // Override the navigation property and just bring up a web browser

     System.Diagnostics.Process.Start("IEXPLORE.EXE", e.Url.ToString());

   // Stop any navigation in our control

      e.Cancel = true;

}

Here is the final result.  Looks nice doesn't it?