We have released a new version of the Tailspin Travel demo in January that is focused exclusively on showing off some of the new features in ASP.NET MVC 2. A large number of the developers looking to learn/evaluate the use of ASP.NET MVC 2 are still using Visual Studio 2008, so we wanted to make sure to provide them with an option. That means that the only requirement for developers to make use of this demo is (assuming they have VS2008 and SQL Express installed) the ASP.NET MVC 2 bits.

You can download the demo here. This is a “slimmed” down version, so it should be easier to configure and set up. I’ve heard that there are a few kinks in setting up its heavier sibling version.

In order for Michele’s active STS to work you have to import a number of certificates into your LocalComputer cert store. Her Certificates Setup document was pretty good in explaining how to create and install the certificates. However I got lost in her section on Certificates Security. The section talks about private keys installed into the LocalMachine cert store must be accessible at runtime by the host running the RP or STS. Since these are web apps, the ASP.NET account must have access. It then talks about running the Certificate Key File Tool (certkeyfiletool.exe) which is located in the \bin directory of the Windows SDK. After searching high and low, I found a webpage on MSDN that says that this tool no longer exists. To replace it somewhat is a sample app called FindPrivateKey.exe. This sample app has to be extracted from the WCF samples archive in C:\Program Files\Microsoft SDKs\Windows\version\Samples. I trust you do not want to extract all the sample apps in this archive. Since the files in the archive are already sorted by its respective path, look for TechnologySamples\Setup\CS\FindPrivateKey.

Build the FindPrivateKey project in Visual Studio 2008. In order to find the private key, you need to get the thumbprint of your certificate. Assuming you have a certificate called “localhost” and it is already imported into your LocalComputer’s Personal cert store. Run mmc, add the Certificates snap-in, choose Local Computer Account, and under Personal, open the localhost certificate.

Copy the thumbprint.

Run the Windows SDK CMD Command Shell as Administrator, and type this at the command prompt:

FindPrivateKey.exe My LocalMachine -t "c1 37 df 00 92 07 40 6b 6f 26 20 10 a8 74 57 bb 35 92 e1 3e" –a

(of course replace the string in quotes with the thumbprint of your certificate).

Running this returns the physical location of your certificate. Copy the entire path from the CMD shell and paste it onto Notepad. You will need to remove the leading spaces on the 2nd line of the path.

Next run the cacls.exe utility from the same CMD shell.

cacls "C:\ProgramData\Microsoft\Crypto\RSA\MachineKeys\51fd35739bae502ad67f4
d4086d32400_3271abe4-895a-4463-82fe-267f8027cb2a" /E /G "Users":R

For starters, I just grant permission to User group on my machine. However the permission should be granted to the user account under which the application code may be running.  For example, if the ASP.NET application always runs under a dedicated user account, you will use that account. You can determine the name of the account by calling WindowsIdentity.GetCurrent().Name to find what account you need to grant access.  You may put this in your web application to find out the account of the IIS default application pool. If all is default, you should see the computer account as IIS APPPOOL\\DefaultAppPool.

Run the following command again:

cacls "C:\ProgramData\Microsoft\Crypto\RSA\MachineKeys\51fd35739bae502ad67f4
d4086d32400_3271abe4-895a-4463-82fe-267f8027cb2a" /E /G "IIS APPPOOL\DefaultAppPool":R

You may also try the steps above if you get this error:

System.Security.Cryptography.CryptographicException: The system cannot find the file specified.

Source Error:

An unhandled exception was generated during the execution of the current web request. Information regarding the origin and location of the exception can be identified using the exception stack trace below.

Catch me live tomorrow at 10:30 am (UTC+08:00) Kuala Lumpur, Singapore.

Just released - the first preview of the Visual Studio 2010 and .NET Framework 4.0 Training Kit!

This training kit preview includes presentations, hands-on labs, and demos for Visual Studio 2010 and .NET Framework 4.0. The content is designed to help developers learn how to utilize the Visual Studio 2010 features and a variety of framework technologies including: C# 4.0, Visual Basic 10, F#, Parallel Computing Platform, ASP.NET AJAX 4.0, and ASP.NET MVC Dynamic Data.

Download the training kit - November 2008 Preview today!

Anyway the Arc Accelerator is meant to allow users to select a chunk of text in IE8, and save it as a tag. The saved tag can be populated into a “tag cloud” (again no actual name decided yet) maintained by the Arc Reactor client, which is developed as a WPF application.

In order to save the tag, a “session” of some sort needs to be created. It needs to be persistently stored (at least until after the saved tag had been retrieved by the Arc Reactor client). In order to have something like this, I need to identify the user, and to identify a user, that requires some sort of authentication. I’ve pondered over implementing my own authentication function by means of using the ASP.NET membership provider. However, that’s too inflexible as it means yet another set of credentials to be maintained by the user. I thought about using Windows Live ID, but I had no clue how to develop such an authentication function. The fear of the unknown can be rather counter-productive sometimes. I went to check out how to create identity-aware applications, downloaded the WebAuth sample which was made available in the Windows Live ID Web SDK (C# code available, woo hoo!), and it was such a simple thing to do.

Before I could use Windows Live ID authentication, I need to create a new project on the Azure Services Developer Portal. To gain access to this, you just have add the Azure Services Invitation in your Connections Dashboard. Yes it is an invitation-only program, hence you might have to wait a bit before access is granted to you. While you’re at it, also add other Connection programs such as Live Framework CTP Developer Connection, Live Mesh Beta, SQL Server Data Services, and Windows Live Dev Connect. Here’s a sneak peak of all the Connection programs I have under my dashboard:

On the Azure Serviced Developer Portal, click to create a new project. The service component to choose is “Live Services: Existing APIs” as shown below. As you could see, I don’t have access to the other bits, which is a bummer. But anyway, let’s take one step at a time. In due time, I will be able to develop and provision my Azure and Mesh application. I can’t wait.

Enter your project details in the following web page:

The 2 most important fields are Domain and Return URL. Return URL is especially important because this is the URL of your web page handler that will process all the goodies that are returned after Windows Live had authenticated your user. The one and only goodie that I’m keen to get is the user ID so that I can associate the saved tag to an Windows Live ID. After creating your project, you will get 2 very important fields which are the AppID and the SecretKey. You will use these properties in your Windows Live ID login control at a later stage.

Pretty soon I’ll either post my web application here on my blog, or include it in the Arc Reactor project on Codeplex. Stay tuned. In my following posts, I will expound on other things which I have developed such as:

• REST and POX service: To return all the saved tags by Windows Live ID
• WCF service that is based on the List-based Publish-Subscribe pattern
• Using LINQ to SQL class to write the SavedTag into DB
• Clients to test the REST service, WCF service, and ultimately the Arc Reactor client implementation.

The other thing I demo’ed at my session was how to set up an interactive TFS Build agent. There’s a good reason why you would want to run an interactive TFS Build Agent. This is the scenario. You have associated a test list that includes a UI functional test case to your build definition, you want TFS Build to bring out the application window so that your tester could perform UI functional testing, and then decide whether the test passed or failed. 

It’s pretty simple. Go to the following folder (the installation folder of Visual Studio 2008).

C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies

Edit tfsbuildservice.exe.config file. Locate the following element:

<add key="InteractivePort" value="9192" />

Open a Visual Studio 2008 Command Prompt and make sure you run it as administrator if you are using Windows Vista or Windows Server 2008.

Reserve the port using the wcfhttpconfig utility. The commands you could use below:

C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies>wcfhttpconfig
wcfhttpconfig.exe <command> <options>
Commands:
  reserve <user> <port>          Used to reserve a port for a particular user
  free <port>                    Used to remove a port reservation

Examples:
  wcfhttpconfig.exe reserve DOMAIN\User 9191
  wcfhttpconfig.exe free 9191

C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies>wcfhttpconfig reserve tfsrtm08\darren 9192

Then run the TFSBuildService like below. Essentially you are running another instance of TFSBuildService that listens at the port 9192.

C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\PrivateAssemblies>TFSBuildService.exe
Press the Escape key (Esc) to exit...

When you queue your build, just select the interactive build agent. The properties of an interactive build agent:

TFS Build is essentially built on top of the foundation provided by MSBuild. Having said that, you could customize TFS Build just like how you would customize your MSBuild script. To find out what are the customizable Team Foundation Build targets, there is a good article on MSDN that explains it well. I’m not exactly adept at creating my own custom tasks, so to my delight I found the MSBuild Extension pack which you could download from Codeplex.

After installing the MSBuild Extension pack, the next thing to do is to edit the TFSBuild.proj file which can be found under the default source control folder named TeamBuildTypes. You may have a number of Team Build types already defined. Each Team Build type corresponds to a build definition. Take note that this is the file that you had set along with its version control folder in the Build definition wizard as shown in the following screen clipping:

In the following task, I am editing the TFSBuild.proj that corresponds to my build definition called “ALM111908Build”.

Check out to edit the TFSBuild.proj file. Open up the file in the Visual Studio editor. I’ll be customizing the Team Foundation Build target, BeforeDropBuild, with a task I am borrowing from the MSBuild extension pack called MSBuild.ExtensionPack.Communication.Email. The definition of the BeforeDropBuild target is:

BeforeDropBuild
Called before saving the built binaries, build log files, and test results to the build-drop directory on the release server. Insert your task into this target to run custom tasks before the built files are saved to the drop-directory.

This task I’m borrowing may be similar to the “A build completes” in the Project Alerts in TFS as illustrated in the following screen clipping.

However I have more control over how the notification email is composed such as including attachments, recipients, subject and body of the email. And I could also decide when to send an email notification at any stage along the TFS Build process, not just when a build completes.

At the end of the TFSBuild.proj file, right before the </Project> closing element, I add the following:

<UsingTask AssemblyFile="$(MSBuildExtensionsPath)\\ExtensionPack\\MSBuild.ExtensionPack.dll" TaskName="MSBuild.ExtensionPack.Communication.Email"/>

<Target Name="BeforeDropBuild">
  <ItemGroup>
    <!-- Specify some attachments -->
    <Attachment Include="C:\demo.txt"/>
    <!-- Specify some recipients -->
    <Recipient Include="darren@tfs.local"/>
  </ItemGroup>
  <MSBuild.ExtensionPack.Communication.Email TaskAction="Send" Subject="Email After Build 5pm" SmtpServer="tfsrtm08" MailFrom="tfsbuild@tfs.local" MailTo="@(Recipient)" Body="This email is sent after ALM Build" Attachments="@(Attachment)"/>
</Target>

Be sure to check in the TFSBuild.proj into the source control. Otherwise, your current build definition will not be able to invoke the overriden TFS Build target. If you have set up continuous integration, which in other words each check-in will trigger a TFS Build, you will realize that checking in TFSBuild.proj will not trigger any build. This is an expected behavior because only files within your solution will trigger a build. So if you want to see that the customized email task for the BeforeDropBuild target is successfully performed, you can just queue a new build in the Team Explorer Build menu. You can then check out the BuildLog.txt file, and search for BeforeDropBuild. The first thing you see if the following:

Overriding target "BeforeDropBuild" in project "C:\Program Files\MSBuild\Microsoft\VisualStudio\TeamBuild\Microsoft.TeamFoundation.Build.targets" with target "BeforeDropBuild" from project "C:\Documents and Settings\TFSBUILD\Local Settings\Temp\Demo\ALM111808Build\BuildType\TFSBuild.proj".

This means that TFS Build understands that you are overriding the the “BeforeDropBuild” with a custom task. Subsequently when you search for another occurrence of the target, you will see the following:

Target "BeforeDropBuild" in file "C:\Documents and Settings\TFSBUILD\Local Settings\Temp\Demo\ALM111808Build\BuildType\TFSBuild.proj" from project "C:\Documents and Settings\TFSBUILD\Local Settings\Temp\Demo\ALM111808Build\BuildType\TFSBuild.proj":
Using "MSBuild.ExtensionPack.Communication.Email" task from assembly "C:\Program Files\MSBuild\\ExtensionPack\\MSBuild.ExtensionPack.dll".
Task "MSBuild.ExtensionPack.Communication.Email"
  Sending email: Email After Build 5pm
  Adding recipient: darren@tfs.local
  Adding attachment: C:\demo.txt
Done executing task "MSBuild.ExtensionPack.Communication.Email".
Done building target "BeforeDropBuild" in project "TFSBuild.proj".

The final check before you shout VOILA is when you see this email in your inbox:

Just remember that there are plenty of other tasks you could borrow from the MSBuild Extension Pack. For instance I can compress the assemblies after the build, deploy my web app to IIS 7, create an event log in Windows, and basically anything you have in mind that you want to associate to your TFS Build.

Q. I have already profiled my solution on Innovate On portal but I didn’t print out any web pages during the solution profiling process. How do I go back to my solution profile details?

A. Login to www.innovateon.com using your Windows Live ID. You will see the following Innovate On homepage. You solutions are listed in the “My Solutions” section somewhere in the upper right-hand corner. Please note that you may have multiple solutions profiled.

Click on the solution link. This brings you to the solution profile web pages. Example of the first page is illustrated below.

This is perhaps the best-kept secret on the Microsoft Partner Program. Check out this tool here.

I’ve often mentioned this to my ISV partners that whether they move into a software-plus-services world, or while they are debating whether to offer an on-premise solution or hosted solution, it all boils down to their own business model. While Microsoft is more ready than ever with the recent announcements about the Azure Services Platform at PDC, the parallel thought process should be about whether they are prepared for this new business model. I found this very good whitepaper that talks about how Microsoft delivers measurable business opportunities for partners in software-plus-services today.