Charles Young

  Home  |   Contact  |   Syndication    |   Login
  140 Posts | 54 Stories | 357 Comments | 376 Trackbacks

News

MVP - Microsoft Most Valuable Professional

Twitter












Article Categories

Archives

Post Categories

Image Galleries

Alternative Feeds

BizTalk Bloggers

BizTalk Sites

CEP Bloggers

CMS Bloggers

Fun

Other Bloggers

Rules Bloggers

SharePoint Bloggers

Utilities

WF Bloggers

Wednesday, November 04, 2009 #

Alexandre Alves wrote an interesting article on CEP extensions for Logic Programming (see http://adcalves.wordpress.com/2009/10/30/logic-programming-lp-extensions-for-cep/) in which he mentions the use of Rete-based rules engines.   I gave a presentation at a conference last week (October Rules Fest 2009) on the differences and similarities between various event stream processing (ESP) approaches and the Rete algorithm.  I had a slide that is not very different in intent to Alexandre's post.  I also touched on performance issues, which is something he talks about briefly.   I don't know of any solid, well thought out, comparative benchmarking between any of the major ESP and CEP-enabled Rete engines, so I can only hazard informed guesses with regard to likely performance issues.   I thought it would be useful to summarise some of my thinking in this area.

Read more at http://geekswithblogs.net/cyoung/archive/2009/11/04/136003.aspx


Friday, October 30, 2009 #

My report on day five (the last day) of the October Rules Fest 2009 is at:

http://geekswithblogs.net/cyoung/archive/2009/10/30/135901.aspx


My report on day four of the October Rules Fest 2009 is at:

http://geekswithblogs.net/cyoung/archive/2009/10/30/135855.aspx

 


Wednesday, October 28, 2009 #

My report on day three of the October Rules Fest 2009 is at:

http://geekswithblogs.net/cyoung/archive/2009/10/28/135780.aspx

 


Tuesday, October 27, 2009 #

I’m at day two of the October Rules Conference at the Adolphus Hotel in downtown Dallas.   My report on the day's processings is at:  

http://geekswithblogs.net/cyoung/archive/2009/10/27/135756.aspx

 


Friday, October 09, 2009 #

Microsoft today announced Service Pack 1 for BizTalk Server 2006 R2.   Note that this is for the previous version of BizTalk Server, not the current version (BizTalk Server 2009).   No doubt a service pack for BTS 2009 will follow in due course.

The service pack is currently at beta.   It has only been announced, not released.   You can download the beta if you log onto the Connect site.

See http://blogs.msdn.com/biztalkcrt/archive/2009/10/09/announcing-biztalk-2006-r2-sp1.aspx

There are a couple of new features.  See http://msdn.microsoft.com/en-us/library/ee532481(BTS.20).aspx.

For a list of bug fixes, see http://support.microsoft.com/kb/974563.

 


Wednesday, October 07, 2009 #

October Rules Fest 2009, Dallas, TX

I've largely finished my presentation for the October Rules Fest 2009 conference in Dallas at the end of the month.   I'm speaking on complex event processing (CEP).   My plan is to provide a broad survey of CEP technologies, chiefly concentrating on the similarities and differences between event stream and rules processing.  There has been a lot of interest and activity around event processing in the rules community in recent years, and not a little controversy about the best approaches and, indeed, the role, if any, of Rete rules engines in detection of complex events.   Constructing the presentation has been something of a journey for me, and hopefully it will prove of interest to those attending the conference.

This is rather last-minute plug for ORF 2009.  It is the second year of this 'alternative' rules conference which is differentiated by a clear and unashamed focus on technology (there are other well-established rules conferences which focus on application at the business level), and by a wide-ranging interest in several related areas of science and research.  For me, some of last year's highlights included hearing Gary Riley explain how he managed to squeeze so much performance out of the CLIPS engine and listening to Dan Levine's talk on rule-based mechanisms in the human brain.  It's that kind of event.

The major rule-processing vendors (ILog (now IBM), FICO, Tibco, etc.,) are well represented at the event together with the JBoss team.   Charles Forgy, who came up with the Rete algorithm three decades ago, is a star speaker (a fascinating talk is promised on how to maximise the benefits of parallelisation in rules engines).   I'm particularly looking forward to hearing Andrew Waterman's talk on the use of rules processing in game-playing software used to promote sustainability and development of natural resources in Mexico.    I've been aware of this project for some time.   Greg Barton will be reporting on his experiences at Southwest Airlines.  There are interesting sessions on rule modelling and aspects of rule languages and DSLs, plenty on CEP, and various talks on constraint programming, rule verification and other topics.   And, to remind us all that technology, for technology's sake, is never a good idea, John Zackman will be there to talk about the role of rules in Enterprise Architecture.

ORF 2009, only in its second year, offers an incredibly varied diet for the rule technologist.   Together with the boot camps and introductory sessions at the beginning of the programme, it offers practical hands-on experience, a chance to learn about rules processing in depth, a showcase for the wide-ranging application of rules in many different areas of IT and an insight into many areas of research.

Places are still available, I understand.   The cost is kept as low as possible by the conference organisers, so visit http://www.octoberrulesfest.org for more information and book in while you can.


Monday, September 28, 2009 #

At first sight, StreamInsight doesn’t appear to offer any support for dynamic queries.   Once you have got over the initial ‘wow’ factor of creating continuous queries over streams using LINQ, rather than some SQL dialect or specialised DSL, the reality hits you that your query is just code.   You wrote the LINQ using C# or VB.NET, and you ended up compiling it into some assembly.

That’s all very well, but it’s not very flexible.   How are you going to store and manage your queries in a repository so that you can review, change and version them?   Does Microsoft really expect you to recompile and re-deploy assemblies every time you want to create or change a query in StreamInsight?   Surely you should be able to dynamically deploy queries straight from a repository.

Have no fear.   All is well.   The QueryTemplate is serialisable.   It isn’t serialisable in the .NET sense (i.e., it isn’t marked up as serilaisable, and it doesn’t implement ISerializable).   Rather, it implements the QueryTemplate.Definition property which returns an XML document containing a complete rendering of your template, complete with a full dataflow and all the operators.   To deserialise  the XML, you use Application.CreateQueryTemplate.   You have to pass in an XmlReader that you have created over the XML.   You get back a clone of the original QueryTemplate which you can now bind to input and output adapters and emit to the engine as a Query.   Nothing could be simpler.

There are a couple of gotchas.   First, don’t do what I did while experimenting.   I created a QueryTemplate and serialised it to XML.   I then tried to deserialise it as a second, identical, QueryTemplate in the same Server instance.    I got back an InvalidDefinition error.   It seems you can’t have identical QueryTemplates in a single StreamInsight Server instance.

The second thing to note is that the serialised QueryTemplate does not contain fully qualified references to your event types.   You still have to define the event types in your application by calling the CreateEventType method.   If you plan to store QueryTemplate XML in some custom repository, you will also need to store the fully qualified names of the .NET types your have defined for your events.   Of course, you will also need to ensure that these types are available at runtime.

Much the same argument applies to adapters.   The QueryTemplate XML does not contain any information on which input and output adapters you want to bind to your query.   However, once you realise that your QueryTemplates are serialisable, it is simple to work out how you might store and manage the template in some repository together with event type and adapter information.   All this information, taken together, defines the StreamInsight concept of a query.   You can write code to extract it from the repository at run-time and run the query.

The current CTP is just a glorified SDK.   Will Microsoft provide a repository and tooling in the release version?   I have no idea.   Given the freedom StreamInsight offers in terms of event definition, and given the fact that the engine can be hosted in custom applications, it is difficult to see how Microsoft could provide a totally generic end-to-end solution that would support externalisation of queries in any and all circumstances.   They could provide a repository and API, and leave it to developers to write the code to exploit the repository.   However, you would still need to write the LINQ together with code to create QueryTemplates and extract and upload XML to the repository.


Wednesday, September 23, 2009 #

What a pity.   I’ve spent some time recently evaluating SQL Server 2008 Reporting Services with respect to its proposed use on a UK public sector project that will implement a part of the 'national infrastructure'.   In every respect but one, Reporting Services provides an excellent fit for the stated requirements.   There is already a commitment to using SQL Server, and SharePoint, within the project, so Reporting Services appears the way to go.

What is the exception?   Well, Reporting Services provides a nice little tool called 'Report Builder' for creation, amongst other things, of ad hoc reports.   This is a user-friendly little gizmo that can be downloaded directly from the portal via Microsoft's excellent ClickOnce technology.   ClickOnce ensures that the application is installed in a sandboxed fashion under the current user's profile, and does not interfere with other installations for other users.

All good stuff, except that the proposed system needs to provide ad hoc reporting facilities to a number of different agencies across the UK.   Oh, and it must be formally accredited by the security people before it can go live.   It turns out that there is no prospect that they will agree to installation of any software on client desktops at those agencies.  Not even using ClickOnce.   It’s out of the question.

SAP offers a similar toolset to Reporting Services, but they have a tool for designing ad hoc reports that is entirely browser-based and has zero footprint on the client.

Mmmm.   Time for the Microsoft SQL Server product team to meet Ajax, methinks.


Monday, August 24, 2009 #

Richard Seroter talks here about feeding BizTalk events into StreamInsight or receiving events out as BizTalk messages.   I spent a little time considering the possibility of using StreamInsight in conjunction with BTS messaging infrastructure by building custom BTS adapters or pipeline components that directly hook into StreamInsight.   A preliminary look through the code samples (the best way, currently, of understanding this new engine, given that the CTP documentation is somewhat sparse) suggests to me that this is probably not the way to go.   As I understand things, there seems to be an impedance mismatch between BTS messaging and the concept of an event stream.   The closest thing BTS offers to an ‘event stream’ is its concept of a batch, used by adapters to submit multiple messages to BTS via the transport proxy as a single transactional interaction.   I say ‘closest’, but in reality a BTS batch is quite different to an event stream, and consequently a BTS adapter is not at all similar to a StreamInsight adapter.   Event streams may be continuous over extended periods of time, and don’t naturally fit a transactional model.
 
Of course, in constrained circumstances, it may be possible for the two models to co-exist. The sample TextFile input adapter, for example, reads a single CSV file and converts its contents into a stream of events.   A second CSV files would be processed as a separate event stream.   In this case, StreamInsight could co-exist nicely with a BTS pipeline that processes each CSV file as a separate message.   However, in other scenarios, you would have to ensure that a StreamInsight adapter continues to run over an open-ended number of BTS batch submissions.   Worse still, how would you cope with multiple instances of the same Receive Ports running in different host instances?   Somehow you would have to share a single event stream between those multiple BTS host instances.
 
So, I think that as far as BTS is concerned, the obvious places you might use StreamInsight are:
a)  outside of BTS, feeding events to a BTS Receive Port
b)  from within a BTS orchestration, probably exploiting the convoying and long-running
     transaction facilities of the orchestration to handle submission of event messages to
     a single event stream. 
c)  outside of BTS, receiving events emitted by a BTS Send Port. 
A special case of a) would be using StreamInsight in conjunction with RFID Server.   Remember that RFID Server can be used for more than just RFID devices.   c) would, I think, prove to be a rare scenario. b) and c) would both significantly compromise the raw performance of StreamInsight by inserting the relatively high latency BTS message box in front of a StreamInsight input adapter.
 
Having spent little time yet with the CTP, I reserve the right to make mistakes!   Maybe I have not properly grasped the StreamInsight model, but this is how it looks to me at present.

Friday, August 21, 2009 #

It was bound to happen.   The very day I fly off on vacation is the day that Microsoft posts the first public CTP of StreamInsight.   This is CTP2.   CTP1 was for private distribution inside Microsoft only, and I couldn't convince or bribe anyone to slip me a copy.   So, I just noticed now, and I haven't had a chance to look at it yet.   Can't wait, though.

CTP2 can be downloaded from http://www.microsoft.com/downloads/details.aspx?FamilyID=a3faa562-b6dc-4702-90c6-bf8e08df3b8b&displaylang=en


Monday, August 10, 2009 #

SQL Server 2008 R2 August CTP has just been released on MSDN and will be publically available on Wednesday.    One little point grabbed my attention.  The forthcoming CEP engine, formally known as 'Orinoco' (this codename was never meant to be used outside the company, but nevertheless made its way into the public domain) now has a proper name – ‘StreamInsight’ to be precise.

Microsoft SteamInsight isn’t included in the SQL Server CTP.  However, a separate CTP is due to be released in the next few weeks.


Thursday, June 11, 2009 #

Last night, I got around to investigating the new Web Slice functionality in IE8. I browsed to http://uk.msn.com/ and found various slices in the home page.   I installed the 'News' slice and then clicked on the button in my Favourites Bar...to be greeted by a rude message saying that "Internet Explorer cannot display the web page".
Bemused, I went binging and soon discovered that Google Gears and Web Slices don't play nicely together.   Unfortunately, this wasn't the answer.   I don't have Google Gears installed.   However, this prompted me to start working through my various Add-ins, disabling them and restarting the browser.   Eventually I found the culprit.   Web Slices, it appears, don't play nicely with Microsoft's 'Windows Live Family Safety Browser Helper Class' add-in.   Why I had this installed and enabled on my work notebook, I cannot say (the kids are not allowed anywhere near my machine).   Anyway, disabling the add-in enabled the new Web Slice features in IE8.
I couldn't find any mention of this anywhere on the web (not even when I googled rather than binged).   Maybe the problem is specific to my machine.  Before anyone asks, yes, this is repeatable.   Every time I switch the Family Safety add-in back on, web slices stop working.   Maybe web slices are deemed to be dangerous and this is by design.    Anyway, I hope this post will save someone a few minutes of annoyance.   I am, incidentally, using IE8 RTM on Vista Business with SP2.

Tuesday, June 09, 2009 #

Yesterday, Microsoft released the final version of ESB Toolkit 2.0 (the word 'Guidance' has been dropped) which you can download from http://www.microsoft.com/downloads/details.aspx?displaylang=en&FamilyID=bc86cf1e-ef29-4b19-95f7-388f64555090#tm.   I have had half an hour today to look at the documentation.   A preliminary read seems to suggest that, between the release of the CTP and the final release, Microsoft scrapped the old UDDI resolver and have introduced a completely new version that complies with the UDDI standards and which addresses the issues raised in a blog article which I published earlier this year. See http://geekswithblogs.net/cyoung/archive/2008/11/12/126975.aspx.   However, please be aware that I need time to properly digest the functionality changes, and won't be able to do that for another week or so.   I will report back when I have had more time to investigate.

Wednesday, May 27, 2009 #

Microsoft yesterday released a new ‘May 2009’ CTP for their 'Oslo' toolset.   This can be downloaded from Microsoft's web site at http://www.microsoft.com/downloads/details.aspx?FamilyID=827122a5-3ca0-4389-a79e-87af37cbf60d&displaylang=en.  
The release is notable for a couple of reasons.   First, it provides insight into the move away from the 'three-in-one’ language approach (MGraph, MSchema and MGrammar) towards a single unified, 'M' language.   Second, it contains an early version of 'Quadrant' which, to date, has only been visible outside the company as part of limited CTP releases (e.g., the PDC release).
Other highlights include an early version of UML domain models, together with an XMI repository loader.   Microsoft is publically committed to providing strong UML and XMI support in 'Oslo' and this is our first glimpse of what they intend.   There is also a CLR domain model and a corresponding .NET assembly loader.
The version of 'Quadrant' will raise a few eyebrows.   It contains functionality for browsing the repository, inspecting types and listing database sessions. However, those of us who played with earlier versions will be surprised to find that model creation facilities are missing.   You can drag items out into workpads onto the canvas as before, and use different views, but there are no tools for creating new models or amending existing models.  This does not, however, indicate some reversal of Microsoft's intentions. The Oslo team explain that they simply want to focus on model browsing in this CTP release, and to get feedback on that one aspect of the tooling.   Expect to see the ‘missing’ functionality re-emerge in future CTPs.
In a similar fashion, only a limited number of domain models are installed in the repository in this release.    In earlier releases we saw a whole lot more stuff that Microsoft is working on.   The absence of model domains in this release does not imply in any way that Microsoft has ceased working on those domains.   This is a constrained release only.
Update: I just discovered that one new feature of Quadrant is the ability to point it off at any SQL Server database.   This represents a further change in emphasis away from the purely respository-centric approach that was originally touted a year and half ago when MS first started talking about their plans.   It's very welcome.   So much metadata, and so many existing models are currently scattered to the four winds, and allowing Quadrant to explore and expolit those models in a unified fashion is a very good idea.   Let's have support for other stores, and not just SQL Server.
My initial experiments with LoadUML suggest that the tool is not yet fully functional.   For example, it fell over the use of the xmi:type attribute on the uml:Model element.  It failed to handle a type element of an ownedAttribute, and it didn’t recognise the packageImport element. The error messages were not always very helpful and the tool is slow.   This is very early preview (‘alpha’) code, so we must make allowances for these sorts of problems.   With a little messing around, I managed to successfully import a simple XMI file into the repository.
Update: The Oslo team plans to do a lot more work in this area to ensure that their XMI tooling works well with a spectrum of more widely-used modelling tools.   This, apparently, will mean building support for a number of XMI variants.
Initial experiments with LoadAssembly went a little more smoothly.   Again, the tool is very slow, and can take several minutes to complete imports.   The basic problem is that the tool imports a full closure of all assembly dependencies.   This means that every time you import an assembly, you are likely to suck in large amounts of additional metadata for.NET framework assemblies and anything else you are dependent on!   Nevertheless, the tool managed to cope with the assemblies I threw at it without any errors.  
This early version of Quadrant has big problems with big models.     It could, in some cases, take several minutes of 100% CPU usage to display the contents of a folder.   Memory usage can also grow to monumental proportions.     Do not import assemblies with large numbers of dependencies! Another problem is that the ‘Refresh’ facility in Quadrant doesn’t appear to work properly yet.   After re-importing a model, you will need to close the Repository Explorer and re-open it to see the changes.   Worse than that, when importing for the first time, I found I generally needed to close and re-open Quadrant itself to see new folders.   All in all, don’t expect Quadrant or the new loaders to behave very well.   This is very early preview code.
I haven’t yet played with the new version of IntelliPad or M.   I’m looking forward to seeing where these technologies have got to.

Thursday, May 21, 2009 #

Saravana Kumar has just re-launched BizTalk 247.com (see http://www.biztalk247.com) with lots of new content and a new layout, look and feel.   Look very quickly and you might just spot that awful photo of me on the home page!   The one with the bright purple tie and a dark blue shirt.   What was I thinking?   Oh well, no-one said that being a BizTalk user equated to being cool.   And I desperately needed a haircut. 
Anyway, congratulations to Saravana.   This is a really useful single stop shop for BizTalk resources. Lots of videos (including a couple with me waving my hands around like a manic thing) and links to various widgets, featured books and guides and tons of other stuff.   Saravana has also worked hard to ensure that URLs to various resources on the site are short and to the point so that you easily find what you are looking for.   Mind you, being a point & click man, myself, I think the site is very easy to navigate anyway.

After publishing the article on CEP on the Microsoft platform a couple of days ago ( see http://geekswithblogs.net/cyoung/archive/2009/05/18/cep_explained_for_biztalk_users.aspx), I was reminded of an excellent presentation given by my good friends John Plummer and Jeff Johnson at the Microsoft Architect Insight conference in 2008.   John and Jeff both work for Microsoft in the UK.   They used NEsper (the .NET port of the open source Esper event processing engine) to demonstrate how CEP might be used in conjunction with BizTalk technologies.   I dug out the slides and reminded myself of their presentation.   All very good stuff.  the slides are at:

http://download.microsoft.com/documents/uk/msdn/events/SOL/SOL08.pptx


Monday, May 18, 2009 #

Wow...three posts in one day - a world record for me.

According to Brian Loesgen, ESB Toolkit 2.0 for Biztalk 2009 will be released mid-June.


Microsoft will, later today, release beta 1 of Visual Studio 2010 and .NET 4.0 on MSDN.   A public release will follow on Wednesday.    For further informtion, see http://blogs.msdn.com/somasegar/archive/2009/05/18/visual-studio-2010-and-net-fx-4-beta-1-ships.aspx.

Last Monday, Microsoft used the TechEd keynote to announce their plans to include a Complex-Event Processing (CEP) engine in SQL Server 2008 R2.   This article attempts to explain CEP from the perspective of a long-time user of BizTalk Server and to address the question as to why BizTalk architects and developers might have a reason to take an interest in the forthcoming CEP engine.

Read on at http://geekswithblogs.net/cyoung/archive/2009/05/18/cep_explained_for_biztalk_users.aspx...


Wednesday, May 13, 2009 #

Following on from the news about Microsoft's CEP engine, Richard Seroter attended yesterday's TechEd session on the new engine and has blogged very detailed notes.   See http://seroter.wordpress.com/2009/05/12/teched-2009-day-2-session-notes-cep-first-look/.    I'm delighted to see that Microsoft is disclosing much the same level of information publically that they made available internally a couple of months ago.  Now all we need is CTP 1.

Richard notes that the session was sparsely attended.   CEP has some way to go before it is widely acknowledged or understood in the mainstream, and the potential impact of engines like this will be poorly understood at present.   I intend to put together an article or two in which I'll attempt to explain why I think we should all take note.

I responded to a comment from Tim Bass last night.   Tim is a vocal critic of the CEP marketplace, and one of his common themes is the belief that most/all CEP vendors currently attach the term 'CEP' incorrectly to what are 'mere' event stream processing engines.   I responded by pointing out the CEDR technology, on which I believe Microsoft's engine in based, directly tackles one of the chief characteristics of the event 'cloud' (a core concept in CEP) which is that events may be detected out-of-order in terms of time and causality, and that CEP engines must be able to handle this efficiently.   I was interested to see that Richard recorded an emphasis on this capability of Microsoft’s new engine.

Also, one other point.  I had a Twitter message yesterday from another well-known person on the CEP circuit who said that he hadn't seen any sign of anyone using the new Microsoft engine yet.  For the avoidance of confusion, Microsoft only announced the engine yesterday.   There is a very early private preview of the code doing the rounds internally within Microsoft.   It looks like the first public CTP will be available later this year and that launch is expected next year.   So no one is yet using the engine, apart from Microsoft themselves (apparently, if I understood comments made during the keynote correctly, they are currently handling 500 million events a day through the engine in association with their web site).


Monday, May 11, 2009 #

NewsFlash...Microsoft today announced their long-awaited entry into the Complex Event Processing market.   The press release is at http://www.microsoft.com/presspass/press/2009/May09/05-11TechEd09PR.mspx.   The news was also announced by Bill Veghte as part of his keynote at TechEd.   The Microsoft CEP offering will be delivered as part of SQL Server 2008 R2 

Unfortunately, this is the only information I can find so far in the public domain, and, being a cautious kind of guy, and NDAd up the hilt, I will hold back from saying more until I can guage just how much detail Microsoft is releasing at the current time.   It looks like they have a session at TechEd tomorrow on their forthcoming offering.   There was talk a few weeks back of an early public CTP, but there is now some suggestion that this may not be available until later in the year.   Watch this space for more info.

In the meantime, here are a couple of Microsoft Research links that you might find interesting.   I couldn't possibly say how relevant they might be ;-)


http://research.microsoft.com/apps/pubs/default.aspx?id=70517


http://middleware05.objectweb.org/WSProceedings/demos/d1_Barga.pdf


Thursday, May 07, 2009 #

I dealt with an interesting, if arcane, issue today at a client's site. The client is in the process of deploying an early version of a BizTalk application to their test environment for the first time.   The test environment is hosted by another company, and BizTalk Server 2006 R2 had been installed and configured by that company. They are using the 64 bit version on Windows 2003 R2 with SP2.   The BizTalk application publishes a WCF endpoint, hosted in IIS6.
The hosting company has quite correctly created a set of domain accounts and groups and configured BizTalk to use these.   Unfortunately, when doing the initial deployment yesterday, we didn't have, and couldn't get, the password for the configured BizTalk Isolated Host user account.   We did, however, have the password for another domain account, and we were able to add that account to the BizTalk Isolated Host Users domain group.   So, having done that, we configured this second account as the identity of the app pool.
To begin with, nothing worked.   Every time we tried to access the WCF endpoint, IIS returned a 404 - Service unavailable message.   However, at some point, the whole thing started working OK.   I forget, now, the exact sequence of steps, but that is not important.
At some point yesterday, the BizTalk developer created a local account called 'BizTalk Isolated Host Users'. I can't remember, now, why we thought this would be a good idea.   Our BizTalk Server is configured to use a domain group of the same name, and is not aware of the local group.   The important point, though, is that this group was not deleted.
Roll forward to today.   Everything was working nicely until the BizTalk developer decided, very sensibly, to tidy things up by removing the unneeded local group.   Shortly after removing this group, we noticed that the dreaded 404 response had returned. The only change we had made was the removal of the local group, so we recreated it.   We didn't add any accounts to it.   After an IIS restart, the endpoint sprang back into life.   We deleted the group, and everything stopped working.   We recreated it again, checked that the endpoint was working, renamed the group and tested.   Sure enough, we got a 404. We changed the name back, and the endpoint worked.
At this point, I felt very confused at several levels.   We checked the configuration of BizTalk carefully, and satisfied ourselves that it had indeed been configured to use only domain accounts and groups. The only thing that was unusual about our environment was that, while the BizTalk isolated host instance we were using was configured to use one domain account for its logon credentials, the IIS app pool was configured to use another, set up with equivalent group membership and permissions.
I have always, as a natural path of least resistance, configured app pools to use the same identity as the corresponding isolated host instance.   I realised that I have never consciously asked the question about what happens if you use different accounts. I phoned a colleague who has far more practical experience of deploying BizTalk than I do, and discussed this with him.   He confirmed that he also always uses the same account, and like me, he had never stopped to wonder what happens if you use different accounts.   So, I turned to the Internet and did some searching.   Eventually, I discovered, embedded half-way through a BizTalk help page on MSDN (see http://65.55.11.235/en-us/library/aa561505.aspx), an explicit statement that the app pool should always be configured with the same account as the isolated host instance.   In the grand tradition of BizTalk documentation there was, of course, absolutely no effort expended on explaining why.   However, the help page also stated mysteriously that if you change the password on the account in the app pool configuration, there is no need to make a corresponding change to the credentials configured on BizTalk's isolated host instance.   Bizarre.   This seems to imply that the credentials you configure in BizTalk are not actually used for any kind of authentication.
We talked to the hosting company, and managed to get the password we needed.   We re-configured the IIS app pool to use the same account configured for the BizTalk isolated host instance.   Having deleted the local group, we restarted IIS and...success...everything worked OK.
So, the moral of the story is that you really need to ensure that your app pool identity is the same as the account you configure on the BizTalk isolated host instance.   Don't worry about keeping the password up to date in BizTalk.   I strongly recommend you always use this approach.    If you really, really , really have to live with different accounts, create an empty local group on you BizTalk box with an identical name to the domain group you are using as BizTalk isolated host users group, and by some magic, everything will work.   Avoid this weird 'work-around' at all costs in production.
Maybe this is some strange side-effect of Windows pass-through authentication (I don't really think that is the case), or maybe it is the result of some undocumented logic deep in the message agent or transport layer.   I can't say.   I do remember that when BTS 2004 first shipped, there was a suggestion that MS might at some point extend the isolated host feature to support additional hosts, and not just IIS.   This has never happened, but it may be the explanation for what you configure an account and password on your isolated host instances even if, in the case of IIS, it is the app pool configuration which is all-important.

Wednesday, April 29, 2009 #

Over on the ILOG blog, Chris Berg called out Andrew Siemer’s post at http://geekswithblogs.net/AndrewSiemer/archive/2009/03/30/ilog-rules-for-.net-3.0-ndash-quick-overview.aspx.   I thought I’d post some observations by way of a response.

See http://geekswithblogs.net/cyoung/archive/2009/04/29/131593.aspx...


Tuesday, April 28, 2009 #

My colleague, the ‘Arch Hacker’, forwarded an email to me this evening from Kenton Price.   Kenton had noticed some peculiar behaviour using the Microsoft Business Rules Engine.   Here are the pertinent extracts from Kenton’s report:
 
“It appears that if you assert a fact in a rule, it hangs around for subsequent instantiations of the rule engine, behaving like a long-term fact.... I solved it by retracting each asserted fact on every exit path (I had a jump-out-early that halts and stops all other rules, so I had to retract the asserted facts here too)....Facts provided in the object[] passed to the BRE call are all retracted automatically. It appears that any others you assert within the rules must be manually retracted.”
 
Kenton is quite correct.   The issue is actually to do with the Policy class, and there are good reasons why the engine behaves this way.   Read more at http://geekswithblogs.net/cyoung/archive/2009/04/28/131548.aspx.