Mendapatkan Data Sabun RAW dari Klien Referensi Web yang berjalan di ASP.net

Saya mencoba memecahkan masalah klien layanan web dalam proyek saya saat ini. Saya tidak yakin dengan platform Server Layanan (Kemungkinan besar LAMP). Saya yakin ada kesalahan di pihak mereka karena saya telah menghilangkan potensi masalah dengan klien saya. Klien adalah proxy referensi web jenis ASMX standar yang dibuat secara otomatis dari layanan WSDL.

Yang perlu saya dapatkan adalah Pesan SOAP RAW (Permintaan dan Tanggapan)

Apa cara terbaik untuk masalah ini?

Saya membuat perubahan berikut web.configuntuk mendapatkan Amplop SOAP (Request / Response). Ini akan menampilkan semua informasi SOAP mentah ke file trace.log.

<system.diagnostics>
  <trace autoflush="true"/>
  <sources>
    <source name="System.Net" maxdatasize="1024">
      <listeners>
        <add name="TraceFile"/>
      </listeners>
    </source>
    <source name="System.Net.Sockets" maxdatasize="1024">
      <listeners>
        <add name="TraceFile"/>
      </listeners>
    </source>
  </sources>
  <sharedListeners>
    <add name="TraceFile" type="System.Diagnostics.TextWriterTraceListener"
      initializeData="trace.log"/>
  </sharedListeners>
  <switches>
    <add name="System.Net" value="Verbose"/>
    <add name="System.Net.Sockets" value="Verbose"/>
  </switches>
</system.diagnostics>

Anda dapat menerapkan SoapExtension yang mencatat permintaan dan respons lengkap ke file log. Anda kemudian dapat mengaktifkan SoapExtension di web.config, yang memudahkan untuk mengaktifkan / menonaktifkan untuk tujuan debugging. Berikut adalah contoh yang telah saya temukan dan modifikasi untuk saya gunakan sendiri, dalam kasus saya logging dilakukan oleh log4net tetapi Anda dapat mengganti metode log dengan milik Anda sendiri.

public class SoapLoggerExtension : SoapExtension
{
    private static readonly ILog log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
    private Stream oldStream;
    private Stream newStream;

    public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute)
    {
        return null;
    }

    public override object GetInitializer(Type serviceType)
    {
        return null;
    }

    public override void Initialize(object initializer)
    {

    }

    public override System.IO.Stream ChainStream(System.IO.Stream stream)
    {
        oldStream = stream;
        newStream = new MemoryStream();
        return newStream;
    }

    public override void ProcessMessage(SoapMessage message)
    {

        switch (message.Stage)
        {
            case SoapMessageStage.BeforeSerialize:
                break;
            case SoapMessageStage.AfterSerialize:
                Log(message, "AfterSerialize");
                    CopyStream(newStream, oldStream);
                    newStream.Position = 0;
                break;
                case SoapMessageStage.BeforeDeserialize:
                    CopyStream(oldStream, newStream);
                    Log(message, "BeforeDeserialize");
                break;
            case SoapMessageStage.AfterDeserialize:
                break;
        }
    }

    public void Log(SoapMessage message, string stage)
    {

        newStream.Position = 0;
        string contents = (message is SoapServerMessage) ? "SoapRequest " : "SoapResponse ";
        contents += stage + ";";

        StreamReader reader = new StreamReader(newStream);

        contents += reader.ReadToEnd();

        newStream.Position = 0;

        log.Debug(contents);
    }

    void ReturnStream()
    {
        CopyAndReverse(newStream, oldStream);
    }

    void ReceiveStream()
    {
        CopyAndReverse(newStream, oldStream);
    }

    public void ReverseIncomingStream()
    {
        ReverseStream(newStream);
    }

    public void ReverseOutgoingStream()
    {
        ReverseStream(newStream);
    }

    public void ReverseStream(Stream stream)
    {
        TextReader tr = new StreamReader(stream);
        string str = tr.ReadToEnd();
        char[] data = str.ToCharArray();
        Array.Reverse(data);
        string strReversed = new string(data);

        TextWriter tw = new StreamWriter(stream);
        stream.Position = 0;
        tw.Write(strReversed);
        tw.Flush();
    }
    void CopyAndReverse(Stream from, Stream to)
    {
        TextReader tr = new StreamReader(from);
        TextWriter tw = new StreamWriter(to);

        string str = tr.ReadToEnd();
        char[] data = str.ToCharArray();
        Array.Reverse(data);
        string strReversed = new string(data);
        tw.Write(strReversed);
        tw.Flush();
    }

    private void CopyStream(Stream fromStream, Stream toStream)
    {
        try
        {
            StreamReader sr = new StreamReader(fromStream);
            StreamWriter sw = new StreamWriter(toStream);
            sw.WriteLine(sr.ReadToEnd());
            sw.Flush();
        }
        catch (Exception ex)
        {
            string message = String.Format("CopyStream failed because: {0}", ex.Message);
            log.Error(message, ex);
        }
    }
}

[AttributeUsage(AttributeTargets.Method)]
public class SoapLoggerExtensionAttribute : SoapExtensionAttribute
{
    private int priority = 1; 

    public override int Priority
    {
        get { return priority; }
        set { priority = value; }
    }

    public override System.Type ExtensionType
    {
        get { return typeof (SoapLoggerExtension); }
    }
}

Anda kemudian menambahkan bagian berikut ke web.config Anda di mana YourNamespace dan YourAssembly menunjuk ke kelas dan perakitan SoapExtension Anda:

<webServices>
  <soapExtensionTypes>
    <add type="YourNamespace.SoapLoggerExtension, YourAssembly" 
       priority="1" group="0" />
  </soapExtensionTypes>
</webServices>

Tidak yakin mengapa semua repot dengan web.config atau kelas serializer. Kode di bawah ini berfungsi untuk saya:

XmlSerializer xmlSerializer = new XmlSerializer(myEnvelope.GetType());

using (StringWriter textWriter = new StringWriter())
{
    xmlSerializer.Serialize(textWriter, myEnvelope);
    return textWriter.ToString();
}

Coba Fiddler2 ini akan membiarkan Anda memeriksa permintaan dan respon. Perlu dicatat bahwa Fiddler bekerja dengan lalu lintas http dan https.

Sepertinya solusi Tim Carter tidak berfungsi jika panggilan ke referensi web melontarkan pengecualian. Saya telah mencoba untuk mendapatkan jawaban web mentah sehingga saya dapat memeriksanya (dalam kode) di penangan kesalahan setelah pengecualian dilemparkan. Namun, saya menemukan bahwa log respons yang ditulis oleh metode Tim kosong saat panggilan melontarkan pengecualian. Saya tidak sepenuhnya memahami kodenya, tetapi tampaknya metode Tim memotong proses setelah titik di mana .Net telah membatalkan dan membuang respons web.

Saya bekerja dengan klien yang mengembangkan layanan web secara manual dengan pengkodean tingkat rendah. Pada titik ini, mereka menambahkan pesan kesalahan proses internal mereka sendiri sebagai pesan berformat HTML ke dalam tanggapan SEBELUM tanggapan yang diformat SOAP. Tentu saja, referensi web .Net automagic meledak dalam hal ini. Jika saya bisa mendapatkan respons HTTP mentah setelah pengecualian dilemparkan, saya dapat mencari dan mengurai respons SOAP apa pun dalam respons HTTP campuran yang kembali dan tahu bahwa mereka menerima data saya dengan baik atau tidak.

Nanti ...

Berikut adalah solusi yang berhasil, bahkan setelah eksekusi (perhatikan bahwa saya hanya setelah respons - bisa mendapatkan permintaan juga):

namespace ChuckBevitt
{
    class GetRawResponseSoapExtension : SoapExtension
    {
        //must override these three methods
        public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute)
        {
            return null;
        }
        public override object GetInitializer(Type serviceType)
        {
            return null;
        }
        public override void Initialize(object initializer)
        {
        }

        private bool IsResponse = false;

        public override void ProcessMessage(SoapMessage message)
        {
            //Note that ProcessMessage gets called AFTER ChainStream.
            //That's why I'm looking for AfterSerialize, rather than BeforeDeserialize
            if (message.Stage == SoapMessageStage.AfterSerialize)
                IsResponse = true;
            else
                IsResponse = false;
        }

        public override Stream ChainStream(Stream stream)
        {
            if (IsResponse)
            {
                StreamReader sr = new StreamReader(stream);
                string response = sr.ReadToEnd();
                sr.Close();
                sr.Dispose();

                File.WriteAllText(@"C:\test.txt", response);

                byte[] ResponseBytes = Encoding.ASCII.GetBytes(response);
                MemoryStream ms = new MemoryStream(ResponseBytes);
                return ms;

            }
            else
                return stream;
        }
    }
}

Berikut cara Anda mengkonfigurasinya di file konfigurasi:

<configuration>
     ...
  <system.web>
    <webServices>
      <soapExtensionTypes>
        <add type="ChuckBevitt.GetRawResponseSoapExtension, TestCallWebService"
           priority="1" group="0" />
      </soapExtensionTypes>
    </webServices>
  </system.web>
</configuration>

"TestCallWebService" harus diganti dengan nama pustaka (yang kebetulan adalah nama aplikasi konsol pengujian yang saya gunakan).

Anda benar-benar tidak harus pergi ke ChainStream; Anda seharusnya dapat melakukannya dengan lebih mudah dari ProcessMessage sebagai:

public override void ProcessMessage(SoapMessage message)
{
    if (message.Stage == SoapMessageStage.BeforeDeserialize)
    {
        StreamReader sr = new StreamReader(message.Stream);
        File.WriteAllText(@"C:\test.txt", sr.ReadToEnd());
        message.Stream.Position = 0; //Will blow up 'cause type of stream ("ConnectStream") doesn't alow seek so can't reset position
    }
}

Jika Anda mencari SoapMessage.Stream, ini seharusnya menjadi aliran hanya-baca yang dapat Anda gunakan untuk memeriksa data pada saat ini. Ini adalah penyebab yang kacau jika Anda membaca aliran, pemrosesan selanjutnya membom tanpa kesalahan data yang ditemukan (aliran berada di akhir) dan Anda tidak dapat mengatur ulang posisi ke awal.

Menariknya, jika Anda melakukan kedua metode, cara ChainStream dan ProcessMessage, metode ProcessMessage akan berfungsi karena Anda mengubah jenis aliran dari ConnectStream ke MemoryStream di ChainStream, dan MemoryStream mengizinkan operasi pencarian. (Saya mencoba mentransmisikan ConnectStream ke MemoryStream - tidak diizinkan.)

Jadi ..... Microsoft harus mengizinkan operasi pencarian pada tipe ChainStream atau membuat SoapMessage.Stream benar-benar salinan hanya-baca sebagaimana mestinya. (Tulis anggota kongres Anda, dll ...)

Satu hal lagi. Setelah membuat cara untuk mengambil respons HTTP mentah setelah pengecualian, saya masih belum mendapatkan respons penuh (seperti yang ditentukan oleh sniffer HTTP). Ini karena ketika layanan web pengembangan menambahkan pesan kesalahan HTML ke awal respons, itu tidak menyesuaikan header Panjang Konten, sehingga nilai Panjang Konten kurang dari ukuran isi respons yang sebenarnya. Yang saya dapatkan hanyalah jumlah karakter nilai Panjang Konten - sisanya hilang. Jelas, ketika .Net membaca aliran respons, itu hanya membaca jumlah karakter Panjang Konten dan tidak memungkinkan nilai Panjang Konten mungkin salah. Ini sebagaimana mestinya; tetapi jika nilai header Panjang Konten salah, satu-satunya cara Anda akan mendapatkan seluruh isi respons adalah dengan sniffer HTTP (Saya pengguna HTTP Analyzer darihttp://www.ieinspector.com ).

Saya lebih suka memiliki kerangka kerja yang melakukan pencatatan untuk Anda dengan menghubungkan aliran pencatatan yang mencatat sebagai kerangka proses yang mendasari aliran. Berikut ini tidak sebersih yang saya inginkan, karena Anda tidak dapat memutuskan antara permintaan dan tanggapan dalam metode ChainStream. Berikut cara saya menanganinya. Terima kasih kepada Jon Hanna untuk ide streaming yang utama

public class LoggerSoapExtension : SoapExtension
{
    private static readonly string LOG_DIRECTORY = ConfigurationManager.AppSettings["LOG_DIRECTORY"];
    private LogStream _logger;

    public override object GetInitializer(LogicalMethodInfo methodInfo, SoapExtensionAttribute attribute)
    {
        return null;
    }
    public override object GetInitializer(Type serviceType)
    {
        return null;
    }
    public override void Initialize(object initializer)
    {
    }
    public override System.IO.Stream ChainStream(System.IO.Stream stream)
    {
        _logger = new LogStream(stream);
        return _logger;
    }
    public override void ProcessMessage(SoapMessage message)
    {
        if (LOG_DIRECTORY != null)
        {
            switch (message.Stage)
            {
                case SoapMessageStage.BeforeSerialize:
                    _logger.Type = "request";
                    break;
                case SoapMessageStage.AfterSerialize:
                    break;
                case SoapMessageStage.BeforeDeserialize:
                    _logger.Type = "response";
                    break;
                case SoapMessageStage.AfterDeserialize:
                    break;
            }
        }
    }
    internal class LogStream : Stream
    {
        private Stream _source;
        private Stream _log;
        private bool _logSetup;
        private string _type;

        public LogStream(Stream source)
        {
            _source = source;
        }
        internal string Type
        {
            set { _type = value; }
        }
        private Stream Logger
        {
            get
            {
                if (!_logSetup)
                {
                    if (LOG_DIRECTORY != null)
                    {
                        try
                        {
                            DateTime now = DateTime.Now;
                            string folder = LOG_DIRECTORY + now.ToString("yyyyMMdd");
                            string subfolder = folder + "\\" + now.ToString("HH");
                            string client = System.Web.HttpContext.Current != null && System.Web.HttpContext.Current.Request != null && System.Web.HttpContext.Current.Request.UserHostAddress != null ? System.Web.HttpContext.Current.Request.UserHostAddress : string.Empty;
                            string ticks = now.ToString("yyyyMMdd'T'HHmmss.fffffff");
                            if (!Directory.Exists(folder))
                                Directory.CreateDirectory(folder);
                            if (!Directory.Exists(subfolder))
                                Directory.CreateDirectory(subfolder);
                            _log = new FileStream(new System.Text.StringBuilder(subfolder).Append('\\').Append(client).Append('_').Append(ticks).Append('_').Append(_type).Append(".xml").ToString(), FileMode.Create);
                        }
                        catch
                        {
                            _log = null;
                        }
                    }
                    _logSetup = true;
                }
                return _log;
            }
        }
        public override bool CanRead
        {
            get
            {
                return _source.CanRead;
            }
        }
        public override bool CanSeek
        {
            get
            {
                return _source.CanSeek;
            }
        }

        public override bool CanWrite
        {
            get
            {
                return _source.CanWrite;
            }
        }

        public override long Length
        {
            get
            {
                return _source.Length;
            }
        }

        public override long Position
        {
            get
            {
                return _source.Position;
            }
            set
            {
                _source.Position = value;
            }
        }

        public override void Flush()
        {
            _source.Flush();
            if (Logger != null)
                Logger.Flush();
        }

        public override long Seek(long offset, SeekOrigin origin)
        {
            return _source.Seek(offset, origin);
        }

        public override void SetLength(long value)
        {
            _source.SetLength(value);
        }

        public override int Read(byte[] buffer, int offset, int count)
        {
            count = _source.Read(buffer, offset, count);
            if (Logger != null)
                Logger.Write(buffer, offset, count);
            return count;
        }

        public override void Write(byte[] buffer, int offset, int count)
        {
            _source.Write(buffer, offset, count);
            if (Logger != null)
                Logger.Write(buffer, offset, count);
        }
        public override int ReadByte()
        {
            int ret = _source.ReadByte();
            if (ret != -1 && Logger != null)
                Logger.WriteByte((byte)ret);
            return ret;
        }
        public override void Close()
        {
            _source.Close();
            if (Logger != null)
                Logger.Close();
            base.Close();
        }
        public override int ReadTimeout
        {
            get { return _source.ReadTimeout; }
            set { _source.ReadTimeout = value; }
        }
        public override int WriteTimeout
        {
            get { return _source.WriteTimeout; }
            set { _source.WriteTimeout = value; }
        }
    }
}
[AttributeUsage(AttributeTargets.Method)]
public class LoggerSoapExtensionAttribute : SoapExtensionAttribute
{
    private int priority = 1;
    public override int Priority
    {
        get
        {
            return priority;
        }
        set
        {
            priority = value;
        }
    }
    public override System.Type ExtensionType
    {
        get
        {
            return typeof(LoggerSoapExtension);
        }
    }
}

Berikut adalah versi sederhana dari jawaban teratas. Tambahkan ini ke <configuration>elemen file web.configatau Anda App.config. Ini akan membuat trace.logfile di bin/Debugfolder proyek Anda . Atau, Anda dapat menentukan jalur absolut untuk file log menggunakan initializeDataatribut.

  <system.diagnostics>
    <trace autoflush="true"/>
    <sources>
      <source name="System.Net" maxdatasize="9999" tracemode="protocolonly">
        <listeners>
          <add name="TraceFile" type="System.Diagnostics.TextWriterTraceListener" initializeData="trace.log"/>
        </listeners>
      </source>
    </sources>
    <switches>
      <add name="System.Net" value="Verbose"/>
    </switches>
  </system.diagnostics>

Ini memperingatkan bahwa atribut maxdatasizedan tracemodetidak diperbolehkan, tetapi mereka meningkatkan jumlah data yang dapat dicatat, dan menghindari pencatatan semuanya dalam hex.

Anda belum menentukan bahasa apa yang Anda gunakan tetapi dengan asumsi C # / .NET Anda dapat menggunakan ekstensi SOAP .

Jika tidak, gunakan sniffer seperti Wireshark

Saya menyadari saya cukup terlambat ke pesta, dan karena bahasa tidak benar-benar ditentukan, berikut adalah solusi VB.NET berdasarkan jawaban Bimmerbound, jika ada yang kebetulan menemukan ini dan membutuhkan solusi. Catatan: Anda perlu memiliki referensi ke kelas stringbuilder dalam proyek Anda, jika Anda belum memilikinya.

 Shared Function returnSerializedXML(ByVal obj As Object) As String
    Dim xmlSerializer As New System.Xml.Serialization.XmlSerializer(obj.GetType())
    Dim xmlSb As New StringBuilder
    Using textWriter As New IO.StringWriter(xmlSb)
        xmlSerializer.Serialize(textWriter, obj)
    End Using


    returnSerializedXML = xmlSb.ToString().Replace(vbCrLf, "")

End Function

Cukup panggil fungsinya dan itu akan mengembalikan string dengan serialisasi xml dari objek yang Anda coba kirimkan ke layanan web (secara realistis, ini harus bekerja untuk objek apa pun yang ingin Anda lemparkan juga).

Sebagai catatan tambahan, panggilan replace dalam fungsi sebelum mengembalikan xml adalah untuk menghapus karakter vbCrLf dari output. Milik saya memiliki banyak dari mereka dalam xml yang dihasilkan tetapi ini jelas akan bervariasi tergantung pada apa yang Anda coba untuk serialisasi, dan saya pikir mereka mungkin dilucuti selama objek dikirim ke layanan web.