public virtual void WriteSoapMessage(IRequest req, System.ServiceModel.Channels.Message message, Stream outputStream)
        {
            try
            {
                using (var writer = XmlWriter.Create(outputStream, Config.XmlWriterSettings))
                {
                    message.WriteMessage(writer);
                }
            }
            catch (Exception ex)
            {
                var response = OnServiceException(req, req.Dto, ex);
                if (response == null || !outputStream.CanSeek)
                    return;

                outputStream.Position = 0;
                try
                {
                    message = SoapHandler.CreateResponseMessage(response, message.Version, req.Dto.GetType(),
                        req.GetSoapMessage().Headers.Action == null);
                    using (var writer = XmlWriter.Create(outputStream, Config.XmlWriterSettings))
                    {
                        message.WriteMessage(writer);
                    }
                }
                catch { }
            }
            finally
            {
                HostContext.CompleteRequest(req);
            }
        }
 private void WriteMessage(System.ServiceModel.Channels.Message message) {
   using (var stringWriter = new StringWriter()) {
     using (var xmlWriter = new XmlTextWriter(stringWriter)) {
       xmlWriter.Formatting = Formatting.Indented;
       message.WriteMessage(xmlWriter);
       Output.SetText(stringWriter.ToString());
     }
   }
 }
        /// <summary>
        /// Convert a Message to XMLDocument
        /// </summary>
        /// <param name="msg">Message to convert</param>
        /// <returns></returns>
        public static XmlDocument MessageToXDom(System.ServiceModel.Channels.Message msg)
        {
            XmlDocument doc = new XmlDocument();
            MemoryStream ms = new MemoryStream();
            XmlWriter writer = XmlWriter.Create(ms);

            msg.WriteMessage(writer);

            writer.Flush();
            ms.Position = 0;

            doc.Load(ms);

            return doc;
        }
        public object BeforeSendRequest(ref System.ServiceModel.Channels.Message request, System.ServiceModel.IClientChannel channel)
        {
            request.Properties.Add("UserName", _user.Username);

            Console.WriteLine("Message:");
            Console.WriteLine(request);
            Console.WriteLine();
            MemoryStream ms = new MemoryStream();
            XmlWriter writer = XmlWriter.Create(ms);
            request.WriteMessage(writer); // the message was consumed here
            writer.Flush();
            ms.Position = 0;
            XDocument xmlDoc = XDocument.Load(ms);
            this.ChangeMessage(xmlDoc);

            //Now recreating the message
            ms = new MemoryStream();
            xmlDoc.Save(ms);
            ms.Position = 0;
            XmlReader reader = XmlReader.Create(ms);
            Message newMessage = Message.CreateMessage(reader, int.MaxValue, request.Version);
            newMessage.Properties.CopyProperties(request.Properties);
            //newMessage.Properties.Add("UserName", _user.Username);
            request = newMessage;

            return null;

            //// Prepare the request message copy to be modified
            //MessageBuffer buffer = request.CreateBufferedCopy(Int32.MaxValue);
            //request = buffer.CreateMessage();

            //ServiceHeader customData = new ServiceHeader();

            //customData.KerberosID = "KerberosID";
            //customData.SiteminderToken = "SiteminderToken";

            //CustomHeader header = new CustomHeader(customData);

            //// Add the custom header to the request.
            //request.Headers.Add(header);

            //return null;
        }
        /// <summary>
        /// This will parse the response received from the service and remove all empty elements from it
        /// </summary>
        public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
        {
            MemoryStream memoryStream = new MemoryStream();
            XmlWriter xmlWriter = XmlWriter.Create(memoryStream);
            reply.WriteMessage(xmlWriter);
            xmlWriter.Flush();
            memoryStream.Position = 0;
            XmlDocument xmlDocument = new XmlDocument();
            xmlDocument.Load(memoryStream);

            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(xmlDocument.NameTable);
            xmlNamespaceManager.AddNamespace("env", "http://schemas.xmlsoap.org/soap/envelope/");
            XmlNode header = xmlDocument.SelectSingleNode("//env:Header", xmlNamespaceManager);
            if (header != null)
            {
                header.ParentNode.RemoveChild(header);
            }

            XmlNodeList nodes = xmlDocument.SelectNodes("//node()");
            foreach (XmlNode node in nodes)
            {
                if (node.NodeType == XmlNodeType.Element && node.ChildNodes.Count == 0 && node.InnerXml == "" && node.Attributes.Count == 0)
                {
                    node.ParentNode.RemoveChild(node);
                }
            }
            memoryStream = new MemoryStream();
            xmlDocument.Save(memoryStream);
            memoryStream.Position = 0;
            XmlReader xmlReader = XmlReader.Create(memoryStream);
            System.ServiceModel.Channels.Message newMessage = System.ServiceModel.Channels.Message.CreateMessage(xmlReader, int.MaxValue, reply.Version);
            newMessage.Headers.CopyHeadersFrom(reply.Headers);
            newMessage.Properties.CopyProperties(reply.Properties);

            //Logging processed response
            MessageBuffer buffer = newMessage.CreateBufferedCopy(Int32.MaxValue);
            newMessage = buffer.CreateMessage();
            LogRequestResponse(buffer, "Opportunity Service Response");

            reply = newMessage;
        }
 public virtual void WriteSoapMessage(IRequest req, System.ServiceModel.Channels.Message message, Stream outputStream)
 {
     using (var writer = XmlWriter.Create(outputStream, Config.XmlWriterSettings))
     {
         message.WriteMessage(writer);
     }
 }
Beispiel #7
0
        public System.ServiceModel.Channels.Message ProcessInboundMessage(System.ServiceModel.Channels.Message m)
        {

            #if DEBUG
            Trace.TraceInformation("Received message on transport...");
            #endif

            if (ListenConnector == null && OperationContext.Current.Host is WcfServiceHost)
                ListenConnector = (OperationContext.Current.Host as WcfServiceHost).ConnectorHost;

            if (ListenConnector != null) // In process
            {
                // Is this channel one way or two way?
                if (!(OperationContext.Current.Channel is IOutputChannel)) // Input only
                    return null;

                #if DEBUG
                Trace.TraceInformation("Message handoff to WcfServerConnector completed");
                #endif

                WcfSendResult processResult = ListenConnector.ProcessMessage(m);
                Message retVal = null;

                // There is an error, so the return value must be a fault!
                if (processResult == null || processResult.Code != ResultCode.Accepted && processResult.Code != ResultCode.AcceptedNonConformant)
                {
                    // Web based context?
                    if (WebOperationContext.Current != null)
                    {
                        WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.InternalServerError;
                        WebOperationContext.Current.OutgoingResponse.StatusDescription = "Internal Server Error";
                    }

                    List<String> details = new List<string>();
                    if (processResult != null)
                    {
                        details = new List<String>();
                        foreach(var dtl in processResult.Details)
                            details.Add(dtl.Message); // Append details
                    }

                    if (processResult == null)
                        retVal = Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode(processResult.Code.ToString(), "http://marc.mohawkcollege.ca/hi"), new FaultReason("The receiver has constructed an invalid response that cannot be sent to the sender"), details), m.Headers.Action);
                    else
                        retVal = Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateSenderFaultCode("EPIC", "http://marc.mohawkcollege.ca/hi"), new FaultReason("Catastrophic failure occurred in the WcfServer send pipeline. This usually occurs when the connector does not receive a message in the allocated amount of time"), details), m.Headers.Action);
                }
                else
                {
                    retVal = processResult.Message;

                    if (processResult.Headers != null)
                    {
                        retVal.Headers.Clear();
                        retVal.Headers.CopyHeadersFrom(processResult.Headers);
                    }
                }
                                
                #if DEBUG
                Trace.TraceInformation("Message sent to client");
                #endif

                return retVal;
            }
            else
            {
                // Get settings
                if(settings == null) settings = System.Web.Configuration.WebConfigurationManager.GetSection("marc.everest.connectors.wcf") as MARC.Everest.Connectors.WCF.Configuration.ConfigurationSection;

                // Now format the message and pass it on ...
                MemoryStream ms = new MemoryStream();
                System.Xml.XmlWriter xw = System.Xml.XmlWriter.Create(ms); // Write to message memory stream for classification matching
                m.WriteMessage(xw);
                xw.Flush(); // Flush the Xml Writer

                ms.Seek(0, SeekOrigin.Begin);                  // Seek to start
                XPathDocument xpd = new XPathDocument(ms); // load xpath document
                XPathNavigator xpn = xpd.CreateNavigator();

                IMessageReceiver receiver = null; // The receiver to use

                // Determine the receiver
                foreach (KeyValuePair<String, IMessageReceiver> kv in settings.Receiver)
                    if (xpn.SelectSingleNode(kv.Key) != null)
                    {
                        receiver = kv.Value;
                        break;
                    }

                // Was a receiver found?
                if (receiver == null)
                { 
                    // Create a not implemented exception
                    if(WebOperationContext.Current != null)
                        WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.NotImplemented;
                    return Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateSenderFaultCode(
                        "NotImplemented", "http://marc.mohawkcollege.ca/hi"), new FaultReason("No receiver understands the request message.")),
                        m.Headers.Action);
                }

                // Create a streams for deserialization
                ms = new MemoryStream();
                XmlWriterSettings xws = new XmlWriterSettings();
                xws.Indent = true;
                xw = XmlWriter.Create(ms, xws); 

                // Deserialize body
                WcfReceiveResult rcv = new WcfReceiveResult();
                try
                {
                    // Because of classification, we need to process this in a wierd way, 
                    // Basically the formatter will classify the message based on the root element name
                    // it receives. Because a SOAP message's root isn't what we really want to process, 
                    // the first child node under the 'body' must be passed to the xml writer
                    xpn.SelectSingleNode("//*[local-name() = 'Body']/child::node()").WriteSubtree(xw);
                    xw.Flush();
                    ms.Seek(0, SeekOrigin.Begin);

                    var serResult = settings.Formatter.Parse(ms);
                    rcv.Structure = serResult.Structure;
                    rcv.Details = serResult.Details;
                    if (rcv.Details.Count() == 0)
                        rcv.Code = ResultCode.Accepted;
                    else
                        rcv.Code = ResultCode.AcceptedNonConformant;
                }
                catch (Exception e)
                {
                    rcv.Code = ResultCode.Error;
                    rcv.Details = new IResultDetail[] { new ResultDetail(ResultDetailType.Error, e.Message, e) };
                }

                // Process on the receiver
                IGraphable obj = receiver.MessageReceived(rcv.Structure, rcv.Code, rcv.Details);

                // Graph this back
                XmlSerializerSurrogate surrogate = new XmlSerializerSurrogate((IXmlStructureFormatter)settings.Formatter);

                // Serialize the response
                Message result = Message.CreateMessage(m.Version, m.Headers.Action, obj, surrogate);
                
                // Validate
                surrogate.WriteObject(new MemoryStream(), obj);

                // Surrogate result code is acceptable?
                if (surrogate.ResultCode != ResultCode.Accepted && surrogate.ResultCode != ResultCode.AcceptedNonConformant)
                {
                    if (WebOperationContext.Current != null)
                    {
                        WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.InternalServerError;
                        WebOperationContext.Current.OutgoingResponse.StatusDescription = "Internal Server Error";
                    }

                    List<string> details = new List<String>();
                    foreach(var itm in surrogate.Details)
                        details.Add(itm.Message); // Append details
                    return Message.CreateMessage(m.Version, MessageFault.CreateFault(FaultCode.CreateReceiverFaultCode(surrogate.ResultCode.ToString(), "http://marc.mohawkcollege.ca/hi"), new FaultReason("The receiver has constructed an invalid response that cannot be returned to the sender"), details), m.Headers.Action);
                }
                else
                    return result;

            }
        }
            public void AfterReceiveReply(ref System.ServiceModel.Channels.Message reply, object correlationState)
            {
                if (correlationState != null
                    && String.Equals(correlationState, _correlationState)
                    && !reply.ToString().Contains("<soapenv:Fault>"))
                {
                    var memoryStream = new MemoryStream();
                    var writer = XmlWriter.Create(memoryStream);
                    reply.WriteMessage(writer);
                    writer.Flush();

                    memoryStream.Position = 0;
                    var doc = new XmlDocument();
                    doc.Load(memoryStream);

                    UpdateMessage(doc);

                    memoryStream.SetLength(0);
                    writer = XmlWriter.Create(memoryStream);
                    doc.WriteTo(writer);
                    writer.Flush();

                    memoryStream.Position = 0;
                    var reader = XmlReader.Create(memoryStream);
                    reply = Message.CreateMessage(reader, int.MaxValue, reply.Version);
                }
            }