Of course, an interesting questions then comes into your mind: what about users that have previously bought the app? (They do not need to buy individual components in the future version…)

Current Situation: app has unlimited time trial with limited functionality, can be purchased for 2,99 EUR

Future situation: free app, no option to buy, only in app purchases

For anyone who is still on a trial license—meaning downloaded your app as a trial before switching to the freemium (free app + paid IAP) model, we can’t automatically change the license state.  The problem is that in the future free app, the IsTrial will allways return false so you can’t rely on this data alone in order to determine which features should be enabled. In order to resolve this, you need to find out the PurchaseDate from the receipt and compare it against the date your new app version became available. You can grab the receipt, and if the license was full and the purchase date was before it went to freemium, it was a customer who bought the full app; if the license was full and the purchaseDate was after it was freemium, the customer did not pay for the app.

Here’s is some supporting code that can help you determine whether the app has been bought before:

 1: using System;

 2: using System.Collections.Generic;

 3: using System.Linq;

 4: using System.Text;

 5: using System.Threading.Tasks;

 6: using Windows.ApplicationModel.Store;

 7: using Windows.Data.Xml.Dom;

 8:  

 9: namespace License

 10: {

 11:     public class MyLicense 

 12:     {

 13:         private LicenseInformation _li = null;

 14:  

 15:         public MyLicense()

 16:         {

 17: #if DEBUG

 18:             _li = CurrentAppSimulator.LicenseInformation;

 19: #else

 20:             _li = CurrentApp.LicenseInformation;

 21: #endif

 22:         }

 23:  

 24:         public async Task<bool> HasBeenBoughtPreviously()

 25:         {

 26:             string receipt;

 27:  

 28:             //Get the receipt

 29: #if DEBUG

 30:             receipt = await CurrentAppSimulator.GetAppReceiptAsync();

 31: #else

 32:             receipt = await CurrentApp.GetAppReceiptAsync();

 33: #endif

 34:  

 35:             //Parse the receipt

 36:             var xmlRcpt = new XmlDocument();

 37:             xmlRcpt.LoadXml(receipt);

 38:             XmlNodeList xmlPurchaseDateNodes = xmlRcpt.SelectNodes("/Receipt/AppReceipt[@LicenseType='Full']/@PurchaseDate");

 39:  

 40:             if (xmlPurchaseDateNodes.Count == 0)

 41:                 return false;

 42:  

 43:             var purchaseDate = DateTime.Parse(xmlPurchaseDateNodes.First().NodeValue.ToString());

 44:  

 45:             if (purchaseDate < new DateTime(2014, 4, 1))

 46:                 return true;    //The app has been purchased before apr/1st > this is the full license

 47:  

 48:             return false;

 49:         }

 50:  

 51:         public async Task<bool> HasBoughtSomething()

 52:         {

 53:             //Did this user buy the previous full version?

 54:             if (await HasBeenBoughtPreviously())

 55:                 return true;

 56:  

 57:             // Did this user buy at least one feature as an in-app purchase?

 58:             if (_li.ProductLicenses.Any(pl => pl.Value.ProductId.StartsWith("Feature_") && pl.Value.IsActive))

 59:                 return true;

 60:  

 61:             return false;

 62:         }

 63:  

 64:         public async Task<bool> IsTrial()

 65:         {

 66:             return _li.IsTrial;

 67:         }

 68:  

 69:         public async Task<bool> HasBoughtFeature(string featureName)

 70:         {

 71:             if (await HasBeenBoughtPreviously())

 72:                 return true;

 73:  

 74:             var pid = string.Format("Feature_{0}", featureName);

 75:             if (_li.ProductLicenses[pid].IsActive)

 76:                 return true;

 77:  

 78:             return false;

 79:         }

 80:  

 81:         public async Task<bool> BuyFeature(string featureName)

 82:         {

 83:             string path = Windows.Storage.ApplicationData.Current.RoamingFolder.Path;

 84:  

 85:             var pid = string.Format("Feature_{0}", featureName);

 86:  

 87:             try

 88:             {

 89: #if DEBUG

 90:                 var r = await CurrentAppSimulator.RequestProductPurchaseAsync(pid);

 91: #else

 92:                 var r = await CurrentApp.RequestProductPurchaseAsync(pid); 

 93: #endif

 94:             }

 95:             catch (Exception) { }

 96:  

 97:             if (_li.ProductLicenses[pid].IsActive)

 98:                 return true;

 99:  

 100:             return false;

 101:         }

 102:     }

 103: }

This article describes how you can:

1.      Create a simple Web API in Visual Studio 2013 with some bad peforming code

2.      Host it on a Windows Azure cloud service

3.      Create a load test and run it first locally and then cloud-based (new feature of Team Foundation Service)

4.      Get profiling information from the Windows Azure cloud service in order to prove the bad peforming code

5.      Scale your cloud service and compare the load test against a baseline.

First, create a new ASP.NET Web API project in Visual Studio 2013. Change the .NET Framework version from 4.5.1 to 4.5, because otherwise you will get warnings when publishing to Windows Azure (4.5.1 is not yet available at the time of writing this post)

Updated the ValuesController with the following code. (Note there is some real bad peforming code like string concatination)

    public class ValuesController : ApiController

    {

        [HttpGet]

        [ActionName("SlowMethod")]

        public string SlowMethod()

        {

            string s = "";

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

            {

                s += "test";

            }

            return "SlowMethod";

        }

        [HttpGet]

        [ActionName("FastMethod")]

        public string FastMethod()

        {

            string s = "";

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

            {

                s += "test";

            }

            return "FastMethod";

        }

        [HttpGet]

        [ActionName("VerySlowMethod")]

        public string VerySlowMethod()

        {

            string s = "";

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

            {

                s += "test";

            }

            return "VerySlowMethod";

        }

        [HttpGet]

        [ActionName("VeryFastMethod")]

        public string VeryFastMethod()

        {

            return "VeryFastMethod";

        }

    }

Next, change the WebApiConfig so that each method can be mapped correctly to an action on the controller

config.Routes.MapHttpRoute(

       name: "DefaultApi",

       routeTemplate: "api/{controller}/{action}/{id}",

       defaults: new { id = RouteParameter.Optional }

);

In Visual Studio, right click the project and select Add Windows Azure Cloud Service. As a result, a new azure project is added.

Add a couple of additional performance counters by editing the diagnostics.wadcfg file (under BadPerformanceService.Azure\BadPerformanceServiceContent)

<!--Added the following counters-->

<PerformanceCounterConfiguration counterSpecifier="\Processor(_Total)\% Processor Time" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\Process(w3wp)\% Processor Time" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\Process(w3wp)\Private Bytes" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\Process(w3wp)\Thread Count" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\.NET CLR Interop(_Global_)\# of marshalling" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\.NET CLR Loading(_Global_)\% Time Loading" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\.NET CLR LocksAndThreads(_Global_)\Contention Rate / sec" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\.NET CLR Memory(_Global_)\# Bytes in all Heaps" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\.NET CLR Networking(_Global_)\Connections Established" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\.NET CLR Remoting(_Global_)\Remote Calls/sec" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\.NET CLR Jit(_Global_)\% Time in Jit" sampleRate="PT30S" />

<PerformanceCounterConfiguration counterSpecifier="\ASP.NET\Request Execution Time" sampleRate="PT3M"/>

<!--End -->

Right click project and choose Publish to Windows Azure.  Import your publish profile file.

Create a cloud service (name it something like badperformancewebapi) and enable remote desktop if you want.

In the advanced settings, check Enable Profiling and Instrumentation

Publish the cloud service and wait for it to complete.

13:20:52 - Checking for Remote Desktop certificate...

13:20:53 - Preparing deployment for BadPerformanceService.Azure - 10/10/2013 13:20:39 with Subscription ID 'xxxx' using Service Management URL 'https://management.core.windows.net/'...

13:20:53 - Connecting...

13:20:53 - Verifying storage account 'badperformancewebapi'...

13:20:54 - Uploading Package...

13:58:02 - Creating...

13:59:26 - Created Deployment ID: a55622d386774ff1b70cbc2fc5c683a5.

13:59:26 - Instance 0 of role BadPerformanceService is creating the virtual machine

13:59:29 - Starting...

13:59:48 - Initializing...

14:00:21 - Instance 0 of role BadPerformanceService is starting the virtual machine

14:01:59 - Instance 0 of role BadPerformanceService is in an unknown state

14:02:30 - Instance 0 of role BadPerformanceService is busy

14:03:02 - Instance 0 of role BadPerformanceService is ready

14:03:02 - Created Website URL: http://badperformancewebapi.cloudapp.net/

14:03:02 - Complete.

Next, create one or more web tests. In my case, I created 4 separate web tests (one for each method) and parameterized the web server. This allows you to run the test either locally or in the cloud

The load test simply combines the 4 web tests, but if necessary you can create another mix of tests. (Step load pattern 10 up to 200 users, all from 1 machine)

Run the load test against the cloud service and wait for it to complete.

A profiling session is created for each instance of the role in your cloud service. To view your profiling reports of each session from Visual Studio, you can view the Server Explorer window and then choose the Windows Azure node to select an instance of a role. You can then view the profiling report as shown in the following illustration.

Please be aware that it can take a while until the profiling report becomes available.

And voilà, here is the report that allows you to drill down in the different hotpaths.

Right now the load test is all running from your local machine. Your machine becomes a bottleneck as soon as you add more users to the test. You can run the same load test in the cloud, allowing you to scale the number of tests and users.

Create a new test settings file (cloud.testsettings) and choose to run the tests using Visual Studio Team Foundation Service

Make sure you are connected to your Team Foundation Service project and make sure that the cloud test settings file is the active one. (right click your settings file)

Run the load test and notice how the UI is different compared to a local load test. Wait for it to finish (or stop it) and then wait for the collection results.

Then, download and view the report to further diagnose the response time. Alternatively, you can download once more the profiling report from the Windows Azure Cloud Service.

Scale your cloud service and compare the load test against a baseline.

In order to test whether adding more servers (scaling) to your cloud service will indeed increase the performance, follow these steps:

1.      Confirm you have only 1 SMALL Windows Azure Cloud Service instance (1 CORE, 1.75 GB MEMORY)

2.      Run a cloud load test for 10 minutes.

3.      Scale up the environment (for example add a couple of instances) and wait for it to finish.
 

4.      Re-run the cloud load test for 10 minutes and download the report

5.      Create an excel report (click the toolbar icon)
 

6.      Choose to run a comparison
 

7.      Choose the 2 load tests
 

Now you can explore the generated excel file and confirm your performance problem is solved by scaling up. OK, we still might need to get rid of the string concatenation in the code :-)

We want to give you a push in the back to develop great applications – join the Windows 8 App Race and win:

How to win

Your app(s) need to be published between April 1 and June 15, 2013. Complete the contest form(s) on https://aka.ms/race.

There is no limit to the number of entries you can submit but each entry must be substantially unique and different. The date and time of the first and fifth application as part of the entry submitted in a particular timeframe will determine the winners of the tablets. Note: this contest is only open for residents from Belgium and Luxembourg. Please read the full terms & conditions of this contest before entering. Questions? Contact us msdnbewm@microsoft.com.

We’re looking forward to see your apps shine in the Store … and who knows soon on your brand new Asus tablet!

- A6 - 4 cores and 28 GB memory

- A7 - 8 cores and 56 GB memory

Interesting if you want to have more power :-)

There is a New-SPContentDeploymentPath powershell command, but executing this also gave some strange error:

New-SPContentDeploymentPath -Name "<name of my path>" -SourceSPWebApplication $source.WebApplication
-SourceSPSite $source -DestinationCentralAdministrationURL $centralAdministrationURL -DestinationSPWebApplication $destinationURL -DestinationSPSite $destinationURL -KeepTemporaryFilesOptions "Failure" -PathAccount $credentials
-PathEnabled:$true

New-SPContentDeploymentPath : One or more issues preventing successful Content Deployment export were detected on this site collection http://<server>:200/. For more information, go to Content Deployment Source Status page

At line:1 char:1

+ New-SPContentDeploymentPath -Name "200-300 Path" -SourceSPWebApplication $source ...

+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+ CategoryInfo : InvalidData: (Microsoft.Share...tDeploymentPath:

SPCmdletNewContentDeploymentPath) [New-SPContentDeploymentPath], ContentDeloymentException

+ FullyQualifiedErrorId : Microsoft.SharePoint.Publishing.Cmdlet.SPCmdletNewContentDeploymentPath

What's wrong? In SharePoint 2013, you cannot create a content deployment path when certain features are enabled on your source site. These features must be uninstalled/deactivated before you can proceed. Now, how do you now which errors prevent you from setting up a successfull content deployemnt?

1. Navigate to your site collection and choos the site settings. - Go to top level site settings - Site Collection Features
2. Enable the "Content Deployment Source Feature"
3. Find the "Content Deployment Source Status" link under the Site Collection Administration section

Now you see a list of issues that will prevent you from setting up a content deployment path. Note: the site you see below is an out of the box site based on a Publishing template without workflow. No other features have been activated.

Now you need to deactive all of the features, and deactivate the metadata navigation. Once you have done that, the list of issues in the Content Deployment Source Status page should become empty.

Now you can create the Content Deployment Path, either via Central Admin or via powershell commands.

Tip:

The following PowerShell command (example) can help in accomplishing this task.
Disable-SPFeature –Identity SignaturesWorkflowSPD1033 –url $sourceURL –Confirm:$false

While setting up my new environment, I encountered a problem and this took me a while to figure out. Luckily I found a solution and with this article I want to share my experiences.

So what was the problem?

I quickly explain how I’ve set up my environment. I have a Windows Server 2012 with internet access, joined to the active directory domain and a SharePoint 2013 farm has been configured. I have run the default SharePoint 2013 Configuration wizard, and as a result all of the service applications were provisioned automatically using the default settings. I used a technical account for setting up all my service applications (including the User Profile Service application).

Next, I created a web application that contains a site collection based on the publishing template. I created a root variation label (en-us) and created different target variation labels (fr-be and nl-be). (yes, I’m from Belgium and we speak a couple of languages over here). While creating these target variation labels, you can configure how translation needs to happen. Basically, I allowed both human and machine translation.

So, I went ahead and created the hierarchies (ran the timer job "Variations Create Hierarchies Job Definition" and waited for it to complete

Then, I created a new page in the en-us site and added some text, checked in the page and then published it. When I then navigated to the fr-be counterpart, I could choose the following options from the variations ribbon toolbar:

So, I choose the “Machine Translate” action and the first time it takes a while to initialize/set up. Don’t know what actually happens behind the scenes but this is the dialog that you get:

When I clicked on the “Translation Status” action in the ribbon toolbar, I could see that the page was queued for translation. After waiting for a lot of time (at least 15 minutes) the status changed to “in progress”. In the meantime, I started a couple of SharePoint Timer jobs (for example the “Machine Translation Service - Machine Translation Service Timer Job”).

Then, the status of the page changed to “error”. I navigated to the http://<server>/variationlogs/allitems.aspx page and noticed the following information:

When I retried executing the machine translation, I got the error as mentioned above (The translation failed because the online translation service was unavailable)

In the event viewer, I found the following error (Event ID 8311)

An operation failed because the following certificate has validation errors:

Subject Name: CN=*.microsofttranslator.com

Issuer Name: CN=Microsoft Secure Server Authority, DC=redmond, DC=corp, DC=microsoft, DC=com

Thumbprint: 34E4C8A8D13F40FAB97F9655F2A505DDC36BD9C2

Errors:

PartialChain: A certificate chain could not be built to a trusted root authority.

RevocationStatusUnknown: The revocation function was unable to check revocation for the certificate.

OfflineRevocation: The revocation function was unable to check revocation because the revocation server was offline.

When enabling verbose logging on the Translation Services (via Central Admin), I could see the same kind of errors in the ULS logs:

An operation failed because the following certificate has validation errors: Subject Name: CN=*.microsofttranslator.com Issuer Name: CN=Microsoft Secure Server Authority, DC=redmond, DC=corp, DC=microsoft, DC=com Thumbprint: 34E4C8A8D13F40FAB97F9655F2A505DDC36BD9C2 Errors: PartialChain: A certificate chain could not be built to a trusted root authority. RevocationStatusUnknown: The revocation function was unable to check revocation for the certificate. OfflineRevocation: The revocation function was unable to check revocation because the revocation server was offline. .

MicrosoftTranslator: Error encountered: System.ServiceModel.Security.SecurityNegotiationException: Could not establish trust relationship for the SSL/TLS secure channel with authority 'api.microsofttranslator.com'. ---> System.Net.WebException: The underlying connection was closed: Could not establish trust relationship for the SSL/TLS secure channel. ---> System.Security.Authentication.AuthenticationException: The remote certificate is invalid according to the validation procedure.
at System.Net.TlsStream.EndWrite(IAsyncResult asyncResult)
at System.Net.ConnectStream.WriteHeadersCallback(IAsyncResult ar)
--- End of inner exception stack trace ---
at System.Net.HttpWebRequest.EndGetResponse(IAsyncResult asyncResult)
at System.ServiceModel.Channels.HttpChannelFactory`1.HttpRequestChannel.HttpChannelAsyncRequest.CompleteGetResponse(IAsyncResult result)
--- End of inner exception stack trace ---
Server stack trace:
at System.Runtime.AsyncResult.End[TAsyncResult](IAsyncResult result)
at System.ServiceModel.Channels.ServiceChannel.SendAsyncResult.End(SendAsyncResult result)
at System.ServiceModel.Channels.ServiceChannel.EndCall(String action, Object[] outs, IAsyncResult result)
at System.ServiceModel.Channels.ServiceChannelProxy.InvokeEndService(IMethodCallMessage methodCall, ProxyOperationRuntime operation)
at System.ServiceModel.Channels.ServiceChannelProxy.Invoke(IMessage message)
Exception rethrown at [0]:
at System.Runtime.Remoting.Proxies.RealProxy.HandleReturnMessage(IMessage reqMsg, IMessage retMsg)
at System.Runtime.Remoting.Proxies.RealProxy.PrivateInvoke(MessageData& msgData, Int32 type)
at Microsoft.Office.TranslationServices.MachineTranslation.LanguageService.EndTranslate(IAsyncResult result)
at Microsoft.Office.TranslationServices.MachineTranslation.MicrosoftTranslator.EndTranslate(IAsyncResult asyncResult)

PersistBehavior: EndTranslate failed: ServiceUnavailableException Reason: ConnectionFailed Inner exception: Could not establish trust relationship for the SSL/TLS secure channel with authority 'api.microsofttranslator.com'.

How did I resolve this? For some reason the certificate is not trusted. I had to import the certificates (and all certificates up in the chain)

So, I opened up an Internet Explorer instance in Administrator Mode (this is important) and navigate to https://www.microsoft.com (notice I use https). Then, open the File menu (press Alt-F) and choose Properties. On that window, click the button called Certificates. Now you can view and install the certificate. Make sure you repeat this step for all other certificates in the chain. In my case, I forgot the GTE CyberTrust Global Root which results in the other certificates below the chain to be untrusted.

Then, I restarted IIS and the Machine Translation Service (via Central Admin), and hit that button in the ribbon again in order to start the machine translation of the fr-be page.

Finally it proceeded without problems, and my page was translated nicely:

Update:

I don’t know whether this is related to the problem or not, but in my environment, I had explicitly disabled “Automatically update certificates in the Microsoft Root Certificate Program” in order to speed up loading of my SharePoint infrastructure. As far as I know, this should not have an impact on SharePoint, besides the .NET framework loading up assemblies faster because it doesn’t need to validate certificates online.

All eligible MSDN subscribers receive a free, one-year Windows Store developer account as part of their MSDN benefits. (Eligible subscriptions include Visual Studio Professional, Test Professional, Premium, Ultimate, and BizSpark.)

We have a program for students—DreamSpark—that similarly waives the subscription fee. And we have an offer for businesses in our BizSpark program, as well.

If you are not part of any of these programs, you can register for a Windows Store developer account and submit apps if you live or operate a business in a country or region listed here. In Belgium, the annual registration fee is 37 EUR for individuals and 75 EUR for companies.

Keep the apps coming!

Grasp the first-mover advantage too and make sure your app is in the Windows Store by the time Windows 8 hits the market on October 26th.

Develop an app NOW and get a €100 Connections Gift Voucher!

Millions of people around the world use Windows every day. Windows 8 gives you the opportunity to access this huge potential market by listing your apps in the Windows Store!

Take 4 simple steps by September 14, 2012: Download the tools you need Follow on & offline training Attend an App Clinic Pass an App Excellence Lab

An App Excellence Lab is a 2-hour review of your application together with a Microsoft engineer. If your app meets all the requirements, you will receive the €100 Connections voucher and a Windows Store token!

Read the full terms & conditions of this promo.

From the batcave: Nico Vermeir – ComicDB

First in our series of #win8devbe app heroes is Nico Vermeir with a juicy story on the development of his comic app.

Do you think your app deserves a place in the spotlights too? Then just contact us!

Summer App-a-thon 8/8 @ our place :-)

Don't miss the Second Summer App-a-thon on August 8th at Microsoft Zaventem. You can get in the running for an Xbox 360 + Kinect and Connections Gift Vouchers! No app idea yet? No problem! We will kick off the sessions with an inspiring hour of brainstorming! Participation is FREE and seats are limited so be quick and book your seat now!

This is the code:

using (var siteCollection = new SPSite(siteCollectionUrl))
{
….
}

I double checked the following possible issues:

• Are we running Visual Studio in Elevated Administrator mode?
• Is the code compiled in 64bit mode?
• Do we have any features deployed to the site that might cause this behavior?

However, everything seemed to be OK on the configuration side. Then, I started to validate the permissions on both the database level as well in SharePoint. But again, everything should have been OK.

In the ULS logs, I found the following error message appearing every time I called the SPSite constructor:

An exception occured while trying to acquire the local farm:

System.TypeInitializationException: The type initializer for 'System.Data.SqlClient.SqlConnection' threw an exception.
---> System.TypeInitializationException: The type initializer for 'System.Data.SqlClient.SqlConnectionFactory' threw an exception.
---> System.TypeInitializationException: The type initializer for 'System.Data.SqlClient.SqlPerformanceCounters' threw an exception.
---> System.Configuration.ConfigurationErrorsException: Configuration system failed to initialize
---> System.Configuration.ConfigurationErrorsException: Unrecognized configuration section serviceBehaviors. (C:\Projects\GenerateSampleData\bin\Debug\GenerateSampleData.exe.Config
line 6)    
at System.Configuration.ConfigurationSchemaErrors.ThrowIfErrors(Boolean ignoreLocal)    
at System.Configuration.BaseConfigurationRecord.ThrowIfInitErrors()    
at System.Configuration.ClientConfigurationSystem.EnsureInit(String configKey)    

--- End of inner exception stack trace ---    

at System.Configuration.ClientConfigurationSystem.EnsureInit(String configKey)    
at System.Configuration.ClientConfigurationSystem.PrepareClientConfigSystem(String sectionName)    
at System.Configuration.ClientConfigurationSystem.System.Configuration.Internal.IInternalConfigSystem.GetSection(String sectionName)    
at System.Configuration.ConfigurationManager.GetSection(String sectionName)    
at System.Configuration.PrivilegedConfigurationManager.GetSection(String sectionName)    
at System.Diagnostics.DiagnosticsConfiguration.Initialize()    
at System.Diagnostics.Switch.InitializeConfigSettings()    
at System.Diagnostics.Switch.InitializeWithStatus()    
at System.Diagnostics.Switch.get_SwitchSetting()    
at System.Data.ProviderBase.DbConnectionPoolCounters..ctor(String categoryName, String categoryHelp)    
at System.Data.SqlClient.SqlPerformanceCounters..ctor()    
at System.Data.SqlClient.SqlPerformanceCounters..cctor()    

--- End of inner exception stack trace ---    

at System.Data.SqlClient.SqlConnectionFactory..ctor()    
at System.Data.SqlClient.SqlConnectionFactory..cctor()    

--- End of inner exception stack trace ---    

at System.Data.SqlClient.SqlConnection..cctor()    

--- End of inner exception stack trace ---    

at System.Data.SqlClient.SqlConnection..ctor(String connectionString)    
at Microsoft.SharePoint.Utilities.SqlSession.OpenConnection()    
at Microsoft.SharePoint.Utilities.SqlSession.ExecuteReader(SqlCommand command, CommandBehavior behavior, SqlQueryData monitoringData, Boolean retryForDeadLock)    
at Microsoft.SharePoint.Utilities.SqlSession.ExecuteReader(SqlCommand command, Boolean retryForDeadLock)    
at Microsoft.SharePoint.Utilities.SqlSession.ExecuteReader(SqlCommand command)    
at Microsoft.SharePoint.Upgrade.SPDatabaseSequence.GetVersion(SPDatabase database, Guid id, Version defaultVersion, SqlSession session, SPDatabaseSequence sequence)    
at Microsoft.SharePoint.Upgrade.SPDatabaseSequence.get_SchemaVersion()     at Microsoft.SharePoint.Upgrade.SPSequence.get_IsBackwardsCompatible()    
at Microsoft.SharePoint.Upgrade.SPUpgradeSession.IsBackwardsCompatible(Object o, Boolean bRecurse)    
at Microsoft.SharePoint.Administration.SPPersistedUpgradableObject.get_IsBackwardsCompatible()    
at Microsoft.SharePoint.Administration.SPPersistedUpgradableObject.ValidateBackwardsCompatibility()    
at Microsoft.SharePoint.Administration.SPConfigurationDatabase.Initialize(SqlConnectionStringBuilder connectionString, Boolean enableCaching, Boolean checkCompatibility, Boolean bindRequestGuid)    
at Microsoft.SharePoint.Administration.SPConfigurationDatabase.Initialize(SqlConnectionStringBuilder connectionString, Boolean enableCaching, Boolean checkCompatibility)    
at Microsoft.SharePoint.Administration.SPConfigurationDatabase.get_Local()    
at Microsoft.SharePoint.Administration.SPFarm.FindLocal(SPFarm& farm, Boolean& isJoined) 

The interesting part was the "Unrecognized configuration section" and "Configuration system failed to initialize" messages that appeared in the logs.

Then, I realized we had some app.config file toghether with our console application, which contained some settings:

The serviceBehavors element was causing this issue! As soon as we commented out this section in the app.config file, the problem disappeared.

Hope this can help you next time!

In order to authenticate, we will use an existing STS endpoint: https://www.e-contract.be/eid-idp/endpoints/ws-federation/metadata/auth-ident-metadata.xml, from which we will retrieve a set of claims.

[Update]
If you haven't done so far, please install the Windows Identity Foundation SDK (WIF). This add the "Add STS Reference" in Visual Studio.

1. Open Visual Studio 2010 and create a new ASP.NET MVC 3 Web Application. Select the .NET Framework 4.
2. Choose the Internet Application template, and select the Razor engine.
   
3. Run the application by pressing F5. Notice the URL (in my case I use the ASP.NET Development Server, using port 25935)
   
4. Close the application and return to Visual Studio
5. Right click the project and choose Add STS Reference.
6. In the Application URI, enter the following address: http://localhost:25935 (change the port number)
   
7. Click Next.
8. Select Use an existing STS and enter the following address: https://www.e-contract.be/eid-idp/endpoints/ws-federation/metadata/auth-ident-metadata.xml
   
9. Click Next.
   
10. Click Next.
    
    Note: here you should be able to see all the claim types offered by the e-contract endpoint
11. Click Finish.

1. When you now hit F5 to run the application again, you will see that the browser redirects you to an external site:
   

    

2. Enter your PIN code (make sure you know this)
   

    

3. After you are authenticated, the values from your Belgian eID card are read out.
4. Next, you will be transferred again to you ASP.NET MVC Application, but it will return a Server Error:
   
   
   This happens because the claims are send in <xml> format to the web application. ASP.NET doesn't allow it because this may be an attempt to compromise the security.
5. The safest way to validate the request while still preserving security, is to introduce a custom RequestValidator. To create custom request validation, you write a custom class that derives from the RequestValidator base class. You then configure ASP.NET to use the custom request validator in the application-level Web.config file.

1. Create a custom class and name it SampleRequestValidator.

1. Add a reference to Microsoft.IdentityModel. (location: C:\Program Files\Reference Assemblies\Microsoft\Windows Identity Foundation\v3.5\Microsoft.IdentityModel.dll)

using System;

using System.Web;

using System.Web.Util;

using Microsoft.IdentityModel.Protocols.WSFederation;

/// <summary>

/// This SampleRequestValidator validates the wresult parameter of the

/// WS-Federation passive protocol by checking for a SignInResponse message

/// in the form post. The SignInResponse message contents are verified later by

/// the WSFederationPassiveAuthenticationModule or the WIF signin controls.

/// </summary>

public class SampleRequestValidator : RequestValidator

{

    protected override bool IsValidRequestString(HttpContext context, string value, RequestValidationSource requestValidationSource, string collectionKey, out int validationFailureIndex)

    {

        validationFailureIndex = 0;

        if (requestValidationSource == RequestValidationSource.Form && collectionKey.Equals(WSFederationConstants.Parameters.Result, StringComparison.Ordinal))

        {

            var message = WSFederationMessage.CreateFromFormPost(context.Request) as SignInResponseMessage;

            if (message != null)

            {

                return true;

            }

        }

        return base.IsValidRequestString(context, value, requestValidationSource, collectionKey, out validationFailureIndex);

    }

}

1. Open the web.config file, and put the following setting directly below the <system.web> section:

<system.web> 

    <httpRuntime requestValidationType="SampleRequestValidator" /> 

 … 

</system.web> 

1. Run the application again. After you have been authenticated, you should already see a different behavior: you name will be displayed in the header section:
   
2. To display all the claim information that is sent to us, open the HomeController and return a view with all the claims:

public ActionResult Index() 

{ 

    ViewBag.Message = "Welcome to ASP.NET MVC!"; 

    var claimsIndentity = User.Identity as ClaimsIdentity; 

    return View(claimsIndentity.Claims); 

} 

1. Open the Index.cshtml view
2. Add the @model directive at the top of the file:

@model IEnumerable<Microsoft.IdentityModel.Claims.Claim> 

1. Create a table and loop through all the available claims:

<table> 

    @foreach (var item in Model) 

 {  

        <tr> 

            <td> 

                @Html.DisplayFor(modelItem => item.ClaimType) 

            </td> 

            <td> 

                @Html.DisplayFor(modelItem => item.Issuer) 

            </td> 

            <td> 

                @Html.DisplayFor(modelItem => item.Value) 

            </td> 

        </tr> 

 } 

</table> 

1. Run you application again, authenticate and verify the results