Manuel Meyer – 12qw.ch

Today we tried to deploy from Visual Studio to our local BizTalk Server Instance using the Deployment Framework for BizTalk. At the binding import stage the process failed and reported the following error message:

**********************************************************************

Information: Importing bindings “D:\Projects\MyProject\MyProject\MySolution.MyFolder.MyProject\PortBindings.xml” into application “MyApplication.App1″ in BizTalk configuration database (server=”hostname”, database=”BizTalkMgmtDb”)…

Error: Failed to update binding information.

Cannot update send port “SqlSendPort_DataBase1″.

Cannot update transport information (address “mssql://host/instance/database?”).

The following items could not be matched up to hosts due to name and/or trust level mismatches: Item: ‘WCF-Custom’ Host: ‘MyProject_SendHost” Trust level: ‘Untrusted’

You must do one of the following:

1) Create hosts with these names and trust levels and try again

2) Re-export the MSI without the binding files and have a post import script apply a suitable binding file.

********************************************************************

It took us quite some time to find the problem. Googling through the web we found lots of blog posts and forum entries all of which said something like:

The binding can not be imported since it wants to map items (e.g. Ports) to host instances it cannot find. This can be due to a mismatch in the name or the trust setting in the binding xml file and the hosts in biztalk.

 In our case however, the error message did not help us at all. Besides the name and the trust settings you need to register the adapters for the hosts. You can do this in the management console at “Platform Settings” –> “Adapters”. (Sidenote: In our setup, the adapter window in the BizTalk Management Console did not refresh and show the newly created adapters until we restarted the BizTalk Administration.) 

Open source Tools will help you boost your development productivity in a BizTalk Project. These are the tools you need!

All of the Tools except for DebugView can be downloaded from CodePlex (http://www.codeplex.com).

Deployment Framework for BizTalk

The Deployment Framework for BizTalk provides you with a best practice approach on how to structure your BizTalk Visual Studio solution and manage your deployment.
Once set up correctly, the Deployment Framework will allow you to deploy or create deployment packages (MSI Installer Files) by the click of a button. This helps you to reduce post-deployment configuration tasks to a minimum and allows non-BizTalk people, such as server administrators to install a BizTalk solution easily.

IMPORTANT: Be aware that using the Deployment Framework for BizTalk should be decided BEFORE you set up your solution in Visual Studio. The reason is that you need to set up the solution as described in the deployment framework documentation.

BizTalk Best Practice Analyzer

The Best Practice Analyzer is a handy tool that analyzes your entire BizTalk Installation and configuration. It provides you with a report where to turn the knobs and push the buttons to optimize your environment.

BizTalk Orchestration Profiler

If you have Orchestrations that need too much time and you can not figure out why or where, the Orchestration Profiler is the tool of your choice. It will help you analyze an orchestration and show you all the steps involved and their execution time. This will help you find the bottlenecks and show you where to start further investigations. The Orchestration Profiler pulls data from the BizTalk Management Database and Tracking Database and creates a nice graphical report with the following components:

An overview about the instances of your orchestrations and their execution times plus a pie chart about the coverage factor.

A graphical representation of your orchestration shapes including a success rate indicator.

A detailed report showing details for every shape in your orchestration. Here you will find out where you spend those lost seconds.

DebugView

DebugView is a simple windows forms application that will show all the output that is written to the Debug Console using System.Diagnostics.Debug.Writeline() on the local computer. This allows you to write trace statements in your orchestration and watch them appear in the DebugView Window. Note that this will work even on an production environment without Visual Studio installed or a debugger attached (provided the source is compiled with the “debug” switch).

Windows 7 comes with lots and lots of keyboard shortcuts. Some of them being extraordinarily handy. Here are my favorites:

Open Command Window from Windows Explorer

In Windows Explorer, right click a file or folder while holding down the shift key. This will give you the “Open Command Window Here” command to open a Windows Command Window (“cmd”) pointing to the current location.

Maximize/Minimize/Dock Active Window

Using the Windows Key combined with the arrow keys you can execute the “maximize”, “minimize”, “dock left” and “dock right” commands from the keyboard.

Move Window to Second Screen (For desktop extended to 2 monitors)

[Win] + [Shift] + [Left] / [Win] + [Shift] + [Right]:

Look through all open windows

Using [Win]-[Space] lets you see through the open windows and look at your desktop.

Set Presentation Settings

[Win]-[P] lets you select the presentation settings (Computer, Projector, Extend, Clone)

Start Applications in Taskbar

Press [Win] + [1] to start the application on the first position on the left in the taskbar. The number corresponds to the position on the taskbar.

And some old ones I like very much:

[Win] + [Shift] + [N]: Create a new folder

[Win] + [E]: Open Windows Explorer

[Win] + [M]: Minimize all windows

[Win] + [R]: Open “run”

Creating BizTalk message schemas manually is usually a rather tiring task. A lot of typing and mouse-action is required. I really did not like to create BizTalk schemas until, one day, i found out that BizTalk offers very good support in the form of keyboard shortcuts. The problem is that if you are working with the context menu, e.g. right-clicking on a schema node and selecting “insert schema node” –> “child record”, you will NEVER find any information on these keyboard shortcuts. The trick is to open the BizTalk Map Editor and click “BizTalk” from the menu toolbar. It will show you the same commands as in the context menu but you will find the keyboard shortcuts for each command.

And, this trick works with all the BizTalk editors, not only the schema editor.

Visual Studio has another well hidden feature, the Mini Command Window. You can use the “Find” TextBox on the toolbar to start commands.

Just set the cursor to the “Find” TextBox and enter a command. All the commands start with ‘>’. Here is a list of available commands:

• >alias (show commands)
• >g (start debug)
• >q (stop debug)
• >r (debug list registers)
• >t (debug step into)
• >u (debug list disassembly)
• >of (open file)
• >nf (new file)
• >op (open project)
• >np (new project)
• >closeall
• >d (list memory)
• >kb (stacktrace)
• >lcase (make lowercase)
• >ucase
• >| (Debug ListProcesses)

My all time favorite is “open file”. I use this one a lot. If you need to open a file you can use the ‘>of’ command to avoid browsing through the solution explorer. Just do this:

1. Press: Ctrl – §  (moves cursor to find window)
2. Enter: ‘>of FileName.cs’

Visual Studio will us autocomplete and after a few letters you can press enter to select the file needed. Nice!

Visual Studio is shipped with hundreds of keyboard shortcuts. Here are my favorites:

General:

• Go to Definition: F12
• Find all References: Shift + F12
• Go to last edited position in code: Ctrl – -  (Ctrl – Dash)
• Delete Line: Ctrl – L
• Cut Line: Shift – Del
• Copy Line: Ctrl – C (no need to select the text before)
• Comment/Uncomment: Ctrl – K – C / Ctrl – K – U
• Insert Snippet: Ctrl – K – X
• Surround with Snippet: Ctrl – K – S (mark selection to be surrounded first)
• Full Screen: Shift – Alt – Enter

Debugging:

• Show Immediate Window: Ctrl – Alt – I
• Run to Cursor: Ctrl – F10
• Toggle Halt on Exceptions: Ctrl – D – E

Working with Visual Studio 2008, I always end up with a total mess of code editor windows (tabs). These two tricks helped me a lot to keep things under control:

1. Track Active Item in Solution Explorer

By enabling this setting, once you open the solution explorer, it will always be scrolled to a position where it shows and highlights the item you are working on in the code editor. You will especially benefit if you have a large solution with lots of projects. You can find it here:

Tools –> Options –> Projects and Solutions –> General –> Track Active Item in Solution Explorer

I read that it could impact the performance of visual studio if you are running it on a slow machine, but for me, its totally worth it.

2. Most Recently Used Tab Order (MRU)

I hate to find a code window by looking at the 15 tabs that are open in my IDE. Most of the time the tabs are not visible anymore and I have to click the active files button to find it. However, these times are over. By adding the registry key below, Visual Studio will sort the open tabs by most-recently-used. Meaning, the item that you are working on will always be on the first position on the left side. Just add a DWORD named:

UseMRUDocOrdering = 1

to:

HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0

(9.0 for Visual Studio 2008)

I like this one very much. Its super easy but it makes working much more comfortable. Credits go out to Sara Ford and her blog post. Check out her blog for tons of VS tips!

I’m am currently working on a project to evaluate the new Microsoft server product Dublin, often referred to as the new “Microsoft Application Server”. Here is a little introduction and a handful of useful resources.

1. What is Dublin?

Dublin is a piece of Software which will be integrated into Microsoft Internet Information Services (IIS). Dublin supports deployment, configuration, management and scalability of applications developed with Windows Communication Foundation (WCF) and Windows Workflow Foundation (WF). The official Microsoft whitepaper about Dublin gives a good overview about their intentions. Go to the official Dublin website (http://www.microsoft.com/net/dublin.aspx) and take a glance at the Dublin Overview Whitepaper.

2. Why do we need Dublin?

Microsoft claims that lots of today’s applications run in a highly distributed environment. In the age of Service Orientation (SOA) these applications can be referred to as “Composite Applications”.

Therefore, the above mentioned task of deployment, configuration, management and scalability become very complex, taking into account that most of these applications run on several computer in geographically distributed locations.

Dublin’s goal is to facilitate these tasks and support handling of Distributed Workflows and Services.

3. Dublin Features

Dublin will simplify working with WF Workflow and WCF Services in the following areas:

• Deployment: Dublin will allow you to directly package and deploy your software from VS2010.
• Hosting
• Service Visibility and Configuration: Dublin provides a graphical UI for WCF Service Configuration
• Monitoring: Dublin provides access to all the monitoring features of WF/WCF including improvements coming in .NET 4.0
• Workflow Instance Management: A major feature of Dublin and WF 4.0 are improvements in the hosting of long-running workflows. Long-running referring to weeks or months. This includes persisting of such workflows.

4. Look and Feel

Check out Microsoft’s Chris Chraft’s blog post to see some screenshots: http://blogs.technet.com/chriscraft/archive/2008/11/09/a-quick-look-at-the-iis-manager-tooling-experience.aspx

5. How does it work under the hood?

As mentioned before, Dublin is an extension to IIS and will therefore be accessed using the IIS Manager. Dublin is planned to be included in the Microsoft Server product family. Regarding the hosting capabilities, Dublin uses Windows Activation Service (WAS). The development team aims at making Dublin/WAS hosting for WCF Services the number one choice as opposed to self-hosting, Windows NT Service hosting or IIS hosting (for HTTP Services).

6. When will Dublin be released?

Dublin relies on WCF 4.0 and WF 4.0. So far, Dublin has been released as an early CTP at the PDC in 2008. Future releases will follow the releases of .NET 4.0 by a couple of months. The next CTP is scheduled for August/September this year, Beta1 for 2010 Q1, RTM for 2010 Q10 (http://social.msdn.microsoft.com/Forums/en-US/dublin/thread/deffd565-8530-48a7-b043-cc1aee77de9e).

7.  Dublin and BizTalk

Certain functionality in Dublin (Hosting of Workflows) can be found as well in the Microsoft BizTalk products. It is important to note that Dublin will NOT replace BizTalk. Microsoft predicts scenarios where Dublin and BizTalk will work hand-in-hand. Dublin will act as application server and BizTalk will take care of the integration and communication issues.

8. Dublin and Oslo and Geneva

Microsoft Codename Oslo, Microsoft’s general purpose modeling platform will be able to target multiple environments. Dublin will be one of them. Meaning that Oslo will support modeling of applications that will be deployed to the Dublin application server (As opposed to applications that will be deployed to Windows Azure, for example).

Microsoft Codename Geneva, Microsoft’s new Identity and Access Management Platform will provide security features to WCF-Services. Therefore, I expect Geneva to support Dublin, as well. However, up to today I could not find very much information about how Dublin and Geneva will work together.

9. Resources:

Did you ever sit in the office and feel sorry for your buddies?

Let them hear your feelings with http://www.sadtrombone.com/

Another website the world was waiting for!!! 

This post continues my overview post about LiveMesh and the Windows Live Framework (http://www.12qw.ch/?p=13).

It explains how and why the Live Framework is interesting for software developers and what you need if you want to start programming Live Services.

Requirements

1. Get a Windows LiveID (If you do not have one already)

2. Visit http://dev.live.com/liveframework/

3. Download and install the Live Framework SDK

4. Download and install the Live Framework Tools for Visual Studio

5. Go to the Azure Developer Portal (https://lx.azure.microsoft.com) and create a new application (select Live Services CTP and Mesh-enabled Web application)

6. Start Visual Studio

If you create a new application of type Mesh-enabled Web Application (MEWA) in Visual Studio, a wizard will guide you through the steps required to establish a trust relationship between your Visual Studio and your cloud project created on the Azure Developer Portal.

Application Types

There are 3 different types of applications that can be developed using the Live Framework:

1. Live Framework-enabled Web Sites

2. Live Framework-enabled Rich Clients  

3. Mesh-Enabled Web Applications (MEWA)

 Type 1 & 2 are very straightforward. You can enhance an existing Web or Rich Client Application by connecting to the users Mesh. There, you can access different MeshObjects, such as applications, contacts, news, etc.

The really big deal comes in the form of Mesh-enabled Web Applications (MEWA). MEWA are applications that run in the Cloud. But, as soon as you create an application instance, it will be automatically synchronized to all the devices in your Live Mesh. The application is automatically installed on your synchronized local devices.

MEWAs are the ultimate combination of the best features found in web-applications and rich-clients. The very same application instance is available online and offline and user data is synchronized between all running instances.

The Live Operating Environment (LOE)

The Live Operating Environment is the endpoint used by the application to communicate with the cloud. The key is that the LOE will be replicated onto every local device added to the users LiveMesh. This is THE essential feature which makes programming Live Services so interesting.

A MEWA running locally on a client device will always talk to the local instance of the LOE. The Framework will transparently synchronize a subset of the data from the cloud LOE in the background.

A MEWA running in the web, for example on the users Live Desktop, will connect directly to the cloud LOE.

Picture 3: Different runtime scenarios for a MEWA

On picture 3 you can see different runtime scenarios for a Mesh-enabled Web Application (MEWA). Red colors depict developer code whereas blue colors depict framework code.

It is important to mention that the three applications in the picture are not only the same application but the very same application instance. The Framework will take care of all the synchronization and caching issues.

The Live Framework Resource Model

The Live Framework provides a resource model that is based on entities, collections of entities and their relationships. The framework model is REST based, meaning every resource can be addressed by a unique URI. Relations between resources are represented through hyperlinks.

Picture 4: The Live Framework Resource Model

The most important entity in the resource model is the Mesh Object. The mesh object is basically a container for data. It has several properties that define its behavior in regard to sharing, synchronization and data.

Picture 5: Components of a Mesh Object

Each Mesh Object has the following properties:

· A collection of mappings to devices: As soon as a certain device is added to this collection, the Framework will synchronize the MeshObject to that device.

· A collection for mappings to users: As soon as a Windows Live user is added to the collection, the MeshObject will be shared with that user.

· A collection of news: Every change in the MeshObject’s data is reflected in a news notification.

· A collection of datafeeds: DataFeeds are the generic abstraction of a collection of DataItems. This is where an application can store its data.

Note that an application instance is a MeshObject as well. Thus, the same rules for synchronization, sharing or notification will apply.

…

Resources:

Live Mesh Beta:

www.mesh.com

Live Framework CTP:

http://dev.live.com/liveframework/

Windows Azure Developer Portal:

https://lx.azure.microsoft.com

The Live Framework MSDN Forums:

http://social.msdn.microsoft.com/Forums/en-US/liveframework/threads/

This post gives an overview about Live Mesh, Live Services and the Live Framework.

Cloud computing is on the rise. The benefits of cloud computing programming paradigms are becoming clearer every day. But, as many problems are solved, new problems arrive.

The biggest issue in regard to cloud computing is connectivity. What can you do if you can not access the cloud. The Windows Azure Live Framework has answers…

LiveMesh

Live Mesh is a service provided by Windows Live. Its goal is to provide a rich user experience by combining all of the users devices, such as personal computer, notebooks, mobile devices, media centers and more to a mesh. Your mesh can be accessed through a website called the “Live Desktop” where you can access all the files, devices and applications in your LiveMesh. All the devices you add to your LiveMesh will be shown in your Ring Of Devices.

Live Mesh tries to mitigate the fact that getting a new device often makes live harder whereas it should make live easier. It tries to unify all

the devices to one big mesh. The user can add a device to the mesh and synchronize data (folders, files) and applications to all the devices in his mesh.

For more information visit: www.mesh.com

LiveServices

The Live Services are one of the service blocks of the Windows Azure Platform. The Live Framework is the means required to program Live Services.

Windows Live Framework

The Live Framework is a Framework for Software developers. It provides a cloud infrastructure that can easily be accessed using familiar tools such as Visual Studio. It allows developers to program the cloud and use all resources and features of Live Mesh. The Live Framework takes care of all the hard programming tasks such as identity management, authentication, synchronization and caching. Its goal is to let the developer take care of the application development and provide an infrastructure that handles the above mentioned tasks in the background. The Live Framework is currently released as a Community Technology Preview (CTP April 09).

If you would like to join the Live Framework CTP, visit: http://dev.live.com/liveframework/

In my next post I will provide a deeper glance at the Live Framework and write about programming the Live Framework.