import socket


def request(host: str) -> None:
    url: str = f"http://{host}"
    sock: socket.SocketType = socket.socket()
    sock.connect((host, 80))
    sock.send(f"GET {url} HTTP/1.0\r\nHost: {host}\r\n\r\n".encode("ascii"))

    response_bytes: bytes = b""
    chunk: bytes = sock.recv(4096)
    while chunk:
        response_bytes += chunk
        chunk = sock.recv(4096)
    print("\n".join([i for i in response_bytes.decode().split("\r\n")]))


if __name__ == "__main__":
    request("so1n.me")

import asyncio
import socket


async def request(host: str) -> None:
    url: str = f"http://{host}"
    loop = asyncio.get_event_loop()
    sock: socket.SocketType = socket.socket()
    await loop.sock_connect(sock, (host, 80))
    await loop.sock_sendall(sock, f"GET {url} HTTP/1.0\r\nHost: {host}\r\n\r\n".encode("ascii"))

    response_bytes: bytes = b""
    chunk: bytes = await loop.sock_recv(sock, 4096)
    while chunk:
        response_bytes += chunk
        chunk = await loop.sock_recv(sock, 4096)
    print("\n".join([i for i in response_bytes.decode().split("\r\n")]))


if __name__ == "__main__":
    asyncio.run(request("so1n.me"))

# 位于:Lib/asyncio/selector_events.py
async def sock_connect(self, sock, address):
    # 检查ssl sock以及检查是否为阻塞的sock
    base_events._check_ssl_socket(sock)
    if self._debug and sock.gettimeout() != 0:
        raise ValueError("the socket must be non-blocking")

    if sock.family == socket.AF_INET or (
            base_events._HAS_IPv6 and sock.family == socket.AF_INET6):
        # 通过dns将域名转为ip地址
        resolved = await self._ensure_resolved(
            address, family=sock.family, type=sock.type, proto=sock.proto,
            loop=self,
        )
        _, _, _, _, address = resolved[0]

    # 创建一个future，这个future会等待soc连连接成功才返回数据。
    fut = self.create_future()
    self._sock_connect(fut, sock, address)
    # 通过future等待soc床创建成功
    return




    
 await fut

# 位于:Lib/asyncio/selector_events.py
    async def _ensure_resolved(self, address, *, family=0, type=socket.SOCK_STREAM, proto=0, flags=0, loop):
        host, port = address[:2]
    	# 判断是否已经解析，已经解析了就直接使用
        info = _ipaddr_info(host, port, family, type, proto, *address[2:])
        if info is not None:
            # "host" is already a resolved IP.
            return [info]
        else:
    		# 没有解析则调用socket.getaddrinfo进行解析
            return await loop.getaddrinfo(host, port, family=family, type=type, proto=proto, flags=flags)
    
# 位于:Lib/asyncio/base_events.py
    async def getaddrinfo(self, host, port, *, family=0, type=0, proto=0, flags=0):
        if self._debug:
            getaddr_func = self._getaddrinfo_debug
        else:
            getaddr_func = socket.getaddrinfo

        return await self.run_in_executor(
            None, getaddr_func, host, port, family, type, proto, flags)

# 位于:Lib/asyncio/selector_events.py
def _sock_connect(self, fut, sock, address):
    fd = sock.fileno()
    try:
        sock.connect(address)
    except (BlockingIOError, InterruptedError):
        # 检查对应的文件描述符对应的连接是否还在运行
        # 如果还在运行则抛错
        self._ensure_fd_no_transport(fd)
        # 注册文件描述符的读回调
        handle = self._add_writer(fd, self._sock_connect_cb, fut, sock, address)
        # 通过fut添加fut完成时移除监听的回调
        fut.add_done_callback(functools.partial(self._sock_write_done, fd, handle=handle))
    except (SystemExit, KeyboardInterrupt):
        raise
    except BaseException as exc:
        fut.set_exception(exc)
    else:
        fut.set_result(None)

def _sock_write_done(self, fd, fut, handle=None):
    # 移除事件的监听
    if handle is None or not handle.cancelled():
        self.remove_writer(fd)

def _sock_connect_cb(self, fut, sock, address):
    if fut.done():
        return
    # 当有写事件除非时代表着连接建立这个行为已经执行完毕了，但是需要检查建立结果
    try:
        err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
        if err != 0:
            raise OSError(err, f'Connect call failed {address}')
    except (BlockingIOError, InterruptedError):
        pass
    except (SystemExit, KeyboardInterrupt):
        raise
    except BaseException as exc:
        fut.set_exception(exc)
    else:
        fut.set_result(None)

# 位于:Lib/asyncio/selector_events.py
def _start_serving(self):
   if self._serving:
       return
   self._serving = True
   for sock in self._sockets:
       sock.listen(self._backlog)  # <--重点，后面有说
       self._loop._start_serving(
           self._protocol_factory, sock, self._ssl_context,
           self, self._backlog, self._ssl_handshake_timeout,
           self._ssl_shutdown_timeout)

# 位于:Lib/asyncio/selector_events.py
def _start_serving(self, protocol_factory, sock,
                   sslcontext=None, server=None, backlog=100,
                   ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
                   ssl_shutdown_timeout=constants.SSL_SHUTDOWN_TIMEOUT):
    self._add_reader(sock.fileno(), self._accept_connection,
                     protocol_factory, sock, sslcontext, server, backlog,
                     ssl_handshake_timeout, ssl_shutdown_timeout)

# 位于:Lib/asyncio/selector_events.py
def _accept_connection(
        self, protocol_factory, sock,
        sslcontext=None, server=None, backlog=100,
        ssl_handshake_timeout=constants.SSL_HANDSHAKE_TIMEOUT,
        ssl_shutdown_timeout=constants.SSL_SHUTDOWN_TIMEOUT):
    # 执行n次accept，直到没有新的请求建立或者执行完毕
    for _ in range(backlog):
        try:
            conn, addr = sock.accept()
            conn.setblocking(False)
        except (BlockingIOError, InterruptedError, ConnectionAbortedError):
            # socket accept的缓冲区为空，所以不用处理了
            return None
        except OSError as exc:
            # 如果有错误，则应该移除监听，再重新调用`_start_serving`进行监听
            if exc.errno in (errno.EMFILE, errno.ENFILE,
                             errno.ENOBUFS, errno.ENOMEM):
                # 兼容accept多次后Linux一直将文件描述符标记为准备就绪的bug，先移除监听再重新监听
                self.call_exception_handler({
                    'message': 'socket.accept() out of system resource',
                    'exception': exc,
                    'socket': trsock.TransportSocket(sock),
                })
                self._remove_reader(sock.fileno())
                self.call_later(constants.ACCEPT_RETRY_DELAY,
                                self._start_serving,
                                protocol_factory, sock, sslcontext, server,
                                backlog, ssl_handshake_timeout,
                                ssl_shutdown_timeout)
            else:
                raise  # The event loop will catch, log and ignore it.
        else:
            extra = {'peername': addr}
            # 每个acccept都可以认为是一个新的客户端建立的请求，为了提高并发性，需要创建一个新的协程去处理。 
            accept = self._accept_connection2(
                protocol_factory, conn, extra, sslcontext, server,
                ssl_handshake_timeout, ssl_shutdown_timeout)
            self.create_task(accept)

# 位于:Lib/asyncio/selector_events.py
class _SelectorSocketTransport(_SelectorTransport):
    ...
    def _read_ready__data_received(self):
        if self._conn_lost:
            return
        try:
            # 通过sock获获取数据
            data = self._sock.recv(self.max_size)
    	# 省去一些异常处理
        except BaseException as exc:
            self._fatal_error(exc, 'Fatal read error on socket transport')
            return
    
        if not data:
            # 没有数据则代表收到eof
            self._read_ready__on_eof()
            return
    
        try:
            self._protocol.data_received(data)
    	# 省去一些异常处理
        except BaseException as exc:
            self._fatal_error(
                exc, 'Fatal error: protocol.data_received() call failed.')
    
    def _read_ready__on_eof(self):
        try:
            keep_open = self._protocol.eof_received()
    	# 省去一些异常处理
        except BaseException as exc:
            self._fatal_error(
                exc, 'Fatal error: protocol.eof_received() call failed.')
            return
    
        if keep_open:
            self._loop._remove_reader(self._sock_fd)
        else:
            self.close()

# 位于:Lib/asyncio/selector_events.py
class _SelectorTransport(transports._FlowControlMixin, transports.Transport):
    ...
    def abort(self):
        # 强制关闭连接
        self._force_close(None)

    def is_closing(self):
        return self._closing

    def close(self):
        if self._closing:
            return
        # close只移除读事件监听，buffer没有数据才会强制关闭
        self._closing = True
        self._loop._remove_reader(self._sock_fd)
        if not self._buffer:
            self._conn_lost += 1
            self._loop._remove_writer(self._sock_fd)
            self._loop.call_soon(self._call_connection_lost, None)

    def __del__(self, _warn=warnings.warn):
        if self._sock is not None:
            _warn(f"unclosed transport {self!r}", ResourceWarning, source=self)
            # 确保sock被回收，如果没有这个操作，可能会导致内存溢出
            self._sock.close()

    def _fatal_error(self, exc, message='Fatal error on transport'):
        # 省略的异常处理...
        self._force_close(exc)

    def _force_close(self, exc):
        if self._conn_lost:
            # 如果连接丢失就不管了
            return
        if self._buffer:
            # 移除写事件监听以及缓存的buffer




    

            self._buffer.clear()
            self._loop._remove_writer(self._sock_fd)
        if not self._closing:
            # 移除读事件监听
            self._closing = True
            self._loop._remove_reader(self._sock_fd)
        # 稍后才关闭连接
        self._loop.call_soon(self._call_connection_lost, exc)

    def _call_connection_lost(self, exc):
        try:
            if self._protocol_connected:
                # 如果当前还处于连接中，那么需要通过Protocol的`connection_lost`方法把连接丢失的原因告诉使用方。
                self._protocol.connection_lost(exc)
        finally:
            # 关闭sock等一切资源
            self._sock.close()
            self._sock = None
            self._protocol = None
            self._loop = None
            server = self._server
            if server is not None:
                server._detach()
                self._server = None

# 位于:Lib/asyncio/selector_events.py
class _SelectorSocketTransport(_SelectorTransport):
    ...

    def write(self, data):
        ...
        # 省略一些校验的
        if self._eof:
            # 已经eof了，不能写数据
            raise RuntimeError('Cannot call write() after write_eof()')
        if not self._buffer:
            # 如果没有buffer,就代表当前的发送缓冲区可能为空，先发发试一试
            try:
                # 先看看能扔多少数据去缓冲区
                n = self._sock.send(data)
            except (BlockingIOError, InterruptedError):
                # 缓冲区满了，无法发送...
                pass
            # 省去一些异常处理
            except BaseException as exc:
                self._fatal_error(exc, 'Fatal write error on socket transport')
                return
            else:
                # 去掉已经扔到缓冲区的数据
                data = data[n:]
                if not data:
                    return
            # 如果缓冲区满了，那么还有剩余的数据，需要等待socket可写时才调用回调写数据
            self._loop._add_writer(self._sock_fd, self._write_ready)

        # 把数据加入buffer中，buffer默认是bytesarray，效率很高
        self._buffer.extend(data)
        # 如果写的压力很高，就需要暂停一下 
        self._maybe_pause_protocol()

    def _write_ready(self):

        if self._conn_lost:
            return
        try:
            n = self._sock.send(self._buffer)
        # 省去一些异常处理
        except BaseException as exc:
            # 如果有异常，就移除监听，清空buffer
            self._loop._remove_writer(self._sock_fd)
            self._buffer.clear()
            # 抛出异常并通过`force`强制关闭socket
            self._fatal_error(exc, 'Fatal write error on socket transport')
        else:
            if n:
                # 从buffer清除掉已经发送的buffer
                del self._buffer[:n]
            self._maybe_resume_protocol()  # May append to buffer.
            if not self._buffer:
                # 发送完了需要进行善后处理，因为有可能socket在发送完消息后就要关闭
                self._loop._remove_writer(self._sock_fd)
                if self._closing:
                    self._call_connection_lost(None)
                elif self._eof:
                    self._sock.shutdown(socket.SHUT_WR)

# 位于:Lib/asyncio/selector_events.py
class _SelectorSocketTransport(_SelectorTransport):
    ...
    def write_eof(self):
        if self._closing or self._eof:
            return
        self._eof = True
        if not self._buffer:
            self._sock.shutdown(socket.SHUT_WR)

    def can_write_eof(self):
        return True