/// <summary>Get Reader for Response</summary>
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
DisposeReaderStreamSpy();
var reader = SoapHttpClientSpy.GetReaderForMessage(message, bufferSize, CurrentWebRequest, out ReaderStreamSpy);
return(reader);
}
/// <summary>Get Writer for Request</summary>
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
DisposeWriterStreamSpy();
var writer = SoapHttpClientSpy.GetWriterForMessage(message, bufferSize, base.RequestEncoding, CurrentWebRequest, out WriterStreamSpy);
return(writer);
}
/// <summary>
/// Override implementation, append the xmlWriterHookInstance into the GetWriterForMessage method
/// </summary>
/// <param name="message">The SOAP client message</param>
/// <param name="bufferSize">The size of the buffer for the xml writer</param>
/// <returns>An instance of the XmlWriterHook</returns>
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
XmlWriter originalXmlWriterImplementation = base.GetWriterForMessage(message, bufferSize);
this.xmlWriterHookInstance = new XmlWriterInjector(originalXmlWriterImplementation);
return(this.xmlWriterHookInstance);
}
/// <summary>Get Reader for Response</summary>
public static XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize, HttpWebRequest request, out SoapHttpClientSpy readerStreamSpy)
{
readerStreamSpy = new SoapHttpClientSpy(message.Stream, request, true);
Encoding encoding = null;
// Set encoding.
var charset = GetParameter(message.ContentType, "charset");
if (!string.IsNullOrEmpty(charset))
{
encoding = Encoding.GetEncoding(charset);
}
if (encoding == null && !(message.SoapVersion == SoapProtocolVersion.Soap12 && IsApplication(message.ContentType)))
{
encoding = Encoding.ASCII;
}
if (bufferSize < 0x200)
{
bufferSize = 0x200;
}
var reader = encoding == null
? new XmlTextReader(readerStreamSpy)
: new XmlTextReader(new StreamReader(readerStreamSpy, encoding, true, bufferSize));
reader.DtdProcessing = DtdProcessing.Prohibit;
reader.Normalization = true;
reader.XmlResolver = null;
return(reader);
}
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
if (bufferSize < 0x200)
{
bufferSize = 0x200;
}
return(new XmlSpecialNSPrefixTextWriter(new StreamWriter(message.Stream, (base.RequestEncoding != null) ? base.RequestEncoding : new UTF8Encoding(false), bufferSize)));
}
public object [] ReceiveResponse(WebResponse response, SoapClientMessage message, SoapExtension[] extensions)
{
StreamReader sr = new StreamReader(response.GetResponseStream());
String content = sr.ReadToEnd();
System.Console.WriteLine(content);
return(null);
}
void WriteToWire(SoapMessage message)
{
SoapClientMessage clientMessage = message as SoapClientMessage;
m_state = ProgressState.Sending;
InitNotification(clientMessage);
m_applicationStream.Position = 0;
CopyStream(m_applicationStream, m_wireStream);
}
/// <summary>Get Writer for Request</summary>
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
DisposeWriterStreamSpy();
// Dispose reader too in case it was created by previous call.
DisposeReaderStreamSpy();
var writer = SoapHttpClientSpy.GetWriterForMessage(message, bufferSize, base.RequestEncoding, CurrentWebRequest, out WriterStreamSpy);
return(writer);
}
/// <summary>Get Writer for Request</summary>
public static XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize, Encoding requestEncoding, HttpWebRequest request, out SoapHttpClientSpy writerStreamSpy)
{
writerStreamSpy = new SoapHttpClientSpy(message.Stream, request);
if (bufferSize < 0x200)
{
bufferSize = 0x200;
}
return(new XmlTextWriter(new StreamWriter(writerStreamSpy, (requestEncoding != null) ? requestEncoding : new UTF8Encoding(false), bufferSize)));
}
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
// Dispose previous reader stream spy.
DisposeReaderStreamSpy();
readerStreamSpy = new StreamSpy(message.Stream);
xmlReader = new XmlTextReader(readerStreamSpy);
return(xmlReader);
}
void InitNotification(SoapClientMessage clientMessage)
{
if (clientMessage.Client is IProxyProgressExtension)
{
IProxyProgressExtension proxy = clientMessage.Client as IProxyProgressExtension;
m_requestGuid = proxy.RequestGuid;
GetContentLength(clientMessage, proxy);
m_progressCallback = proxy.Callback;
}
}
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
System.Xml.XmlReader aReader = base.GetReaderForMessage(message, bufferSize);
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
doc.Load(aReader);
Response = doc.InnerXml;
return(new XmlNodeReader(doc));
}
/// <summary>
/// Tries to get ITraceable instance
/// </summary>
/// <param name="message"></param>
/// <returns></returns>
private ITraceable GetTraceable(SoapMessage message)
{
SoapClientMessage clientMessage = message as SoapClientMessage;
if (clientMessage != null)
{
return(clientMessage.Client as ITraceable);
}
return(null);
}
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
// Dispose previous writer stream spy.
DisposeWriterStreamSpy();
writerStreamSpy = new StreamSpy(message.Stream);
// XML should always support UTF8.
xmlWriter = new XmlTextWriter(writerStreamSpy, Encoding.UTF8);
return(xmlWriter);
}
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
var reader = new XmlTextReader(new XmlSanitizingStreamReader(message.Stream))
{
ProhibitDtd = true,
Normalization = true,
XmlResolver = null
};
return(reader);
}
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
XmlReader readerForMessage = base.GetReaderForMessage(message, bufferSize);
XmlTextReader xmlTextReader = readerForMessage as XmlTextReader;
if (xmlTextReader != null)
{
xmlTextReader.Normalization = false;
xmlTextReader.DtdProcessing = DtdProcessing.Ignore;
xmlTextReader.XmlResolver = null;
}
return(new AutoDiscoverClientXmlReader(readerForMessage));
}
// Write the contents of the outgoing SOAP message to the log file.
public void WriteOutput(SoapClientMessage message)
{
newStream.Position = 0;
FileStream myFileStream = new FileStream(filename, FileMode.Append, FileAccess.Write);
StreamWriter myStreamWriter = new StreamWriter(myFileStream);
myStreamWriter.WriteLine("=================================== Request at "
+ DateTime.Now);
myStreamWriter.Flush();
Copy(newStream, myFileStream);
myFileStream.Close();
newStream.Position = 0;
Copy(newStream, oldStream);
}
// Write the contents of the incoming SOAP message to the log file.
public void WriteInput(SoapClientMessage message)
{
Copy(oldStream, newStream);
FileStream myFileStream = new FileStream(filename, FileMode.Append, FileAccess.Write);
StreamWriter myStreamWriter = new StreamWriter(myFileStream);
myStreamWriter.WriteLine("---------------------------------- Response at "
+ DateTime.Now);
myStreamWriter.Flush();
newStream.Position = 0;
Copy(newStream, myFileStream);
myFileStream.Close();
newStream.Position = 0;
}
/// <summary>
/// Store the size of data to be processed.
/// The way to obtain the size differs depending on whether we are sending or receiving data.
/// * When we are reading from the web server, the web server reports the size in through the web response.
/// * When we are sending data our stream has the size to be sent.
/// </summary>
/// <param name="clientMessage"></param>
/// <param name="proxy"></param>
void GetContentLength(SoapClientMessage clientMessage, IProxyProgressExtension proxy)
{
if (clientMessage.Stage == SoapMessageStage.BeforeDeserialize)
{
m_totalSize = proxy.ResponseContentLength;
}
else if (clientMessage.Stage == SoapMessageStage.AfterSerialize)
{
m_totalSize = clientMessage.Stream.Length;
}
else
{
m_totalSize = TotalSizeUnknown;
}
}
void ReadFromWire(SoapMessage message)
{
SoapClientMessage clientMessage = message as SoapClientMessage;
m_state = ProgressState.Retrieving;
InitNotification(clientMessage);
try
{
CopyStream(m_wireStream, m_applicationStream);
}
finally
{
m_applicationStream.Position = 0;
}
}
public void LogSoapRequestAfterSerialize(SoapClientMessage message)
{
newStream.Position = 0;
var requestStr = new StreamReader(newStream, Encoding.UTF8).ReadToEnd();
try
{
requestStr = XmlHelper.FormatXML(requestStr);
}
catch { }
logger.Info(string.Format("SoapRequestAfterSerialize of the {2}:{1}{0}", requestStr, Environment.NewLine, message.MethodInfo.Name));
newStream.Position = 0;
Copy(newStream, oldStream);
}
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
if (this.Action != null)
{
message.Headers.Add(this.Action);
}
if (this.To != null)
{
message.Headers.Add(this.To);
}
if (this.OpenAsAdminOrSystemService != null)
{
this.OpenAsAdminOrSystemService.BudgetType = 1;
this.OpenAsAdminOrSystemService.BudgetTypeSpecified = true;
message.Headers.Add(this.OpenAsAdminOrSystemService);
}
return(base.GetWriterForMessage(message, bufferSize));
}
public override void ProcessMessage(SoapMessage message)
{
switch (message.Stage)
{
case SoapMessageStage.BeforeSerialize:
break;
case SoapMessageStage.AfterSerialize:
newStream.Position = 0;
Copy(newStream, oldStream);
break;
case SoapMessageStage.BeforeDeserialize:
newStream.Position = 0;
Copy(oldStream, newStream);
newStream.Position = 0;
//TextReader reader = new StreamReader(newStream);
XElement xml = XElement.Load(newStream);
if (message is SoapClientMessage)
{
SoapClientMessage clientMessage = (SoapClientMessage)message;
if (clientMessage.Client is SoapService50Ex)
{
SoapService50Ex client = (SoapService50Ex)clientMessage.Client;
XNamespace soap = "http://schemas.xmlsoap.org/soap/envelope/";
client.headerInfo = xml.Element(soap + "Header").Element("equella");
}
}
newStream.Position = 0;
break;
case SoapMessageStage.AfterDeserialize:
break;
}
}
/// <summary>
/// 客户端的调用时序是：
/// BeforeSerilize
/// AfterSerilize
/// BeforeDeserialize
/// AfterDeserialize
/// </summary>
/// <param name="message"></param>
public override void ProcessMessage(SoapMessage message)
{
if (message is SoapClientMessage)
{
SoapClientMessage clientMessage = (SoapClientMessage)message;
if (clientMessage.Stage == SoapMessageStage.BeforeSerialize)
{
ServiceBrokerSoapHeader header = new ServiceBrokerSoapHeader();
T broker = GetSerivceBrokerContext();
header.UseServerCache = broker.UseServerCache;
header.TimePoint = broker.TimePoint;
broker.ConnectionMappings.ForEach(mapping =>
header.ConnectionMappings.Add(new SoapHeaderConnectionMappingItem(mapping.Key, mapping.Value)));
broker.Context.ForEach(kp => header.Context.Add(new SoapHeaderContextItem(kp.Key, kp.Value)));
clientMessage.Headers.Add(header);
}
}
}
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
soapClientMessage = message;
responseXmlReader = base.GetReaderForMessage(soapClientMessage, bufferSize);
return(responseXmlReader);
}
// Write the contents of the outgoing SOAP message to the log file.
public void WriteOutput(SoapClientMessage message)
{
// <Snippet2>
// <Snippet3>
// <Snippet4>
// <Snippet5>
// <Snippet6>
newStream.Position = 0;
FileStream myFileStream = new FileStream(filename, FileMode.Append,
FileAccess.Write);
StreamWriter myStreamWriter = new StreamWriter(myFileStream);
myStreamWriter.WriteLine(
"================================== Request at "
+ DateTime.Now);
// Print to the log file the request header field for SoapAction header.
myStreamWriter.WriteLine("The SoapAction Http request header field is: ");
myStreamWriter.WriteLine("\t" + message.Action);
// Print to the log file the type of the client that invoked
// the XML Web service method.
myStreamWriter.WriteLine("The type of the client is: ");
if ((message.Client.GetType()).Equals(typeof(MathSvc)))
{
myStreamWriter.WriteLine("\tMathSvc");
}
// Print to the log file the method invoked by the client.
myStreamWriter.WriteLine(
"The method that has been invoked by the client is:");
myStreamWriter.WriteLine("\t" + message.MethodInfo.Name);
// Print to the log file if the method invoked is OneWay.
if (message.OneWay)
{
myStreamWriter.WriteLine(
"The client doesn't wait for the server to finish processing");
}
else
{
myStreamWriter.WriteLine(
"The client waits for the server to finish processing");
}
// Print to the log file the URL of the site that provides
// implementation of the method.
myStreamWriter.WriteLine(
"The URL of the XML Web service method that has been requested is: ");
myStreamWriter.WriteLine("\t" + message.Url);
myStreamWriter.WriteLine("The contents of the SOAP envelope are: ");
myStreamWriter.Flush();
// Copy the contents of one stream to another.
Copy(newStream, myFileStream);
myFileStream.Close();
newStream.Position = 0;
// Copy the contents of one stream to another.
Copy(newStream, oldStream);
// </Snippet6>
// </Snippet5>
// </Snippet4>
// </Snippet3>
// </Snippet2>
}
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
writer = new XmlWriterListener(base.GetWriterForMessage(message, bufferSize));
return(writer);
}
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
string xmlMatchSchema = "<?xml";
string xmlSchema = "<?xml version=\"1.0\" encoding=\"utf-8\" ?>";
int schemaLength = Encoding.UTF8.GetByteCount(xmlMatchSchema);
Stream messageStream = message.Stream;
byte[] schemaArray = new byte[schemaLength];
if (messageStream.CanSeek)
{
long originalPosition = messageStream.Position;
messageStream.Seek(0, SeekOrigin.Begin);
int bytesRead = messageStream.Read(schemaArray, 0, schemaArray.Length);
string readSchema = Encoding.UTF8.GetString(schemaArray);
if (readSchema.ToLowerInvariant() != xmlMatchSchema.ToLowerInvariant())
{
messageStream.Seek(0, SeekOrigin.Begin);
byte[] content = new byte[messageStream.Length];
messageStream.Read(content, 0, content.Length);
messageStream.Seek(0, SeekOrigin.Begin);
string strContent = Encoding.UTF8.GetString(content);
MemoryStream newMemStream = new MemoryStream();
newMemStream.Seek(0, SeekOrigin.Begin);
newMemStream.Write(Encoding.UTF8.GetBytes(xmlSchema), 0, Encoding.UTF8.GetByteCount(xmlSchema));
newMemStream.Write(content, 0, content.Length);
newMemStream.Seek(0, SeekOrigin.Begin);
XmlTextReader reader = null;
Encoding encoding = (message.SoapVersion == SoapProtocolVersion.Soap12) ? RequestResponseUtils.GetEncoding2(message.ContentType) : RequestResponseUtils.GetEncoding(message.ContentType);
if (bufferSize < 0x200)
{
bufferSize = 0x200;
}
if (encoding != null)
{
reader = new XmlTextReader(new StreamReader(message.Stream, encoding, true, bufferSize));
}
else
{
reader = new XmlTextReader(message.Stream);
}
reader.ProhibitDtd = true;
reader.Normalization = true;
reader.XmlResolver = null;
return(reader);
}
else
{
messageStream.Seek(originalPosition, SeekOrigin.Begin);
return(base.GetReaderForMessage(message, bufferSize));
}
}
else
{
Trace.WriteLineIf(Settings.TraceSwitch.TraceWarning, "Unseekable stream returned with message, maybe the connection has terminated. Stream type: " + message.Stream.GetType().ToString());
return(base.GetReaderForMessage(message, bufferSize));
}
}
/// <summary>Get Writer for Request</summary>
protected override XmlWriter GetWriterForMessage(SoapClientMessage message, int bufferSize)
{
DisposeWriterStreamSpy();
return(StreamSpy.GetWriterForMessage(message, bufferSize, base.RequestEncoding, out WriterStreamSpy));
}
/// <summary>Get Reader for Response</summary>
protected override XmlReader GetReaderForMessage(SoapClientMessage message, int bufferSize)
{
DisposeReaderStreamSpy();
return(StreamSpy.GetReaderForMessage(message, bufferSize, out ReaderStreamSpy));
}
