Monday, November 2, 2015

String trimming WCF inspector for JSON binding

In my last blog entry I presented a string trimming WCF inspector for SOAP binding. Unfortunately, the approach presented there doesn’t work for Web bound WCF services that use JSON as the communication language.

The difficulty here is that the documentation of possible differences in message inspectors for XML vs JSON is very sparse. Fortunately, the previously mentioned blog entry by Carlos Figueira brings some invaluable details. In particular, Carlos shows that internally a JSON WCF represents the incoming data using XML, unfortunately however, there approach from the SOAP inspector doesn’t work this time. This is because requests are never SOAP envelopes.

There are two possible approaches, either stick with the XML that represents incoming JSON data or work at the JSON level. I took this as a challenge to get the JSON from the XML, modify it and give it back to the message builder. To trim strings I need a completely different approach then, I no longer walk over XML nodes, rather I have a JSON I need to rewrite to another JSON but the actual structure of the data is not known (the inspector works for different WCF methods of different signatures not known to the inspector).

My proposal is as follows, it uses JSON.NET to rewrite JSON with a help of an auxiliary json converter that does actual trimming.

/// <summary>
 /// WCF inspektor trimujący stringi dla webhttpbinding
 /// </summary>
 /// <remarks>
 /// https://code.msdn.microsoft.com/WCF-REST-Message-Inspector-c4b6790b
 /// </remarks>
 public class StringTrimmingWebMessageInspector : IDispatchMessageInspector
 {
     #region IDispatchMessageInspector Members
 
     public object AfterReceiveRequest(
         ref System.ServiceModel.Channels.Message request,
         IClientChannel channel, InstanceContext instanceContext )
     {
         if ( !request.IsEmpty )
         {
             WebContentFormat messageFormat = this.GetMessageContentFormat( request );
             if ( messageFormat == WebContentFormat.Json )
             {
                 MemoryStream ms            = new MemoryStream();
                 XmlDictionaryWriter writer = JsonReaderWriterFactory.CreateJsonWriter( ms );
                
                 request.WriteMessage( writer );
                 writer.Flush();
 
                 ms.Close();
 
                 string messageBody = Encoding.UTF8.GetString(ms.ToArray());
 
                 string convertedBody = JObject.Parse( messageBody )
                    .ToString( Newtonsoft.Json.Formatting.None, new TrimmingConverter() );
 
                 ms = new MemoryStream( Encoding.UTF8.GetBytes( convertedBody ) );
                 XmlDictionaryReader reader = 
                    JsonReaderWriterFactory.CreateJsonReader( ms, XmlDictionaryReaderQuotas.Max ); 
 
                 Message newMessage = Message.CreateMessage( reader, int.MaxValue, request.Version );
                 newMessage.Properties.CopyProperties( request.Properties );
                 request = newMessage; 
             }               
         }
 
         return null;
     }
 
     private WebContentFormat GetMessageContentFormat( Message message )
     {
         WebContentFormat format = WebContentFormat.Default;
         if ( message.Properties.ContainsKey( WebBodyFormatMessageProperty.Name ) )
         {
             WebBodyFormatMessageProperty bodyFormat;
             bodyFormat = (WebBodyFormatMessageProperty)message.Properties[WebBodyFormatMessageProperty.Name];
             format = bodyFormat.Format;
         }
 
         return format;
     }
 
     public void BeforeSendReply( ref System.ServiceModel.Channels.Message reply, object correlationState )
     {
     }
 
     #endregion
 }
 
 public class TrimmingConverter : JsonConverter
 {
     public override bool CanConvert( Type objectType )
     {
         return objectType == typeof( string );
     }
     public override bool CanRead { get { return true; } }
     public override object ReadJson( 
        JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer )
     {
         if ( reader.Value != null && reader.Value is string )
             return ( (string)reader.Value ).Trim();
         else
             return reader.Value;
     }
     public override bool CanWrite { get { return true; } }
     public override void WriteJson( 
        JsonWriter writer, object value, JsonSerializer serializer )
     {
         if ( value is string )
             serializer.Serialize( writer, ( (string)value ).Trim() );
         else
             serializer.Serialize( writer, value );
     }
 }

String trimming WCF message inspector for XML binding

How often your users copy-paste data from somewhere to your web app and then post something that is incorrect because some extra characters are copied from the source text? Is user name really “ John ” “ Smith ”?

Sooner or later at the server side, the input strings are validated but often what you do first is a simple trimming so that “ John” becomes “John”. The question is then not “to trim or not to trim” but rather “when the trimming should occur to be as ellegant as possible”.

String trimming on HTTP input is a convenient solution. The data that is processed by an MVC controller, a WebApi controller or a WCF service code is already trimmed so that you don’t have to put any extra effort on trimming at the business level of your code. This approach is common and solutions for MVC or WebAPI can easily be found.

My specific problem was that I needed the same for WCF and unfortunately, I couldn’t find anything ready to use. My previous experience with WCF message inspectors suggested that a smart inspector is a way to go. A series of blog entries by Carlos Figueria is a valuable source of information on that topic, however this specific requirement of a trimming inspector has no previous solutions (or I couldn’t find any).

Without any further ado, let’s see how such message inspector is implemented:

/// <summary>
/// WCF inspektor trimujący stringi
/// </summary>
public class StringTrimmingMessageInspector : IDispatchMessageInspector
{
    #region IDispatchMessageInspector Members
 
    public object AfterReceiveRequest(
        ref System.ServiceModel.Channels.Message request,
        IClientChannel channel, InstanceContext instanceContext )
    {
        if ( !request.IsEmpty )
        {
            MessageBuffer buffer = request.CreateBufferedCopy( Int32.MaxValue );
            request = buffer.CreateMessage();
 
            XmlDocument xmlDoc = new XmlDocument();
 
            using ( MemoryStream ms = new MemoryStream() )
            {
                XmlWriter writer = XmlWriter.Create( ms );
                request.WriteMessage( writer ); // the message was consumed here
                writer.Flush();
                ms.Position = 0;
                xmlDoc.Load( ms );
            }
 
            XmlNamespaceManager manager = new XmlNamespaceManager( xmlDoc.NameTable );
            manager.AddNamespace( "s", "http://schemas.xmlsoap.org/soap/envelope/" );
 
            XmlNode bodyNode = xmlDoc.SelectSingleNode( "//s:Envelope/s:Body", manager );
            this.ChangeNode( bodyNode );
 
            Message newMessage = Message.CreateMessage( request.Version, request.Headers.Action, bodyNode.FirstChild );
            newMessage.Properties.CopyProperties( request.Properties );
 
            request = newMessage;
        }
 
        return null;
    }
 
    private void ChangeMessage( XmlDocument doc )
    {
        if ( doc == null ) return;
 
        ChangeNode( doc.DocumentElement );
    }
 
    private void ChangeNode( XmlNode node )
    {
        if ( node == null ) return;
        if ( node.NodeType == XmlNodeType.Text ) node.InnerText = node.InnerText.Trim();
 
        foreach ( XmlNode childNode in node.ChildNodes )
            ChangeNode( childNode );
    }
 
    public void BeforeSendReply( ref System.ServiceModel.Channels.Message reply, object correlationState )
    {
    }
 
    #endregion
}

The inspector assumes the message is always an XML document and this is true for XML based bindings. A request is always a SOAP envelope that has headers and a body. Inside the inspector I retrieve the body node of an incoming message and I run a simple recursive function on the node that walks over the tree of XML nodes and whenever it find a node of text type, it trims its contents. I then recreate the message using traversed node as the body.

To apply the inspector, I also need a simple endpoint behavior

/// <summary>
/// Podstawowa infrastruktura rozszerzania
/// </summary>
public class StringTrimmingBehavior : IEndpointBehavior
{
    #region IEndpointBehavior Members
 
    public void AddBindingParameters( ServiceEndpoint endpoint, 
       System.ServiceModel.Channels.BindingParameterCollection bindingParameters )
    {
    }
 
    public void ApplyClientBehavior( ServiceEndpoint endpoint, 
       System.ServiceModel.Dispatcher.ClientRuntime clientRuntime )
    {
    }
 
    public void ApplyDispatchBehavior( ServiceEndpoint endpoint, 
       System.ServiceModel.Dispatcher.EndpointDispatcher endpointDispatcher )
    {
        endpointDispatcher.DispatchRuntime.MessageInspectors
           .Add( new StringTrimmingMessageInspector() );
    }
 
    public void Validate( ServiceEndpoint endpoint )
    {
    }
 
    #endregion
}
And this is it, please feel free to use/modify this for your own purposes.