Il servizio remoto .NET sembra arrestarsi in modo anomalo e smette di rispondere ai client.

Question

Possiedo un servizio .NET Remoting che funziona bene la maggior parte del tempo. Se si verifica un'eccezione o un errore, registra l'errore in un file ma continua a essere eseguito.

Tuttavia, circa una volta ogni due settimane il servizio smette di rispondere ai clienti, che provoca l'appication cliente a schiantarsi con un SocketException con il seguente messaggio:

A connection attempt failed because the connected party did not properly respond after a period of time, or established connection failed because connected host has failed to respond 

Nessuna eccezione o traccia dello stack è scritto al nostro registro file, quindi non riesco a capire dove il servizio si sta bloccando, il che mi porta a credere che sia fuori dal mio codice che sta fallendo. Quali ulteriori passaggi posso prendere per capire la causa principale di questo crash? Immagino che scriva qualcosa su un EventLog da qualche parte, ma non ho molta familiarità con il sistema di registrazione degli eventi di Windows, quindi non sono esattamente sicuro su dove cercare.

Grazie in anticipo per qualsiasi tipo di assistenza.

MODIFICA: Ha dimenticato di menzionare, l'arresto o il riavvio del servizio non fa nulla, il servizio non risponde mai. Devo interrompere manualmente il processo prima di poter riavviare il servizio.

EDIT 2:

public class ClientInfoServerSinkProvider : 
     IServerChannelSinkProvider 
    { 
     private IServerChannelSinkProvider _nextProvider = null; 

     public ClientInfoServerSinkProvider() 
     { 
     } 

     public ClientInfoServerSinkProvider(
       IDictionary properties, 
       ICollection providerData) 
     { 
     } 

     public IServerChannelSinkProvider Next 
     { 
     get { return _nextProvider; } 
     set { _nextProvider = value; } 
     } 

     public IServerChannelSink CreateSink(IChannelReceiver channel) 
     { 
     IServerChannelSink nextSink = null; 

     if (_nextProvider != null) 
     { 
      nextSink = _nextProvider.CreateSink(channel); 
     } 
     return new ClientIPServerSink(nextSink); 
     } 

     public void GetChannelData(IChannelDataStore channelData) 
     { 
     } 
    } 

    public class ClientIPServerSink : 
     BaseChannelObjectWithProperties, 
     IServerChannelSink, 
     IChannelSinkBase 
    { 

     private IServerChannelSink _nextSink; 

     public ClientIPServerSink(IServerChannelSink next) 
     { 
     _nextSink = next; 
     } 

     public IServerChannelSink NextChannelSink 
     { 
     get { return _nextSink; } 
     set { _nextSink = value; } 
     } 

     public void AsyncProcessResponse(
       IServerResponseChannelSinkStack sinkStack, 
       Object state, 
       IMessage message, 
       ITransportHeaders headers, 
       Stream stream) 
     { 
     IPAddress ip = headers[CommonTransportKeys.IPAddress] as IPAddress; 
     CallContext.SetData("ClientIPAddress", ip); 
     sinkStack.AsyncProcessResponse(message, headers, stream); 
     } 

     public Stream GetResponseStream(
       IServerResponseChannelSinkStack sinkStack, 
       Object state, 
       IMessage message, 
       ITransportHeaders headers) 
     { 
     return null; 
     } 

     public ServerProcessing ProcessMessage(
       IServerChannelSinkStack sinkStack, 
       IMessage requestMsg, 
       ITransportHeaders requestHeaders, 
       Stream requestStream, 
       out IMessage responseMsg, 
       out ITransportHeaders responseHeaders, 
       out Stream responseStream) 
     { 
     if (_nextSink != null) 
     { 
      IPAddress ip = 
        requestHeaders[CommonTransportKeys.IPAddress] as IPAddress; 

      CallContext.SetData("ClientIPAddress", ip); 
      ServerProcessing spres = _nextSink.ProcessMessage(
        sinkStack, 
        requestMsg, 
        requestHeaders, 
        requestStream, 
        out responseMsg, 
        out responseHeaders, 
        out responseStream); 
      return spres; 
     } 
     else 
     { 
      responseMsg = null; 
      responseHeaders = null; 
      responseStream = null; 
      return new ServerProcessing(); 
     } 
     } 

Answer 1

Il problema era dovuto a un deadlock causato nel mio codice, se la memoria serve ho avuto due oggetti di blocco e ne ho bloccati uno dall'interno, essenzialmente facendoli aspettare l'uno per l'altro. Sono stato in grado di determinare questo collegando un debugger al servizio remoto.

Answer 2

Questo è come cercare di scoprire perché nessuno risponde al telefono quando si chiama un amico. E il problema è che la sua casa è stata distrutta da un incendio. Una visione imperfetta di ciò che sta accadendo è il problema principale, in particolare cattivo con un servizio perché c'è così poco da guardare.

Questo non può andare meglio fino a quando non si utilizza quel telefono per parlare con il programmatore del servizio e farlo coinvolgere nel problema. Qualcuno dovrà eseguire il debug di questo. E sì, sarà difficile, in mancanza di una volta ogni due settimane potrebbe non essere considerato abbastanza critico. O troppo lungo per sedersi in attesa che succeda. L'unica cosa pratica che puoi fare per aiutare è creare un minidump del processo e trasmetterlo al programmatore di servizio in modo che abbia qualcosa da attirare. Se il servizio viene eseguito su un'altra macchina, coinvolgere anche l'amministratore della LAN.