solidsoft-reply / esb-libraries Goto Github PK

The ESB Libraries support a graduated approach to BAM when used in BizTalk orchestration code. At one end of the spectrum, the OnStep() method can be used to execute an entire Interceptor step at one location in the code. At the other end of the spectrum, developers can use BAM event streams, including the TrackpointDirectiveEventStream class and OESTrackpointEventStream provided by the ESB Libraries, to perform BAM actions without the use of Interception. Between these two extremes, the ESB Library event stream classes support two further models. The first allows developers to perform all the actions of a given type (e.g., all the updates defined in a step) at one location. The second allows the developers to perform certain BAM actions individually, but using configuration supplied by the Step.

These features are designed to make the ESB Libraries more useful when performing BAM in orchestrations. However, a further issue has been raised. When using the Step-driven approaches, developers naturally want to model different sets of actions as different steps that they can apply in different locations in a given orchestration. However, this necessitates the use of BAM continuation. This feels unnatural to developers, and requires additional work to manage continuation IDs.

For reasons I won't discuss in depth here, there is no sensible or safe alternative to using BAM continuation across multiple steps in a single orchestration. This has to do partly with the way the BAM Interceptor Framework works and partly with the fact that, even in a single orchestration, situations can potentially arise where updates could arrive out-of-order in the BAM primary import tables if continuation is not used.

Having recognised the underlying imperative to use BAM continuation, the question is "can the ESB Libraries be extended to make this continuation feel more 'natural' to developers". One approach would be to manage creation of continuation tokens and the performance of continuation in a more automated 'hidden' fashion. This would still need to be modelled in steps - e.g., by introducing an 'Extend a given activity' vocabulary definition that links a step to another step. In effect, the proposed mechanism will link continuation directly to directives, using each directive's knowledge of the current activity ID to manufacture continuations. This would be safe, because it would be based four-square on BAM continuation. However, it would also hide the use of continuation from the developer and provide them with a mechanism aligned closely to the use of directives, making the use of the libraries feel more natural.

Currently, the documented instructions mandate the use of WCF binding configuration in the BTSNTSvc,config.exe WCF file or any other relevant config file. In fact, there is some evidence that it is possible to rely on the recent enhancements in WCF 4 which support configuration-free binding. However, there is also evidence that this can be problematic. The code should be improved to handle bindings in code, rather than static configuration.

When an endpoint directive instruction is created with endpoint configuration, the directive validation reports that the configuration is missing.

The WiX installer should be enhanced to support optional installation of the UDDI library. This library is often not required. In the same way, the UDDI action vocabulary should be optionally installed

The pipeline components always indent XML content in messages. Although the XML is valid, this is not a good strategy for integration where a recipient may not be handling whitespace well, etc. The behaviour is caused by the use of the Save() method on XmlDocument.

To improve this, the code has now been changed to avoid formatting by default. However, formatting can be useful. The code has been extended to handle an additional XML formatting action in directives. This supports normalization of XML as well as indenting.

An intermittent issue can arise when using the Service Mediation FF Disassembler component in a BizTalk pipeline. It may sometimes fail to process a message, failing with an error that states that the DataReader has been disposed.

This bug was caused by faulty logic in which the Service Mediation component set the MessageType property of the component after transformation. The code has been amended to use a local variable instead of the component property.

The signing file is password-protected, and is a PFX file rather than the more normal .snk file. Assemblies must be strong-named for use in BizTalk Sever, but password protection of the key file is not appropriate for an open-source project. Without the password, certain problems cannot be addressed. For example, the UDDI unit tests depend on the use of the full public key to allow internal members to be made visible for test purposes.

If one of the ESB service mediation disassembly pipeline components (not the Service Mediation component, but one of other components - XML, FF, BTF, EDI or AS2) is re-configured in a Receive Port using the BizTalk administration console, the next time the pipeline component is invoked, it fails with the following error:

COM object that has been separated from its underlying RCW cannot be used. The possible cause is invalid or malformed per instance configuration data.

The BizTalk application has to be redeployed to recover from this failure.

The code does not log effectively to the event log. This is dependent on improvement to the WiX setup MSI to handle registration of event sources.

The code assumes that all routing endpoints are specified as well-formed URIs. This is a run-time validation test performed on directives. However, there is no such constraint in the real world. For example, a BizTalk Server Send Port may drop files into a folder using non-URI file path. This validation rules should be removed.

The installer does not currently handle the following:

a) Selection of target folder for installing the Resolver Service and reference assemblies
b) Importing and publishing of the BRE vocabularies
c) Verification of the Application Pool account
d) Automatic adding of the Application Pool account to the appropriate Windows Groups for access to the Rules repository
e) Automatic configuration of BizTalk BTSNTSvc.exe.config files

This is a candidate list of enhancements which will be addressed in dues course.

When a policy is configured to return BTS properties, the property collection does not appear in the directive.

The message type property of messages is not being set correctly after transformation in pipeline components. It is being overwritten by the original message type of the pre-transformation message

Several of the UDDI unit tests fail when run.

Requests from the resolver are handled correctly by the Resolver Service. However, when I dump the raw request and replay it via SOAP UI, the tests fail with custom serialisation issues.

On moving an expression shape that contains resolver code to a different location in an orchestration, the following serialization error started occurring.

'System.Linq.Enumerable+WhereSelectArrayIterator`2[[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]' in Assembly 'System.Core, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089' is not marked as serializable. StackTrace: at System.Runtime.Serialization.FormatterServices.InternalGetSerializableMembers(RuntimeType type)
at System.Runtime.Serialization.FormatterServices.GetSerializableMembers(Type type, StreamingContext context)
at System.Runtime.Serialization.Formatters.Binary.WriteObjectInfo.InitMemberInfo()
at System.Runtime.Serialization.Formatters.Binary.WriteObjectInfo.InitSerialize(Object obj, ISurrogateSelector surrogateSelector, StreamingContext context, SerObjectInfoInit serObjectInfoInit, IFormatterConverter converter, ObjectWriter objectWriter, SerializationBinder binder)
at System.Runtime.Serialization.Formatters.Binary.ObjectWriter.Write(WriteObjectInfo objectInfo, NameInfo memberNameInfo, NameInfo typeNameInfo)
at System.Runtime.Serialization.Formatters.Binary.ObjectWriter.Serialize(Object graph, Header[] inHeaders, __BinaryWriter serWriter, Boolean fCheck)
at System.Runtime.Serialization.Formatters.Binary.BinaryFormatter.Serialize(Stream serializationStream, Object graph, Header[] headers, Boolean fCheck)
at Microsoft.XLANGs.Core.ObjectSerializer._serialize(Object graph, StringLookup sl)
at Microsoft.XLANGs.Core.ObjectSerializer.SerializeStateManager(IStateManager stateMgr, StringLookup lookup)
at Microsoft.XLANGs.Core.Service.Persist(Boolean dehydrate, Context ctx, Boolean idleRequired, Boolean finalPersist, Boolean bypassCommit, Boolean terminate)
at Microsoft.XLANGs.Core.ServiceContext.PendingCommit(Boolean ignore, XMessage msg)
at Microsoft.XLANGs.Core.ExceptionHandlingContext.PendingCommit(Boolean ignoreCommit, XMessage msg)
at Microsoft.XLANGs.Core.ExceptionHandlingContext.PendingCommit(Boolean ignoreCommit, XMessage msg)
at Microsoft.BizTalk.XLANGs.BTXEngine.BTXPortBase.SendMessage(Int32 iOperation, XLANGMessage msg, Correlation[] initCorrelations, Correlation[] followCorrelations, Context cxt, Segment seg, ActivityFlags flags)
at GDIH.CustomerRef.Common.Orchestrations.ProcessCustomerReference.segment2(StopConditions stopOn)
at Microsoft.XLANGs.Core.SegmentScheduler.RunASegment(Segment s, StopConditions stopCond, Exception& exp)

The XPath/macro specifiers in BAM interception policies allow format strings to be provided in outer braces. These braces are not being removed when the data is updated to the BAM primary import tables.

A problem with corrupted pipeline configuration highlighted the need for improvements to error handling in the Load() method of the Service Mediation pipeline component. The code should log friendly and informative errors related to individual properties, rather than low-level technical issues such as COM problems.

If the UDDI library is not installed, the Resolver Service cannot run due to a static reference on the UDDI library.