2 // WebMessageFormatter.cs
5 // Atsushi Enomoto <atsushi@ximian.com>
6 // Atsushi Enomoto <atsushi@xamarin.com>
8 // Copyright (C) 2008,2009 Novell, Inc (http://www.novell.com)
9 // Copyright (C) 2011 Xamarin, Inc (http://xamarin.com)
11 // Permission is hereby granted, free of charge, to any person obtaining
12 // a copy of this software and associated documentation files (the
13 // "Software"), to deal in the Software without restriction, including
14 // without limitation the rights to use, copy, modify, merge, publish,
15 // distribute, sublicense, and/or sell copies of the Software, and to
16 // permit persons to whom the Software is furnished to do so, subject to
17 // the following conditions:
19 // The above copyright notice and this permission notice shall be
20 // included in all copies or substantial portions of the Software.
22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 using System.Collections.Generic;
32 using System.Globalization;
34 using System.Reflection;
35 using System.Runtime.Serialization;
36 using System.Runtime.Serialization.Json;
37 using System.ServiceModel;
38 using System.ServiceModel.Channels;
39 using System.ServiceModel.Description;
40 using System.ServiceModel.Web;
45 using XmlObjectSerializer = System.Object;
48 namespace System.ServiceModel.Dispatcher
50 // This set of classes is to work as message formatters for
51 // WebHttpBehavior. There are couple of aspects to differentiate
53 // - request/reply and client/server
54 // by WebMessageFormatter hierarchy
55 // - WebClientMessageFormatter - for client
56 // - RequestClientFormatter - for request
57 // - ReplyClientFormatter - for response
58 // - WebDispatchMessageFormatter - for server
59 // - RequestDispatchFormatter - for request
60 // - ReplyDispatchFormatter - for response
62 // FIXME: below items need more work
63 // - HTTP method differences
66 // - output format: Stream, JSON, XML ...
68 internal abstract class WebMessageFormatter
70 OperationDescription operation;
71 ServiceEndpoint endpoint;
72 QueryStringConverter converter;
73 WebHttpBehavior behavior;
75 WebAttributeInfo info = null;
77 public WebMessageFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
79 this.operation = operation;
80 this.endpoint = endpoint;
81 this.converter = converter;
82 this.behavior = behavior;
85 // This is a hack for WebScriptEnablingBehavior
86 var jqc = converter as JsonQueryStringConverter;
88 BodyName = jqc.CustomWrapperName;
92 void ApplyWebAttribute ()
94 MethodInfo mi = operation.SyncMethod ?? operation.BeginMethod;
96 object [] atts = mi.GetCustomAttributes (typeof (WebGetAttribute), false);
98 info = ((WebGetAttribute) atts [0]).Info;
99 atts = mi.GetCustomAttributes (typeof (WebInvokeAttribute), false);
101 info = ((WebInvokeAttribute) atts [0]).Info;
103 info = new WebAttributeInfo ();
105 template = info.BuildUriTemplate (Operation, GetMessageDescription (MessageDirection.Input));
108 public string BodyName { get; set; }
110 public WebHttpBehavior Behavior {
111 get { return behavior; }
114 public WebAttributeInfo Info {
118 public WebMessageBodyStyle BodyStyle {
119 get { return info.IsBodyStyleSetExplicitly ? info.BodyStyle : behavior.DefaultBodyStyle; }
122 public bool IsRequestBodyWrapped {
125 case WebMessageBodyStyle.Wrapped:
126 case WebMessageBodyStyle.WrappedRequest:
129 return BodyName != null;
133 public bool IsResponseBodyWrapped {
136 case WebMessageBodyStyle.Wrapped:
137 case WebMessageBodyStyle.WrappedResponse:
140 return BodyName != null;
144 public OperationDescription Operation {
145 get { return operation; }
148 public QueryStringConverter Converter {
149 get { return converter; }
152 public ServiceEndpoint Endpoint {
153 get { return endpoint; }
156 public UriTemplate UriTemplate {
157 get { return template; }
160 protected WebContentFormat ToContentFormat (WebMessageFormat src, object result)
162 if (result is Stream)
163 return WebContentFormat.Raw;
165 case WebMessageFormat.Xml:
166 return WebContentFormat.Xml;
167 case WebMessageFormat.Json:
168 return WebContentFormat.Json;
170 throw new SystemException ("INTERNAL ERROR: should not happen");
173 protected string GetMediaTypeString (WebContentFormat fmt)
176 case WebContentFormat.Raw:
177 return "application/octet-stream";
178 case WebContentFormat.Json:
179 return "application/json";
180 case WebContentFormat.Xml:
182 return "application/xml";
186 protected void CheckMessageVersion (MessageVersion messageVersion)
188 if (messageVersion == null)
189 throw new ArgumentNullException ("messageVersion");
191 if (!MessageVersion.None.Equals (messageVersion))
192 throw new ArgumentException (String.Format ("Only MessageVersion.None is supported. {0} is not.", messageVersion));
195 protected MessageDescription GetMessageDescription (MessageDirection dir)
197 foreach (MessageDescription md in operation.Messages)
198 if (md.Direction == dir)
200 throw new SystemException ("INTERNAL ERROR: no corresponding message description for the specified direction: " + dir);
203 protected XmlObjectSerializer GetSerializer (WebContentFormat msgfmt, bool isWrapped, MessagePartDescription part)
205 if (part.Type == typeof (void))
206 return null; // no serialization should be done.
209 case WebContentFormat.Xml:
210 if (xml_serializer == null)
211 xml_serializer = isWrapped ? new DataContractSerializer (part.Type, part.Name, part.Namespace) : new DataContractSerializer (part.Type);
212 return xml_serializer;
213 case WebContentFormat.Json:
214 // FIXME: after name argument they are hack
215 if (json_serializer == null)
216 json_serializer = isWrapped ? new DataContractJsonSerializer (part.Type, BodyName ?? part.Name, null, 0x100000, false, null, true) : new DataContractJsonSerializer (part.Type);
217 return json_serializer;
219 throw new NotImplementedException (msgfmt.ToString ());
223 XmlObjectSerializer xml_serializer, json_serializer;
225 protected object DeserializeObject (XmlObjectSerializer serializer, Message message, MessageDescription md, bool isWrapped, WebContentFormat fmt)
227 // FIXME: handle ref/out parameters
229 var reader = message.GetReaderAtBodyContents ();
230 reader.MoveToContent ();
232 bool wasEmptyElement = reader.IsEmptyElement;
235 if (fmt == WebContentFormat.Json)
236 reader.ReadStartElement ("root", String.Empty); // note that the wrapper name is passed to the serializer.
238 reader.ReadStartElement (md.Body.WrapperName, md.Body.WrapperNamespace);
241 var ret = (serializer == null) ? null : ReadObjectBody (serializer, reader);
243 if (isWrapped && !wasEmptyElement)
244 reader.ReadEndElement ();
249 protected object ReadObjectBody (XmlObjectSerializer serializer, XmlReader reader)
252 return (serializer is DataContractJsonSerializer) ?
253 ((DataContractJsonSerializer) serializer).ReadObject (reader) :
254 ((DataContractSerializer) serializer).ReadObject (reader, true);
256 return serializer.ReadObject (reader, true);
260 internal class RequestClientFormatter : WebClientMessageFormatter
262 public RequestClientFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
263 : base (operation, endpoint, converter, behavior)
267 public override object DeserializeReply (Message message, object [] parameters)
269 throw new NotSupportedException ();
273 internal class ReplyClientFormatter : WebClientMessageFormatter
275 public ReplyClientFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
276 : base (operation, endpoint, converter, behavior)
280 public override Message SerializeRequest (MessageVersion messageVersion, object [] parameters)
282 throw new NotSupportedException ();
287 internal class RequestDispatchFormatter : WebDispatchMessageFormatter
289 public RequestDispatchFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
290 : base (operation, endpoint, converter, behavior)
294 public override Message SerializeReply (MessageVersion messageVersion, object [] parameters, object result)
296 throw new NotSupportedException ();
300 internal class ReplyDispatchFormatter : WebDispatchMessageFormatter
302 public ReplyDispatchFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
303 : base (operation, endpoint, converter, behavior)
307 public override void DeserializeRequest (Message message, object [] parameters)
309 throw new NotSupportedException ();
314 internal abstract class WebClientMessageFormatter : WebMessageFormatter, IClientMessageFormatter
316 IClientMessageFormatter default_formatter;
318 protected WebClientMessageFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
319 : base (operation, endpoint, converter, behavior)
323 public virtual Message SerializeRequest (MessageVersion messageVersion, object [] parameters)
325 if (parameters == null)
326 throw new ArgumentNullException ("parameters");
327 CheckMessageVersion (messageVersion);
329 var c = new Dictionary<string,string> ();
331 MessageDescription md = GetMessageDescription (MessageDirection.Input);
335 object msgpart = null;
338 for (int i = 0; i < parameters.Length; i++) {
339 var p = md.Body.Parts [i];
340 string name = p.Name.ToUpper (CultureInfo.InvariantCulture);
341 if (UriTemplate.PathSegmentVariableNames.Contains (name) ||
342 UriTemplate.QueryValueVariableNames.Contains (name))
343 c.Add (name, parameters [i] != null ? Converter.ConvertValueToString (parameters [i], parameters [i].GetType ()) : null);
345 // FIXME: bind as a message part
347 msgpart = parameters [i];
349 throw new NotImplementedException (String.Format ("More than one parameters including {0} that are not contained in the URI template {1} was found.", p.Name, UriTemplate));
352 ret = Message.CreateMessage (messageVersion, (string) null, msgpart);
354 to = UriTemplate.BindByName (Endpoint.Address.Uri, c);
357 var hp = new HttpRequestMessageProperty ();
358 hp.Method = Info.Method;
360 WebMessageFormat msgfmt = Info.IsResponseFormatSetExplicitly ? Info.ResponseFormat : Behavior.DefaultOutgoingResponseFormat;
361 var contentFormat = ToContentFormat (msgfmt, msgpart);
362 string mediaType = GetMediaTypeString (contentFormat);
363 // FIXME: get encoding from somewhere
364 hp.Headers ["Content-Type"] = mediaType + "; charset=utf-8";
367 if (WebOperationContext.Current != null)
368 WebOperationContext.Current.OutgoingRequest.Apply (hp);
370 // FIXME: set hp.SuppressEntityBody for some cases.
371 ret.Properties.Add (HttpRequestMessageProperty.Name, hp);
373 var wp = new WebBodyFormatMessageProperty (ToContentFormat (Info.IsRequestFormatSetExplicitly ? Info.RequestFormat : Behavior.DefaultOutgoingRequestFormat, null));
374 ret.Properties.Add (WebBodyFormatMessageProperty.Name, wp);
379 public virtual object DeserializeReply (Message message, object [] parameters)
381 if (parameters == null)
382 throw new ArgumentNullException ("parameters");
383 CheckMessageVersion (message.Version);
386 if (OperationContext.Current != null) {
387 // Set response in the context
388 OperationContext.Current.IncomingMessage = message;
393 return null; // empty message, could be returned by HttpReplyChannel.
395 string pname = WebBodyFormatMessageProperty.Name;
396 if (!message.Properties.ContainsKey (pname))
397 throw new SystemException ("INTERNAL ERROR: it expects WebBodyFormatMessageProperty existence");
398 var wp = (WebBodyFormatMessageProperty) message.Properties [pname];
399 var fmt = wp != null ? wp.Format : WebContentFormat.Xml;
401 var md = GetMessageDescription (MessageDirection.Output);
402 var serializer = GetSerializer (wp.Format, IsResponseBodyWrapped, md.Body.ReturnValue);
403 var ret = DeserializeObject (serializer, message, md, IsResponseBodyWrapped, fmt);
409 internal class WrappedBodyWriter : BodyWriter
411 public WrappedBodyWriter (object value, XmlObjectSerializer serializer, string name, string ns, WebContentFormat fmt)
417 this.serializer = serializer;
421 WebContentFormat fmt;
424 XmlObjectSerializer serializer;
427 protected override BodyWriter OnCreateBufferedCopy (int maxBufferSize)
429 return new WrappedBodyWriter (value, serializer, name, ns, fmt);
433 protected override void OnWriteBodyContents (XmlDictionaryWriter writer)
436 case WebContentFormat.Raw:
437 WriteRawContents (writer);
439 case WebContentFormat.Json:
440 WriteJsonBodyContents (writer);
442 case WebContentFormat.Xml:
443 WriteXmlBodyContents (writer);
448 void WriteRawContents (XmlDictionaryWriter writer)
450 throw new NotSupportedException ("Some unsupported sequence of writing operation occured. It is likely a missing feature.");
453 void WriteJsonBodyContents (XmlDictionaryWriter writer)
456 writer.WriteStartElement ("root");
457 writer.WriteAttributeString ("type", "object");
459 WriteObject (serializer, writer, value);
461 writer.WriteEndElement ();
464 void WriteXmlBodyContents (XmlDictionaryWriter writer)
467 writer.WriteStartElement (name, ns);
468 WriteObject (serializer, writer, value);
470 writer.WriteEndElement ();
473 void WriteObject (XmlObjectSerializer serializer, XmlDictionaryWriter writer, object value)
475 if (serializer != null){
477 if (serializer is DataContractJsonSerializer)
478 ((DataContractJsonSerializer) serializer).WriteObject (writer, value);
480 ((DataContractSerializer) serializer).WriteObject (writer, value);
482 serializer.WriteObject (writer, value);
489 internal abstract class WebDispatchMessageFormatter : WebMessageFormatter, IDispatchMessageFormatter
491 protected WebDispatchMessageFormatter (OperationDescription operation, ServiceEndpoint endpoint, QueryStringConverter converter, WebHttpBehavior behavior)
492 : base (operation, endpoint, converter, behavior)
496 public virtual Message SerializeReply (MessageVersion messageVersion, object [] parameters, object result)
499 return SerializeReplyCore (messageVersion, parameters, result);
501 if (WebOperationContext.Current != null)
502 OperationContext.Current.Extensions.Remove (WebOperationContext.Current);
506 Message SerializeReplyCore (MessageVersion messageVersion, object [] parameters, object result)
508 // parameters could be null.
509 // result could be null. For Raw output, it becomes no output.
511 CheckMessageVersion (messageVersion);
513 MessageDescription md = GetMessageDescription (MessageDirection.Output);
516 // var dcob = Operation.Behaviors.Find<DataContractSerializerOperationBehavior> ();
517 // XmlObjectSerializer xos = dcob.CreateSerializer (result.GetType (), md.Body.WrapperName, md.Body.WrapperNamespace, null);
518 // var xsob = Operation.Behaviors.Find<XmlSerializerOperationBehavior> ();
519 // XmlSerializer [] serializers = XmlSerializer.FromMappings (xsob.GetXmlMappings ().ToArray ());
521 WebMessageFormat msgfmt = Info.IsResponseFormatSetExplicitly ? Info.ResponseFormat : Behavior.DefaultOutgoingResponseFormat;
523 XmlObjectSerializer serializer = null;
525 // FIXME: serialize ref/out parameters as well.
527 string name = null, ns = null;
530 case WebMessageFormat.Xml:
531 serializer = GetSerializer (WebContentFormat.Xml, IsResponseBodyWrapped, md.Body.ReturnValue);
532 name = IsResponseBodyWrapped ? md.Body.WrapperName : null;
533 ns = IsResponseBodyWrapped ? md.Body.WrapperNamespace : null;
535 case WebMessageFormat.Json:
536 serializer = GetSerializer (WebContentFormat.Json, IsResponseBodyWrapped, md.Body.ReturnValue);
537 name = IsResponseBodyWrapped ? (BodyName ?? md.Body.ReturnValue.Name) : null;
542 var contentFormat = ToContentFormat (msgfmt, result);
543 string mediaType = GetMediaTypeString (contentFormat);
544 Message ret = contentFormat == WebContentFormat.Raw ? new RawMessage ((Stream) result) : Message.CreateMessage (MessageVersion.None, null, new WrappedBodyWriter (result, serializer, name, ns, contentFormat));
546 // Message properties
548 var hp = new HttpResponseMessageProperty ();
549 // FIXME: get encoding from somewhere
550 hp.Headers ["Content-Type"] = mediaType + "; charset=utf-8";
552 // apply user-customized HTTP results via WebOperationContext.
553 if (WebOperationContext.Current != null) // this formatter must be available outside ServiceHost.
554 WebOperationContext.Current.OutgoingResponse.Apply (hp);
556 // FIXME: fill some properties if required.
557 ret.Properties.Add (HttpResponseMessageProperty.Name, hp);
559 var wp = new WebBodyFormatMessageProperty (contentFormat);
560 ret.Properties.Add (WebBodyFormatMessageProperty.Name, wp);
565 public virtual void DeserializeRequest (Message message, object [] parameters)
567 if (parameters == null)
568 throw new ArgumentNullException ("parameters");
569 CheckMessageVersion (message.Version);
571 IncomingWebRequestContext iwc = null;
572 if (OperationContext.Current != null) {
573 OperationContext.Current.Extensions.Add (new WebOperationContext (OperationContext.Current));
574 iwc = WebOperationContext.Current.IncomingRequest;
577 var wp = message.Properties [WebBodyFormatMessageProperty.Name] as WebBodyFormatMessageProperty;
578 var fmt = wp != null ? wp.Format : WebContentFormat.Xml;
580 Uri to = message.Headers.To;
581 UriTemplateMatch match = to == null ? null : UriTemplate.Match (Endpoint.Address.Uri, to);
582 if (match != null && iwc != null)
583 iwc.UriTemplateMatch = match;
585 MessageDescription md = GetMessageDescription (MessageDirection.Input);
587 for (int i = 0; i < parameters.Length; i++) {
588 var p = md.Body.Parts [i];
589 string name = p.Name.ToUpperInvariant ();
590 if (fmt == WebContentFormat.Raw && p.Type == typeof (Stream)) {
591 var rmsg = (RawMessage) message;
592 parameters [i] = rmsg.Stream;
594 var str = match.BoundVariables [name];
596 parameters [i] = Converter.ConvertStringToValue (str, p.Type);
598 if (info.Method != "GET") {
599 var serializer = GetSerializer (fmt, IsRequestBodyWrapped, p);
600 parameters [i] = DeserializeObject (serializer, message, md, IsRequestBodyWrapped, fmt);
602 // for GET Uri template parameters, there is no <anyType xsi:nil='true' />. So just skip the member.
610 internal class RawMessage : Message
612 public RawMessage (Stream stream)
614 this.Stream = stream;
615 headers = new MessageHeaders (MessageVersion.None);
616 properties = new MessageProperties ();
619 public override MessageVersion Version {
620 get { return MessageVersion.None; }
623 MessageHeaders headers;
625 public override MessageHeaders Headers {
626 get { return headers; }
629 MessageProperties properties;
631 public override MessageProperties Properties {
632 get { return properties; }
635 public Stream Stream { get; private set; }
637 protected override void OnWriteBodyContents (XmlDictionaryWriter writer)
639 writer.WriteString ("-- message body is raw binary --");
642 protected override MessageBuffer OnCreateBufferedCopy (int maxBufferSize)
644 var ms = Stream as MemoryStream;
646 ms = new MemoryStream ();
650 return new RawMessageBuffer (ms.ToArray (), headers, properties);
654 internal class RawMessageBuffer : MessageBuffer
657 MessageHeaders headers;
658 MessageProperties properties;
660 public RawMessageBuffer (byte [] buffer, MessageHeaders headers, MessageProperties properties)
662 this.buffer = buffer;
663 this.headers = new MessageHeaders (headers);
664 this.properties = new MessageProperties (properties);
667 public override int BufferSize {
668 get { return buffer.Length; }
671 public override void Close ()
675 public override Message CreateMessage ()
677 var msg = new RawMessage (new MemoryStream (buffer));
678 msg.Headers.CopyHeadersFrom (headers);
679 msg.Properties.CopyProperties (properties);