¿Cómo establecer un tiempo de espera en los sockets de bloqueo en boost asio?

Question

¿Hay alguna manera de cancelar una operación pendiente (sin desconectar) o establecer un tiempo de espera para las funciones de la biblioteca de impulso?

I.e. Quiero establecer un tiempo de espera en el bloqueo de socket en impulsar asio?

socket.read_some (boost :: :: asio del búfer (pData, maxSize), ERROR_);

Ejemplo: Quiero leer algo de la toma, pero quiero un error si han transcurrido 10 segundos.

Answer 1

Bajo Linux/BSD el tiempo de espera en las operaciones de E/S en sockets es apoyado directamente por el sistema operativo. La opción se puede habilitar a través del setsocktopt(). No sé si boost::asio proporciona un método para configurarlo o expone el script de socket para permitirle configurarlo directamente; este último caso no es realmente portable.

Para una mayor abundamiento aquí está la descripción de la página man:

SO_RCVTIMEO y SO_SNDTIMEO

  Specify the receiving or sending timeouts until reporting an 
      error. The argument is a struct timeval. If an input or output 
      function blocks for this period of time, and data has been sent 
      or received, the return value of that function will be the 
      amount of data transferred; if no data has been transferred and 
      the timeout has been reached then -1 is returned with errno set 
      to EAGAIN or EWOULDBLOCK just as if the socket was specified to 
      be non-blocking. If the timeout is set to zero (the default) 
      then the operation will never timeout. Timeouts only have 
      effect for system calls that perform socket I/O (e.g., read(2), 
      recvmsg(2), send(2), sendmsg(2)); timeouts have no effect for 
      select(2), poll(2), epoll_wait(2), etc. 

Answer 2

En * nix, tendrá que utilizar la alarma() para que su llamada socket fallaría con EINTR

Answer 3

Usted podría hacer un async_read y también establecer un temporizador para su tiempo de espera deseado. Luego, si el temporizador se dispara, llame a cancelar en su objeto de socket. De lo contrario, si su lectura ocurre, puede cancelar su temporizador. Esto requiere que uses un objeto io_service por supuesto.

edición: Ha encontrado un fragmento de código para usted que hace esto

http://lists.boost.org/Archives/boost/2007/04/120339.php

Answer 4

que tenía la misma pregunta, y después de algunas investigaciones, la solución más limpia más simple que pudiera venir fue para obtener el subyacente socket nativo, y hacer una selección hasta que haya datos para leer. Seleccionar tomará un parámetro de tiempo de espera. Por supuesto, trabajar con el socket nativo comienza a ir en contra del uso de asio en primer lugar, pero de nuevo, esta parece ser la forma más limpia. Por lo que pude ver, asio no proporciona una forma de hacer esto para el uso sincrónico fácilmente. Código:

 // socket here is: boost::shared_ptr<boost::asio::ip::tcp::socket> a_socket_ptr 

     // Set up a timed select call, so we can handle timeout cases. 

     fd_set fileDescriptorSet; 
     struct timeval timeStruct; 

     // set the timeout to 30 seconds 
     timeStruct.tv_sec = 30; 
     timeStruct.tv_usec = 0; 
     FD_ZERO(&fileDescriptorSet); 

     // We'll need to get the underlying native socket for this select call, in order 
     // to add a simple timeout on the read: 

     int nativeSocket = a_socket_ptr->native(); 

     FD_SET(nativeSocket,&fileDescriptorSet); 

     select(nativeSocket+1,&fileDescriptorSet,NULL,NULL,&timeStruct); 

     if(!FD_ISSET(nativeSocket,&fileDescriptorSet)){ // timeout 

       std::string sMsg("TIMEOUT on read client data. Client IP: "); 

       sMsg.append(a_socket_ptr->remote_endpoint().address().to_string()); 

       throw MyException(sMsg); 
     } 

     // now we know there's something to read, so read 
     boost::system::error_code error; 
     size_t iBytesRead = a_socket_ptr->read_some(boost::asio::buffer(myVector), error); 

     ... 

Quizás esto le sea útil para su situación.

Answer 5

Usted puede envolver las llamadas síncronas en futuros y esperar a que se complete con un tiempo de espera (wait_timeout).

http://www.boost.org/doc/libs/1_47_0/doc/html/thread/synchronization.html#thread.synchronization.futures

Desde luego, no una talla para todos, pero funciona bien para, por ejemplo, eludiendo los tiempos de espera de conexión lenta.

Answer 6

Siguiendo con lo que grepsedawk ha mencionado. Hay algunos ejemplos que muestran cómo cancelar operaciones asíncronas de larga ejecución después de un período de tiempo, en la sección Tiempos de espera dentro de asio doco. Boost Asio Examples .Async TCP client helped me the most.

feliz :) Asyncing

Answer 7

Cuando se hizo esta pregunta, supongo ASIO no tenía ningún ejemplo de cómo llevar a cabo lo que el PO es necesario, que es el tiempo de espera para una operación de bloqueo tal como una operación de socket de bloqueo. Ahora existen ejemplos para mostrarle exactamente cómo hacer esto. el ejemplo parece largo, pero eso se debe a que está BIEN comentado. Muestra cómo usar el ioservicio en un modo de tipo 'one shot'.

Creo que el ejemplo es una gran solución. Las otras soluciones aquí rompen la portabilidad y no aprovechan ioservice. si la portabilidad no es importante y el ioservicio parece tener demasiada sobrecarga --TODO-- no debería usar ASIO. No importa qué, tendrá un ioservicio creado (casi todas las funciones de ASIO dependen de él, incluso los conectores de sincronización), así que aproveche.

Timeout a blocking asio tcp operation

Timeout a blocking asio udp operation

La documentación ASIO se ha actualizado, a fin de comprobar hacia fuera para nuevos ejemplos sobre cómo superar algunos de los ASIO 'trampas' usar para tener.

Answer 8

Incluso años después de la pregunta original, todavía no hay una respuesta satisfactoria.

usando Selecciona manualmente no es una buena opción número del descriptor

1. archivo debe ser inferior a 1.024
2. FD puede informar falsamente como listo debido a la suma de comprobación incorrecta.

llamada io_service.run_one() es también una mala idea, porque puede haber otras opciones asíncronas que necesita una io_service para siempre run(). Y el documento de boost sobre bloquear el cliente de tcp es difícil de comprender.

Así que aquí está mi solución. La idea clave es la siguiente:

{ 
    Semaphore r_sem; 
    boost::system::error_code r_ec; 
    boost::asio::async_read(s,buffer, 
          [this, &r_ec, &r_sem](const boost::system::error_code& ec_, size_t) { 
           r_ec=ec_; 
           r_sem.notify(); 
          }); 
    if(!r_sem.wait_for(std::chrono::seconds(3))) // wait for 3 seconds 
    { 
     s.cancel(); 
     r_sem.wait(); 
     throw boost::system::system_error(boost::asio::error::try_again); 
    } 
    else if(r_ec) 
     throw boost::system::system_error(r_ec); 
} 

Aquí Semaphore es sólo un mutex y una condition_variable.
wait_for se implementa por http://en.cppreference.com/w/cpp/thread/condition_variable/wait_for

código completo está en https://github.com/scinart/cpplib/blob/master/include/asio.hpp
ejemplos está en https://github.com/scinart/cpplib/blob/master/test/test_asio.cpp
ejemplo mejor en https://github.com/scinart/cpplib/blob/master/test/test_SyncBoostIO.cpp