Pobieranie danych mydła RAW z klienta odniesienia sieci Web działającego w ASP.net

Próbuję rozwiązać problem z klientem usługi sieciowej w moim bieżącym projekcie. Nie jestem pewien platformy serwera usług (najprawdopodobniej LAMP). Uważam, że po ich stronie ogrodzenia jest błąd, ponieważ wyeliminowałem potencjalne problemy z moim klientem. Klient jest standardowym proxy odwołań do sieci WWW typu ASMX generowanym automatycznie z usługi WSDL.

To, do czego potrzebuję, to wiadomości RAW SOAP (żądanie i odpowiedzi)

Jaki jest najlepszy sposób, aby to zrobić?

Wprowadziłem następujące zmiany w web.configcelu uzyskania koperty SOAP (żądanie / odpowiedź). Spowoduje to wyświetlenie wszystkich surowych informacji SOAP do pliku 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>

Można zaimplementować SoapExtension, który rejestruje pełne żądanie i odpowiedź w pliku dziennika. Następnie możesz włączyć rozszerzenie SoapExtension w pliku web.config, co ułatwia włączanie / wyłączanie do celów debugowania. Oto przykład, który znalazłem i zmodyfikowałem na własny użytek, w moim przypadku logowanie zostało wykonane przez log4net, ale możesz zastąpić metody dziennika własnymi.

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); }
    }
}

Następnie dodaj następującą sekcję do pliku web.config, gdzie YourNamespace i YourAssembly wskazują klasę i zestaw Twojego SoapExtension:

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

Nie wiem, po co tyle zamieszania z web.config lub klasą serializatora. Poniższy kod zadziałał dla mnie:

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

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

Wypróbuj Fiddler2 , który pozwoli ci sprawdzić żądania i odpowiedzi. Warto zauważyć, że Fiddler działa zarówno z ruchem http, jak i https.

Wygląda na to, że rozwiązanie Tima Cartera nie działa, jeśli wywołanie odwołania internetowego zgłasza wyjątek. Próbowałem uzyskać odpowiedź nieprzetworzoną, aby móc ją zbadać (w kodzie) w programie obsługi błędów po wyrzuceniu wyjątku. Jednak stwierdzam, że dziennik odpowiedzi napisany przez metodę Tima jest pusty, gdy wywołanie zgłasza wyjątek. Nie rozumiem do końca kodu, ale wydaje się, że metoda Tima przerywa proces po punkcie, w którym .Net już unieważnił i odrzucił odpowiedź sieciową.

Pracuję z klientem, który ręcznie opracowuje usługę internetową z kodowaniem niskiego poziomu. W tym momencie dodają swoje własne wewnętrzne komunikaty o błędach procesu jako komunikaty w formacie HTML do odpowiedzi PRZED odpowiedzią w formacie SOAP. Oczywiście, pojawia się tutaj odniesienie do automagic .Net. Gdybym mógł uzyskać nieprzetworzoną odpowiedź HTTP po wyrzuceniu wyjątku, mógłbym poszukać i przeanalizować każdą odpowiedź SOAP w mieszanej zwrotnej odpowiedzi HTTP i wiedzieć, że otrzymali moje dane w porządku, czy nie.

Później ...

Oto rozwiązanie, które działa, nawet po wykonaniu (zwróć uwagę, że jestem dopiero po odpowiedzi - również mogę uzyskać żądanie):

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;
        }
    }
}

Oto jak możesz to skonfigurować w pliku konfiguracyjnym:

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

„TestCallWebService” należy zastąpić nazwą biblioteki (była to nazwa aplikacji konsoli testowej, w której pracowałem).

Naprawdę nie powinieneś iść do ChainStream; powinieneś być w stanie zrobić to prościej z ProcessMessage, ponieważ:

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
    }
}

Jeśli spojrzysz na SoapMessage.Stream, powinien to być strumień tylko do odczytu, którego możesz użyć do sprawdzenia danych w tym momencie. Jest to błąd, ponieważ jeśli odczytujesz strumień, kolejne przetwarzanie bomb bez błędów znalezionych danych (strumień był na końcu) i nie możesz zresetować pozycji do początku.

Co ciekawe, jeśli wykonasz obie metody, ChainStream i ProcessMessage, metoda ProcessMessage będzie działać, ponieważ zmieniono typ strumienia z ConnectStream na MemoryStream w ChainStream, a MemoryStream zezwala na operacje wyszukiwania. (Próbowałem rzucić ConnectStream na MemoryStream - nie było dozwolone.)

Więc ..... Microsoft powinien albo zezwolić na operacje wyszukiwania na typie ChainStream, albo uczynić SoapMessage.Stream prawdziwie kopią tylko do odczytu, tak jak powinna. (Napisz kongresmana itp.)

Jeszcze jeden punkt. Po utworzeniu sposobu na odzyskanie nieprzetworzonej odpowiedzi HTTP po wyjątku nadal nie otrzymałem pełnej odpowiedzi (określonej przez sniffer HTTP). Dzieje się tak, ponieważ gdy programistyczna usługa sieciowa dodawała komunikaty o błędach HTML na początku odpowiedzi, nie dostosowywała nagłówka Content-Length, więc wartość Content-Length była mniejsza niż rozmiar rzeczywistej treści odpowiedzi. Wszystko, co otrzymałem, to liczba znaków wartości Content-Length - reszty brakowało. Oczywiście, kiedy .Net czyta strumień odpowiedzi, po prostu czyta liczbę znaków Content-Length i nie pozwala na to, aby wartość Content-Length była błędna. Tak powinno być; ale jeśli wartość nagłówka Content-Length jest nieprawidłowa, jedynym sposobem, w jaki kiedykolwiek otrzymasz całą treść odpowiedzi, jest sniffer HTTP (używam analizatora HTTP zhttp://www.ieinspector.com ).

Wolałbym, aby platforma wykonywała rejestrowanie za Ciebie, przechodząc do strumienia rejestrowania, który rejestruje, gdy struktura przetwarza ten strumień. Poniższe nie są tak przejrzyste, jak bym chciał, ponieważ nie możesz zdecydować między żądaniem a odpowiedzią w metodzie ChainStream. Oto jak sobie z tym radzę. Z podziękowaniami dla Jona Hanny za nadrzędny pomysł na transmisję

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);
        }
    }
}

Oto uproszczona wersja najlepszej odpowiedzi. Dodaj to do <configuration>elementu swojego web.configlub App.configpliku. Utworzy trace.logplik w bin/Debugfolderze twojego projektu . Lub możesz określić bezwzględną ścieżkę do pliku dziennika przy użyciu initializeDataatrybutu.

  <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>

Ostrzega, że atrybuty maxdatasizei tracemodenie są dozwolone, ale zwiększają ilość danych, które mogą być rejestrowane, i unikają rejestrowania wszystkiego w postaci szesnastkowej.

Nie określiłeś języka, którego używasz, ale zakładając C # / .NET, możesz użyć rozszerzeń SOAP .

W przeciwnym razie użyj sniffera, takiego jak Wireshark

Zdaję sobie sprawę, że jestem dość spóźniony na imprezę, a ponieważ język nie został określony, oto rozwiązanie VB.NET oparte na odpowiedzi Bimmerbound, na wypadek gdyby ktoś się na to natknął i potrzebował rozwiązania. Uwaga: musisz mieć odniesienie do klasy stringbuilder w swoim projekcie, jeśli jeszcze tego nie zrobiłeś.

 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

Po prostu wywołaj funkcję, a zwróci ona ciąg znaków z zserializowanym kodem XML obiektu, który próbujesz przekazać do usługi sieciowej (realistycznie powinno to działać również dla każdego obiektu, który chcesz do niego rzucić).

Na marginesie, wywołanie replace w funkcji przed zwróceniem xml ma na celu usunięcie znaków vbCrLf z wyniku. Mój miał ich kilka w wygenerowanym pliku XML, ale oczywiście będzie się to różnić w zależności od tego, co próbujesz serializować i myślę, że mogą zostać usunięte podczas wysyłania obiektu do usługi internetowej.