Brian Loesgen's Blog

San Diego Code Camp is this weekend! I’ll be there on Saturday, doing two presentations:

• A Technical Drilldown into “All Things M” (part of the forthcoming Oslo platform)
• A First Look at BizTalk Server 2009: Integration Server, SOA Foundation, Gateway to Azure

If you’ve never been to a Code Camp before, you should check it out. It’s an “anything goes” community-driven conference-ish event. Lots of high quality sessions, at a recession-friendly cost (free). Lots of learning opportunities. What’s not to like?

As usual, this will be at UCSD La Jolla. See you there!

Full details are at http://www.socalcodecamp.com/

I’m REALLY happy to say the the ESB Toolkit 2.0 has been released. As part of the current launch tour I’m doing, I’m telling people that in my opinion the best part of BizTalk Server 2009 is the ESB Toolkit. If you’re a BizTalk dev, you really want it check it out. And, if you’re one of those unfortunates that had installation issues, it’s OK to come back now and try again. I installed a build a couple of weeks ago, took me about 15 minutes total. The team invested a LOT of effort in this area, and it shows.

By sheer coincidence (OK, so I knew rough timeframe, but not to the day :)), I’m doing an overview presentation of it, and showing some really cool dynamic messaging demos, at a user group meeting in San Diego tonight. Meeting will be at 6:30 (pizza at 6:00) at the Microsoft office in La Jolla.

The official team blog announcement is available here.

You can get the bits here.

I’ll be posting more info about this within the next few days, and, if you’re in San Diego tonight, come on by!!

Folks,

Last week in Salt Lake City, we kicked off a 6-city tour of the US Southwest featuring BizTalk Server 2009 and ESB Toolkit 2.0. This week I’ll be in L.A. and Phoenix. Remaining dates are as listed below. This is a free event, but you need to register. If you’re in one of the listed cities c’mon by, it’s a really interesting event.

Please join us for a “First Look” at BizTalk Server 2009!

Details were announced last week at TechEd (in Ofer Ashkenazi’s session and in mine) about the next version of Microsoft’s ESB Toolkit. Here’s a summary:

Name change

Yes, that’s not a typo, the “ESB Guidance 2.0” is now the “BizTalk ESB Toolkit 2.0”. This is just one of several changes, and was made to better reflect some of the points below. When released, it will be available for download from MSDN (not Codeplex).

Availability

Release-to-Web is expected to happen around mid-June. In the interim, CTP 2 (Jan 2009) is available at Codeplex, as it has been for months now. No CTPs or other releases are planned prior to the release-to-Web.

Cost

The ESB Toolkit is built on top of BizTalk Server 2009, and is free BizTalk licensees.

Community

Discussions will also be migrating from Codeplex to a public discussion forum at MSDN. Microsoft employees will also be monitoring the forums and will be helping answer questions.

Major Enhancements in Version 2.0

· Built on BizTalk Server 2009

· Provides greatly enhanced tooling, on top of an optimized core (includes a killer itinerary design tool)

· Supports UDDI 3.0

· Provides even more extensibility points

· Provides even more prescriptive guidance about enterprise integration patterns

· Streamlined installation experience (Powershell, configuration tool, etc). For those of you who had issues with installation, you’ll be pleased to hear I did an almost complete install last week (without following any docs), in about 15 minutes.

My opinion on this is that it is a natural evolution. The ESB Toolkit adds a LOT of value for customers adopting SOA technologies, implementing bus-based solutions, and using BizTalk as an integration platform. The transition to a more supported model in a natural step as the capabilities of the offering expand, and maturity sets in.

I’ve had the pleasure of working closely with the Patterns and Practices team that are responsible for this effort, and under Dmitri Ossipov’s leadership have really done a great job turning this into a product-quality set of components that a LOT of BizTalk shops will find very compelling and useful.

As soon as I can, I’ll be posting more information and videos here. This journey started a long time ago, and it just keeps on getting better!

Microsoft officially released BizTalk Server 2009 today. Press release is here, and you can see a complete list of new features here.

I was wondering what to write, and a retrospective seemed appropriate.

But first, where are we today? I hear lots of questions out in the field: where will BizTalk fit in a Dublin world?, what about WF?, how does BizTalk mesh with the future technologies? One of the talks I just submitted for the San Diego CodeCamp I think sums up where we are now pretty nicely:

BizTalk Server 2009: Integration Server, SOA Foundation, Gateway to Azure

Microsoft recently released BizTalk Server 2009. In this session we will look at the power that BizTalk provides to connect applications, services and partners. Now in its 6^th release, BizTalk has evolved to play a vital role as the foundational messaging bus in a services-oriented architecture. We will look at the value BizTalk Server 2009 adds in bridging between on-premises and cloud-based application, as well as how it enables SharePoint to provide human interaction in workflows, processes and service orchestrations.

BizTalkers, we have a VERY interesting story to tell. We are the glue that holds things together. BizTalk Server 2009, plus all the adapters, WCF capabilities, ESB capabilities in the ESB Guidance, BAM, the rules engine, SharePoint adapter…. the list of value-adds and the power BizTalk provides goes on and on. BizTalk has evolved with the times, and the industry, adopted standards as they emerged, and added capabilities as they were needed. We started out by being (as Don Box said circa 2002-ish) “ahead of our time”, and, we still are. We were doing loosely-coupled async services long before anyone said that’s what we should be doing. We were contract-first message-oriented – about a decade ago!

Now for the retrospective part:

• Here’s my post about the BizTalk 2004 launch: http://blog.brianloesgen.com/archive/2004/03/08/2671.aspx
• Here’s a retrospective I did about 4 years ago: http://blog.brianloesgen.com/archive/2005/11/30/61669.aspx (I figure I can quote my own retrospective in my retrospective once it’s over 3 years old :))

And, my favorite, is the CD I have:

Yes, it says “1999”, and no, as it turns out there never was a “BizTalk Server 1.0”, that would be BizTalk Server 2000. I actually remember seeing the first press announcement about this new thing called BizTalk, and telling a co-worker  “I’m going to keep an eye on this, it sounds cool”. I started working with bits and interacting with the product team back in the BizTalk Jumpstart Kit days, which pre-dated even this Alpha. I think I’ll wait a few more years, then take that CD and try installing it on Windows 12 or whatever we are running then (assuming whatever I have can still read CDs!).

We’ve come a very long way since then, and the future continues to be bright for BizTalkers….

Note, if you’re in the US Southwest, watch this space for details of a “first look” tour we’re putting together.

[[ 23:00 pacific time Apr 24 2009 – Update… there were some issues with the videos (although they all worked fine on my Win 7 box!). I’m re-encoding some new ones, the SkyDrive folder below will have a few choices. Please let me know of any issues. ]]

As part of my “M” end-to-end presentation in Stockholm last week, I came up with a way to walk through MSchema, MGrammar, MGraph and Intellipad that went over really well with the conference attendees. They “got” what I was talking about, rather than walking out with glazed-over eyes, so…. As I’d put so much work into it and it seemed to resonate well with the audience, I thought I should record it and push it out to the world.

Caveat: although this is based on the now-current Oslo SDK, we are still pretty early on in the dev life cycle, so change is pretty much assured. As such, if you’re watching this in the year 2010, some of the things I say and do may no longer be applicable. However, for those here and now and interested in learning more about the Oslo modeling platform, I think you’ll find it of interest.

I had to do it at a fairly high resolution in order to fit everything I wanted to and still have the “code” legible (if you have a DSL that looks like a human language, is it still called “code”?).

To see the video, click the link below and then pick your favorite flavor. Click it and press the “download” button above it.

Enjoy, and as always, comments and feedback are welcome.

I’m late posting this, but… I will be presenting at TechEd again, this time along with Syed Rasheed of the product team. This presentation will be focused on the almost-released new version 2.0 ESB Guidance from Microsoft’s Patterns and Practices group.

I’m working on some cool new demos for this session, should be fun!

TechEd is always a great conference, and usually sells out. To register, click the image below.

------------------------------------------------------

SOA317 Dynamic Messaging with Microsoft BizTalk Enterprise Service Bus (ESB) Guidance v2

Presenter(s): Brian Loesgen, Syed Rasheed

Brian Loesgen
Brian Loesgen is a principal SOA architect with Microsoft. Based in San Diego. Brian is a six-time Microsoft MVP for BizTalk Server, and has been involved with BizTalk since prior to the BizTalk Server 2000 beta. Brian has extensive experience in building sophisticated enterprise, ESB and SOA solutions. Brian was a key architect/developer of the “Microsoft ESB Guidance”, initially released by Microsoft in Oct 2006. He is a co-author of six books, including “BizTalk Server 2004 Unleashed”, and is currently working on “SOA with .NET”. He has written technical white papers for Intel, Microsoft and others. Brian has spoken at numerous major technical conferences worldwide. Brian is a co-founder and past-President of the International .NET Association (ineta.org), and past-President of the San Diego .NET user group, where he continues to lead the Connected Systems SIG, and is a member of the Editorial Board for the .NET Developer’s Journal. Brian was also a member of the Microsoft Connected Systems Division Virtual Technical Specialist Team pilot, and is part of Microsoft’s Connected Systems Advisory Board. Brian has been blogging since 2003 at http://blog.BrianLoesgen.com.

Syed Rasheed
As the senior product manager for Data Programmability and Service Oriented Architecture solutions at Microsoft Corp., Syed Rasheed coordinates DP & SOA marketing, consulting, evangelism, and product development activities. In addition to helping customers address SOA challenges today, Syed is responsible for working with customers, partners, and industry analysts to ensure the next generation of Microsoft technology meets customer’s requirements for building SOA and Business Process solutions. Syed is 15 years veteran of IT industry with extensive experience in the Business Process Management Systems, Enterprise Integration Middleware and Database and BI technologies areas. His work spanned several industries including financial services, telecommunication and banking.

Level: 300 - Advanced

Session Type: Breakout Session

Track: SOA and Business Processes

As organizations look to Service Oriented Architectures to help them deliver flexible, agile and responsive IT environments, the Enterprise Service Bus has emerged as a key architectural pattern to help achieve this goal. In this session, we discuss the Microsoft Enterprise Service Bus Guidance (and specifically the new version 2.0) and how it allows an organization to build a dynamic, flexible, and practical ESB as part of the larger Service-Oriented Infrastructure.

If you’re working with WCF services hosted in Azure (I blogged about my first experience putting a service up there here), some new samples have just been published at http://code.msdn.microsoft.com/wcfazure.

Enjoy!

I ran into an issue working with the AWESOME MUrl sample trying to reach Twitter from inside Intellipad (running in “MUrl mode”). I’m doing this post for the benefit of others that may run also into this, there are actually two solutions…

If you haven’t seen MUrl in action, please see my previous post about it and do check it out. Bottom line is that the sample is a DSL (written in “M” of course) for doing REST client requests, and “MUrl mode” lets you do those requests right from inside Intellipad. Super cool…

Where I ran into an issue was that although I was able to query Twitter no problem with MUrl from Intellipad, when I tried posting I would get an “Expectation Failed” error message. I was somewhat amused that somehow it seemed that I was not living up to some service’s expectations :) … but mostly I was annoyed that I could not do this. After a bit of looking around, I found this post that explained what was going on.

I made the code change to the MUrlRuntime.cs file as shown below:

Alternatively, you could make the equivalent change by adding this to the ipad.exe.config:

<system.net>

   <settings>

     <servicePointManager expect100Continue="false" />

   </settings>

</system.net>

(for the benefit of Oslo people using search engines, other text in the error message was “Expect: 100-continue”, and some text from Twitter saying “we only allow the 100-continue expectation”)

The new SQL Adapter in the WCF Adapter Pack 2.0 supports composite operations, that is performing multiple SQL operations in response to a single input message. The purpose of this blog post is to provide a walkthrough of how this works. I am using the public beta of BizTalk Server 2009, the public beta of the WCF Adapter Pack 2.0 and released version of SQL Server 2008. See below for an important caveat, as well as a link at the end of the post to my test solution.

To start, as with most things in BizTalk’s contract-first world, we need a schema. In order to do this, choose “add generated items” from a BizTalk project in Visual Studio. Then, choose “Consume Adapter Service”. If you don’t see that Visual Studio template, then you haven’t installed the Adapter Pack, as that’s where it comes from.

Next, select the sqlBinding specify a server, and press “Configure”. Set the client credential type to Windows (assume appropriate SQL login rights), and then on the URI tab, specified the server and database to use:

Af6ter doing this, press “Connect”, and the metadata will be populated.

For the purpose of this walkthrough, I have created 2 stored procedures: the first one inserts a record into a table, the second returns all rows in that table. Those are shown in the UI below.

Note that in the category we have “Procedures” and “Strongly-Typed Procedures”. The distinction is that “Procedures” will create un-typed schemas, whereas “Strongly-Typed Procedures” will generate schemas that you can work with inside BizTalk for mapping, promoting properties, etc.

The “Filename Prefix” will be used as a prefix for all the generated schemas.

After that was configured, I clicked OK and all the schemas were generated for me.

Next step is that you need to create a composite schema that will define the message you send to the adapter. I’m not quite sure why this one wasn’t generated for me, it’d be nice (hint hint), but it’s trivial to do.

How I did this for the walkthrough:

• create a new schema
• rename the root to SQLMsg (or whatever you like, this is unimportant)
• add a sibling record called SQLMsgResponse (this name does matter, it is the name of the request, with “Response” appended)
• add two child records under SQLMsg, and another two under SQLMsgResponse (names don’t matter, they’ll get renamed below)
• right-click the topmost “<schema>” node, and in the “Imports” property, add the “CompositeTypedProcedure.dbo.xsd” schema
• in the first child under SQLMsg, set the “Data Structure Type” property to InsertIntoDestination (this is a reference that you just imported above)
• in the second child under SQLMsg, set the “Data Structure Type” property to SelectAllDestination
• in the first child under SQLMsgResponse, set the “Data Structure Type” property to InsertIntoDestination (this is a reference that you just imported above)
• in the second child under SQLMsgResponse, set the “Data Structure Type” property to SelectAllDestinationResponse

Your schema should now look like this:

The, create an instance of the new composite schema to use as a test message, and populate the request. Here’s mine:

I then created a simple orchestration that would receive a request, call the adapter, and persist the response from the adapter. The request and response messages are of the type we just created in the composite schema:

Build and deploy the solution. After deploying it, note that there was a binding file generated along with the schemas, which is awesome, as this means you don’t need to manually create the send port. So, import the binding file which exists in you Visual Studio project.

HOWEVER… pretty big caveat here…. after importing the binding, you need to change the action mapping. If you use the default value, it will fail. You need to replace what is generated with the magic keyword “CompositeOperation”. This tells the adapter that it needs to call multiple operations, which it will resolve based on the schemas and namespaces. I believe the reason this works the way it does is that it allows you to import multiple operations in a single pass, and then use some subset of those operations in a composite operation, thereby enabling re-use of the generated schemas to potentially cover multiple different combinations of composite operations. Either way, watch out for this one. The error message tells you exactly what the problem is, however it won’t tell you about the keyword.

As an aside, and for the benefit of those who have not worked with this adapter yet, here are the binding configuration properties you have access to:

Then:

• create an inbound file drop location
• create an outbound file drop folder
• bind everything
• start the application
• drop your instance doc into the file drop location, triggering the orchestration

Lastly, here’s the output file:

In closing, I think this is an awesome new capability, and I am really liking the new SQL adapter. In case you haven’t heard, the old SQL adapter is being deprecated, so you really should be working with this one going forward.

You can download my test solution here.

In recent days there’s been some interesting movement in Oslo-land:

• Doug Purdy and Chris Sells did a presentation at Mix09 that showed a domain-specific language for invoking RESTful services, and how to use M to create RESTful services
• BizTalk MVP Yossi Dahan has published (Part 1, Part 2, Part 3) details about his domain-specific approach to BizTalk deployments
• Kris Horrocks has started blogging, and posted his domain-specific approach to interacting with X10 home automation

What these three things have in common is that this is the start of practical examples of how you can author a DSL using M, and how the DSL could be used to simplify the effort required to do things (ie: reduce the amount of code you need to write). Up until now it’s been interesting to watch, but there hasn’t been much in the way of practical examples. The fact that these are starting to emerge speaks to the increasing maturity of the project.

The path to learning this stuff starts with M, then you move on to creating DSLs using MGrammar, and then the final phase is creating a runtime that is actually doing something with the data produced by your DSL. This is where Doug and Chris’s presentation (I highly recommend you click the link above and watch it) really resonates well. The “Murl” effort they’ve been working on (available here) makes it really easy to create a REST client. 

The sample also shows how extensible Intellipad is, by adding a new “mode” that enables actually USING the DSL (parsing *and* executing) from inside Intellipad and calling RESTful services. Very cool! The code you see below is the syntax of the DSL used to call REST services.

But, in my opinion, the most exciting part of their presentation was the MService part, which is a (work-in-progress, not released) way to create a RESTful service, using a DSL written in M. The screen shot below shows the service definition in the left-hand pane, and the generated SQL in the right-hand pane (red arrows indicates some of the relationships between the two).

They saved the file out to  c:\inetpub\wwwroot, and made a REST request (from Intellipad, using Murl-mode, just because they could :)). There’s a handler that IIS routes the request for a “*.m” resource request to. It’s an entirely self-bootstrapped operation, if the service sees no storage it will create the storage.

M is all about writing down data, and the ultimate output is structured data in the form of MGraph. Where this becomes tangible and payoff is realized is when we use a runtime to do interesting things with that data, and MService is the best example of this that I’ve seen thus-far. It’s a tantalizing view of how developers will create applications in the future.

[UPDATED: I just found out there’s a “language gallery” with links to sample languages people are creating. See http://msdn.microsoft.com/en-us/oslo/cc749619.aspx]

[Even though it may have been more appropriate to speak on Oslo in Oslo? :)]

Next month I will be speaking at the Cornerstone Developer Summit in Stockholm, Sweden. I will be doing 2 sessions, one on M, the other on the new wave of Microsoft SOA offerings (Oslo, BizTalk, Dublin, Azure, .NET 4, et al) and how things fit together from an architectural perspective.

I’m looking forward to this event, I hear it’s a top-notch event and always a lot of fun, and I’m looking forward to catching up with a couple of my old friends Julie Lerman and Scott Bellware. I’m also trying to get to the local BizTalk user group where MVP Alan Smith and I will present a BizTalk Best Practices session.

To find out more, or to sign up for the conference, visit:

http://www.cornerstone.se/sv/ExpertZone/developersummit/2009/Startsida/Arkitektur/

Zoiner and I are both travelling this week, but rather than cancel our meetings, we have rejiggered them (I’ve always wanted to use that word in a sentence).

So, San Diego .NET User Group Connected Systems and Architecture SIGs are doing a joint meeting tomorrow (Monday March 9 2009), and I will be doing my Microsoft SOA Offerings presentation.

I plan to show a demo I’ve been working on. It involves BizTalk Server 2009, ESB Guidance 2.0, Dublin, Windows Workflow Foundation and Windows Communication Foundation (from .NET 4.0), and Azure, all in a couple of VMs running simultaneously (off my notebook) with two networks, using 64-bit Virtual PC hosted on 64-bit Windows 7.  With the exception of Virtual PC, *everything* in that chain is beta -- or earlier. Now that should certainly appeal to the inner-geek in all of you!

Meeting starts at 6:00 for pizza, 6:30 for the meeting itself, at the Microsoft La Jolla office.

I’ll be speaking at the ASP.NET SIG of the San Diego .NET User Group tonight. Abstract is below. Meeting starts at 6:00 at the Microsoft La Jolla office.

This is basically the same presentation Allan Naim and I did recently at the SOA BP conference in Redmond and at an internal Microsoft conference.

If the demo gods are willing (as I expect them to be), I’m planning to do my shinny new demo that ties together work I’ve been doing around Dublin, Azure, WF, WCF, BizTalk 2009 and ESB Guidance 2.0.

Session Abstract:

With so many technologies to choose from, Solution Architects often find themselves unsure of what the right technologies are to address their solution needs. With the recent announcement of Microsoft's new "Dublin" application server capabilities, architects and developers have more choices than ever and the challenge is selecting and integrating the right technologies in order to ensure that IT is agile, and that business needs are met. The goal of this session is to provide you with a holistic view of Microsoft SOA technologies focusing on building the right architecture to address specific SOA capabilities around integration, messaging, security and management using technologies such as BizTalk Server 2009, ESB Guidance v2, Managed Services Engine, .NET 4.0 and Dublin. We will look at the value each piece adds to the overall picture, and how they can be integrated in a holistic solution.

I did a post a couple of months back where I showed you how to take a WCF service and host it on the Azure service platform. I thought that was pretty cool, but wanted to take it to the next level. So, why not call that from a .NET 4.0 workflow, and host that workflow in “Dublin” (the set of WCF/WF hosting capabilities being added to the Windows Server application server)?

I heard it was Ron Jacobs that said that with .NET 3.0, WF and WCF “had just met”, in .NET 3.5 they “were dating”, and in .NET 4.0, “they’re married”. It’s a great way to think of it. The integration between WF and WCF now is really tight, and makes it really easy to create, host and expose a WF service using WCF.

I did this using the Community Technology Preview of the .NET 4.0 framework, using the virtual machine that was made available to PDC2008 attendees. Note that as with almost any CTP, it’s a pretty sure thing that there will be changes to the framework between that point in time and the ultimate release, so some of these screenshots, shapes and even steps may become obsolete. As always when working with pre-release software: expect change! I’m not going to say it was quick, but this post could save anyone trying to do the same a lot of time.

First step was to create a new project using the Windows Application Server template in Visual Studio 2010 PDC CTP (this will not be required in the release, it will just be workflow project).

I added a ServiceOperation step, which is how I will expose the service to the outside world. The collapse sequence inside the “after receiving message” is where we will consume the service.

With the PDC08 CTP VM, you need to define the operation contracts for both consumed and exposed service.

This first operation contract is the contract we will expose to the outside world. As you can see, we accept two string parameters on the way in, and return a string value.

The inside the collapsed sequence here’s where we call the service:

OK, so far this is pretty cool, but what could make it cooler? Take a look at the URI… That’s a WCF service that I wrote that’s hosted in the cloud, on the Azure Services Platform.

And next is the operation contract definition of the service we are calling (the client operation). Hard lesson learned: you need to be REALLY careful with names you enter in the consumed service operation contract, or you’ll end up with a mismatch with the service WSDL, and invoking it will fail. This can be challenging to troubleshoot. This is after all a CTP, so, there are bound to be some areas that are opportunities for improvement.

For completeness and to close the loop in this post, I invoke my workflow service using the WCF test client application:

I thought it would be nice to echo out information to the debugger as the service was executing, so I created a custom workflow element to do that, which is the “DebugWriteActivity” you see above. I wanted to pass in a string from the host workflow, the technique is shown below.

So there you have it. With virtually no code I created a workflow service (hosted in “Dublin”), which was exposed as a WCF service, and in turn consumed a WCF service that was hosted in Azure.

I’d like to thank Cliff Simpkins (Microsoft) and Zoiner Tejada (Hershey Technologies) for their assistance as I went down this path. I’d also like to thank the people staying on my floor at the Hyatt for not calling security when I first saw this work calling an Azure-based service, my reaction was somewhat errr…. “non-subdued” ;)