¿Cómo arreglar java.net.SocketException: tubería rota?

Estoy usando el cliente http apache commons para llamar a la URL usando el método de publicación para publicar los parámetros y rara vez arroja el siguiente error.

java.net.SocketException: Broken pipe
        at java.net.SocketOutputStream.socketWrite0(Native Method)
        at java.net.SocketOutputStream.socketWrite(SocketOutputStream.java:92)
        at java.net.SocketOutputStream.write(SocketOutputStream.java:136)
        at java.io.BufferedOutputStream.write(BufferedOutputStream.java:105)
        at java.io.FilterOutputStream.write(FilterOutputStream.java:80)
        at org.apache.commons.httpclient.methods.ByteArrayRequestEntity.writeRequest(ByteArrayRequestEntity.java:90)
        at org.apache.commons.httpclient.methods.EntityEnclosingMethod.writeRequestBody(EntityEnclosingMethod.java:499)
        at org.apache.commons.httpclient.HttpMethodBase.writeRequest(HttpMethodBase.java:2114)
        at org.apache.commons.httpclient.HttpMethodBase.execute(HttpMethodBase.java:1096)
        at org.apache.commons.httpclient.HttpMethodDirector.executeWithRetry(HttpMethodDirector.java:398)

¿Alguien puede sugerir qué está causando esta excepción y cómo depurarla?

Esto es causado por:

• generalmente, escribir en una conexión cuando el otro extremo ya la ha cerrado;
• menos habitualmente, el par cierra la conexión sin leer todos los datos que ya están pendientes al final.

Entonces, en ambos casos, tiene un protocolo de aplicación mal definido o implementado.

Hay una tercera razón que no documentaré aquí, pero que implica que los pares tomen medidas deliberadas para restablecer en lugar de cerrar correctamente la conexión.

En nuestro caso, experimentamos esto al realizar una prueba de carga en nuestro servidor de aplicaciones. El problema resultó que necesitamos agregar memoria adicional a nuestra JVM porque se estaba agotando. Esto resolvió el problema.

Intente aumentar la memoria disponible para la JVM o supervise el uso de la memoria cuando reciba esos errores.

SocketException: tubería rota, es causada por el 'otro extremo' (el cliente o el servidor) que cierra la conexión mientras su código lee o escribe en la conexión.

Esta es una excepción muy común en aplicaciones cliente / servidor que reciben tráfico de clientes o servidores fuera del control de la aplicación. Por ejemplo, el cliente es un navegador. Si el navegador realiza una llamada Ajax, y / o el usuario simplemente cierra la página o el navegador, esto puede matar efectivamente toda comunicación inesperadamente. Básicamente, verá este error cada vez que el otro extremo finalice su aplicación, y no lo estaba anticipando.

Si experimenta esta excepción en su aplicación, significa que debe verificar su código donde ocurre el IO (entrada / salida) y envolverlo con un bloque try / catch para capturar esta IOException. Entonces depende de usted decidir cómo quiere manejar esta situación semi-válida.

En su caso, el primer lugar donde aún tiene control es la llamada a HttpMethodDirector.executeWithRetry- Así que asegúrese de que la llamada esté envuelta con el bloque try / catch y manejela como mejor le parezca.

Recomiendo encarecidamente que no se registren errores específicos de SocketException-Broken Pipe en cualquier otra cosa que no sean los niveles de depuración / rastreo. De lo contrario, esto se puede usar como una forma de ataque DOS (Denegación de servicio) al llenar los registros. Intente y endurezca y pruebe negativamente su aplicación para este escenario común.

Todas las secuencias y conexiones abiertas deben cerrarse correctamente, por lo que la próxima vez que intentemos usar el objeto urlConnection, no arrojará un error. Como ejemplo, el siguiente cambio de código solucionó el error para mí.

Antes de:

OutputStream out = new BufferedOutputStream(urlConnection.getOutputStream());
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
bw.write("Some text");
bw.close();
out.close();

Después:

OutputStream os = urlConnection.getOutputStream();
OutputStream out = new BufferedOutputStream(os);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(out));
bw.write("Some text");
bw.close();
out.close();
os.close(); // This is a must.

Implementé la funcionalidad de descarga de datos a través del servidor FTP y encontré la misma excepción allí al reanudar esa descarga. Para resolver esta excepción, siempre tendrá que desconectarse de la sesión anterior y crear una nueva instancia del Cliente y una nueva conexión con el servidor. Este mismo enfoque también podría ser útil para HTTPClient.

Tuve el mismo problema mientras desarrollaba una aplicación Java simple que escucha en un TCP específico. Por lo general, no tuve ningún problema, pero cuando ejecuté una prueba de esfuerzo, noté que algunas conexiones se rompieron con un error socket write exception.

Después de la investigación, encontré una solución que resuelve mi problema. Sé que esta pregunta es bastante antigua, pero prefiero compartir mi solución, alguien puede encontrarla útil.

El problema estaba en la creación de ServerSocket. Leí de Javadoc que hay un límite predeterminado de 50 sockets pendientes. Si intenta abrir otra conexión, se rechazarán. La solución consiste simplemente en cambiar esta configuración predeterminada en el lado del servidor. En el siguiente caso, creo un servidor de Socket que escucha en el puerto TCP 10_000y acepta max 200sockets pendientes.

new Thread(() -> {
      try (ServerSocket serverSocket = new ServerSocket(10_000, 200)) {
        logger.info("Server starts listening on TCP port {}", port);

        while (true) {
          try {
            ClientHandler clientHandler = clientHandlerProvider.getObject(serverSocket.accept(), this);
            executor.execute(clientHandler::start);
          } catch (Exception e) {
            logger.error(e.getMessage());
          }
        }

      } catch (IOException | SecurityException | IllegalArgumentException e) {
        logger.error("Could not open server on TCP port {}. Reason: {}", port, e.getMessage());
      }
    }).start();

Desde Javadoc de ServerSocket :

La longitud máxima de la cola para las indicaciones de conexión entrante (una solicitud de conexión) se establece en el parámetro de acumulación. Si llega una indicación de conexión cuando la cola está llena, se rechaza la conexión.

El problema podría ser que sus archivos desplegados no se actualicen con los métodos RMI correctos. Verifique que su interfaz RMI tenga parámetros actualizados o estructuras de datos actualizadas que su cliente no tiene. O que su cliente RMI no tiene parámetros que difieran de la versión de su servidor.

Esto es solo una suposición educada. Después de volver a implementar los archivos de clase de mi aplicación de servidor y volver a realizar las pruebas, el problema de "tubería rota" desapareció.

Las respuestas anteriores ilustran la razón de esto java.net.SocketException: Broken pipe: el otro extremo cerró la conexión. Me gustaría compartir la experiencia de lo que sucedió cuando lo encontré:

1. en la solicitud de un cliente, el Content-Typeencabezado se establece erróneamente más grande que el cuerpo de la solicitud (de hecho, no había ningún cuerpo)
2. el servicio inferior en el socket tomcat estaba esperando los datos de ese tamaño del cuerpo (http está en TCP que asegura la entrega encapsulando y ...)
3. Cuando caducaron 60 segundos, Tomcat lanza una excepción de tiempo de espera: Servlet.service() for servlet [dispatcherServlet] in context with path [] threw exception java.net.SocketTimeoutException: null
4. el cliente recibe una respuesta con el código de estado 500 debido a la excepción de tiempo de espera.
5. conexión cercana del cliente (porque recibe respuesta).
6. tomcat lanza java.net.SocketException: Broken pipeporque el cliente lo cerró.

A veces, tomcat no arroja una excepción de pip roto, porque la excepción de tiempo de espera cierra la conexión, por qué esa diferencia también me confunde.

JavaDoc:

La longitud máxima de la cola para las indicaciones de conexión entrante (una solicitud de conexión) se establece en 50. Si llega una indicación de conexión cuando la cola está llena, se rechaza la conexión.

Debe aumentar el parámetro "backlog" de su ServerSocket, por ejemplo

int backlogSize = 50 ;
new ServerSocket(port, backlogSize);

La causa es que el par remoto cierra su socket (bloqueo, por ejemplo), por lo que si intenta escribir datos en él, por ejemplo, obtendrá esto. para resolver eso, proteja las operaciones de lectura / escritura en el socket entre (intente catch), luego administre el caso de pérdida de conexión en el catch (renueve la conexión, pare el programa, ... etc.):

 try {
      /* your code */
 } catch (SocketException e) {
      e.printStackTrace();
      /* insert your failure processings here */
 }