Remove the socket_dontwait option from the async module, as it is an obsolete feature.

Author: matyhtf

ext-src/swoole_async_coro.cc

@@ -116,9 +116,6 @@ PHP_FUNCTION(swoole_async_set) {
         v = SW_MAX(1, SW_MIN(v, UINT32_MAX));
         SwooleG.aio_worker_num = v;
     }
-    if (php_swoole_array_get_value(vht, "socket_dontwait", ztmp)) {
-        SwooleG.socket_dontwait = zval_is_true(ztmp);
-    }
     if (php_swoole_array_get_value(vht, "dns_lookup_random", ztmp)) {
         SwooleG.dns_lookup_random = zval_is_true(ztmp);
     }

include/swoole.h

@@ -670,11 +670,11 @@ struct EventData {
     char data[SW_IPC_BUFFER_SIZE];
 
     uint32_t size() {
-    	return sizeof(info) + len();
+        return sizeof(info) + len();
     }
 
     uint32_t len() {
-    	return info.len;
+        return info.len;
     }
 };
 
@@ -746,12 +746,11 @@ struct Global {
     uchar running : 1;
     uchar wait_signal : 1;
     uchar enable_signalfd : 1;
-    uchar socket_dontwait : 1;
     uchar dns_lookup_random : 1;
     uchar use_async_resolver : 1;
     uchar use_name_resolver : 1;
     uchar enable_coroutine : 1;
-    uchar print_backtrace_on_error: 1;
+    uchar print_backtrace_on_error : 1;
 
     uint8_t process_type;
     uint32_t process_id;
@@ -812,7 +811,7 @@ void hook_call(void **hooks, int type, void *arg);
 double microtime(void);
 }  // namespace swoole
 
-extern swoole::Global SwooleG;                  // Local Global Variable
+extern swoole::Global SwooleG;                      // Local Global Variable
 extern thread_local swoole::ThreadGlobal SwooleTG;  // Thread Global Variable
 
 #define SW_CPU_NUM (SwooleG.cpu_num)

include/swoole_socket.h

@@ -190,7 +190,6 @@ struct Socket {
     uchar dtls : 1;
 #endif
 #endif
-    uchar dontwait : 1;
     uchar close_wait : 1;
     uchar send_wait : 1;
     uchar tcp_nopush : 1;

src/network/client.cc

@@ -86,7 +86,6 @@ Client::Client(SocketType _type, bool _async) : async(_async) {
             connect = Client_tcp_connect_async;
             send = Client_tcp_send_async;
             sendfile = Client_tcp_sendfile_async;
-            socket->dontwait = SwooleG.socket_dontwait;
         } else {
             connect = Client_tcp_connect_sync;
             send = Client_tcp_send_sync;

src/reactor/base.cc

@@ -218,7 +218,6 @@ ssize_t Reactor::write_func(Reactor *reactor,
                             const std::function<void(Buffer *buffer)> &append_fn) {
     ssize_t retval;
     Buffer *buffer = socket->out_buffer;
-    int fd = socket->fd;
 
     if (socket->buffer_size == 0) {
         socket->set_memory_buffer_size(Socket::default_buffer_size);
@@ -263,6 +262,11 @@ ssize_t Reactor::write_func(Reactor *reactor,
             if (!socket->isset_writable_event()) {
                 reactor->add_write_event(socket);
             }
+            /**
+             * Part of the data has been successfully written to the kernel's socket buffer,
+             * and at this point, writing to the memory queue is permitted under any circumstances.
+             * Ensure that the async write operation either succeeds completely or fails entirely.
+             */
             goto _append_buffer;
         } else if (errno == EINTR) {
             goto _do_send;
@@ -271,18 +275,11 @@ ssize_t Reactor::write_func(Reactor *reactor,
             return SW_ERR;
         }
     } else {
-    _append_buffer:
         if (buffer->length() > socket->buffer_size) {
-            if (socket->dontwait) {
-                swoole_set_last_error(SW_ERROR_OUTPUT_BUFFER_OVERFLOW);
-                return SW_ERR;
-            } else {
-                swoole_error_log(
-                    SW_LOG_WARNING, SW_ERROR_OUTPUT_BUFFER_OVERFLOW, "socket#%d output buffer overflow", fd);
-                sw_yield();
-                socket->wait_event(SW_SOCKET_OVERFLOW_WAIT, SW_EVENT_WRITE);
-            }
+            swoole_set_last_error(SW_ERROR_OUTPUT_BUFFER_OVERFLOW);
+            return SW_ERR;
         }
+    _append_buffer:
         append_fn(buffer);
     }
     return __len;