Hướng dẫn how does python connect with http socket? - python kết nối với http socket như thế nào?

Ổ cắm¶

Tôi chỉ nói về ổ cắm Inet (tức là IPv4), nhưng chúng chiếm ít nhất 99% ổ cắm được sử dụng. Và tôi sẽ chỉ nói về luồng luồng (tức là TCP) còn gì nữa không. Tôi sẽ cố gắng làm sáng tỏ bí ẩn về một ổ cắm là gì, cũng như một số gợi ý về cách làm việc với các ổ cắm chặn và không chặn. Nhưng tôi sẽ bắt đầu bằng cách nói về việc chặn ổ cắm. Bạn cần phải biết cách họ làm việc trước khi xử lý các ổ cắm không chặn.

Một phần của rắc rối với việc hiểu những điều này là ổ cắm có thể có nghĩa là một số thứ khác nhau một cách tinh tế, tùy thuộc vào ngữ cảnh. Vì vậy, trước tiên, hãy để một sự khác biệt giữa một ổ cắm ứng dụng khách của máy khách - một điểm cuối của một cuộc trò chuyện và một ổ cắm máy chủ của máy chủ, giống như một toán tử chuyển mạch. Ví dụ, ứng dụng máy khách (ví dụ, trình duyệt của bạn) sử dụng ổ cắm máy khách của máy khách; Máy chủ web mà nó nói chuyện với việc sử dụng cả ổ cắm máy chủ của máy chủ và máy khách của máy khách.

Tạo ổ cắm

Nói một cách thô bạo, khi bạn nhấp vào liên kết đưa bạn đến trang này, trình duyệt của bạn đã làm một cái gì đó như sau:

# create an INET, STREAMing socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# now connect to the web server on port 80 - the normal http port
s.connect(("www.python.org", 80))

Khi connect hoàn thành, ổ cắm s có thể được sử dụng để gửi yêu cầu cho văn bản của trang. Cùng một ổ cắm sẽ đọc câu trả lời, và sau đó bị phá hủy. Đúng vậy, bị phá hủy. Các ổ cắm của máy khách thường chỉ được sử dụng cho một trao đổi (hoặc một bộ trao đổi tuần tự nhỏ).

Những gì xảy ra trong máy chủ web phức tạp hơn một chút. Đầu tiên, máy chủ web tạo ra một ổ cắm máy chủ trên mạng:

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

Một vài điều cần chú ý: Chúng tôi đã sử dụng socket.gethostname() để có thể nhìn thấy ổ cắm cho thế giới bên ngoài. Nếu chúng tôi đã sử dụng s.bind(('localhost', 80)) hoặc s.bind(('127.0.0.1', 80)), chúng tôi vẫn sẽ có một ổ cắm máy chủ trên máy chủ, nhưng một máy chủ chỉ hiển thị trong cùng một máy.

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

Một điều thứ hai cần lưu ý: Các cổng số thấp thường được dành riêng cho các dịch vụ nổi tiếng của các dịch vụ (HTTP, SNMP, v.v.). Nếu bạn đang chơi xung quanh, hãy sử dụng một số cao đẹp (4 chữ số).

Cuối cùng, đối số của

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

Bây giờ chúng tôi có một ổ cắm máy chủ trên mạng, nghe trên cổng 80, chúng tôi có thể nhập chính của máy chủ web:

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Trên thực tế, có 3 cách chung trong đó vòng lặp này có thể hoạt động - gửi một luồng để xử lý

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Sử dụng ổ cắm

Điều đầu tiên cần lưu ý, là ổ cắm của Trình duyệt web trên mạng và máy chủ web của máy chủ trên máy chủ của máy khách. Đó là, đây là một cuộc trò chuyện ngang hàng của người Viking. Hoặc để đặt nó một cách khác, với tư cách là nhà thiết kế, bạn sẽ phải quyết định các quy tắc nghi thức là gì cho một cuộc trò chuyện. Thông thường, ổ cắm connecting bắt đầu cuộc trò chuyện, bằng cách gửi yêu cầu hoặc có lẽ là một dấu hiệu. Nhưng đó là một quyết định thiết kế - nó không phải là một quy tắc của ổ cắm.

Bây giờ có hai bộ động từ để sử dụng để liên lạc. Bạn có thể sử dụng

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Bây giờ chúng tôi đến khối vấp ngã chính của ổ cắm -

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Khi một

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Một giao thức như HTTP sử dụng ổ cắm chỉ cho một lần chuyển. Khách hàng gửi một yêu cầu, sau đó đọc trả lời. Đó là nó. Các ổ cắm bị loại bỏ. Điều này có nghĩa là một khách hàng có thể phát hiện kết thúc trả lời bằng cách nhận 0 byte.

Nhưng nếu bạn có kế hoạch sử dụng lại ổ cắm của mình để chuyển tiếp, bạn cần nhận ra rằng không có EOT trên ổ cắm. Tôi nhắc lại: Nếu một ổ cắm

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Giả sử bạn không muốn kết thúc kết nối, giải pháp đơn giản nhất là thông báo độ dài cố định:

class MySocket:
    """demonstration class only
      - coded for clarity, not efficiency
    """

    def __init__(self, sock=None):
        if sock is None:
            self.sock = socket.socket(
                            socket.AF_INET, socket.SOCK_STREAM)
        else:
            self.sock = sock

    def connect(self, host, port):
        self.sock.connect((host, port))

    def mysend(self, msg):
        totalsent = 0
        while totalsent < MSGLEN:
            sent = self.sock.send(msg[totalsent:])
            if sent == 0:
                raise RuntimeError("socket connection broken")
            totalsent = totalsent + sent

    def myreceive(self):
        chunks = []
        bytes_recd = 0
        while bytes_recd < MSGLEN:
            chunk = self.sock.recv(min(MSGLEN - bytes_recd, 2048))
            if chunk == b'':
                raise RuntimeError("socket connection broken")
            chunks.append(chunk)
            bytes_recd = bytes_recd + len(chunk)
        return b''.join(chunks)

Mã gửi ở đây có thể sử dụng cho hầu hết mọi sơ đồ nhắn tin - trong Python bạn gửi chuỗi và bạn có thể sử dụng

class MySocket:
    """demonstration class only
      - coded for clarity, not efficiency
    """

    def __init__(self, sock=None):
        if sock is None:
            self.sock = socket.socket(
                            socket.AF_INET, socket.SOCK_STREAM)
        else:
            self.sock = sock

    def connect(self, host, port):
        self.sock.connect((host, port))

    def mysend(self, msg):
        totalsent = 0
        while totalsent < MSGLEN:
            sent = self.sock.send(msg[totalsent:])
            if sent == 0:
                raise RuntimeError("socket connection broken")
            totalsent = totalsent + sent

    def myreceive(self):
        chunks = []
        bytes_recd = 0
        while bytes_recd < MSGLEN:
            chunk = self.sock.recv(min(MSGLEN - bytes_recd, 2048))
            if chunk == b'':
                raise RuntimeError("socket connection broken")
            chunks.append(chunk)
            bytes_recd = bytes_recd + len(chunk)
        return b''.join(chunks)

class MySocket:
    """demonstration class only
      - coded for clarity, not efficiency
    """

    def __init__(self, sock=None):
        if sock is None:
            self.sock = socket.socket(
                            socket.AF_INET, socket.SOCK_STREAM)
        else:
            self.sock = sock

    def connect(self, host, port):
        self.sock.connect((host, port))

    def mysend(self, msg):
        totalsent = 0
        while totalsent < MSGLEN:
            sent = self.sock.send(msg[totalsent:])
            if sent == 0:
                raise RuntimeError("socket connection broken")
            totalsent = totalsent + sent

    def myreceive(self):
        chunks = []
        bytes_recd = 0
        while bytes_recd < MSGLEN:
            chunk = self.sock.recv(min(MSGLEN - bytes_recd, 2048))
            if chunk == b'':
                raise RuntimeError("socket connection broken")
            chunks.append(chunk)
            bytes_recd = bytes_recd + len(chunk)
        return b''.join(chunks)

Tăng cường dễ nhất là làm cho ký tự đầu tiên của tin nhắn thành một chỉ báo loại tin nhắn và có loại xác định độ dài. Bây giờ bạn có hai

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Một biến chứng cần biết: Nếu giao thức đàm thoại của bạn cho phép nhiều tin nhắn được gửi lại (không có một số loại trả lời) và bạn vượt qua kích thước chunk tùy ý, cuối cùng bạn có thể đọc bắt đầu một tin nhắn sau. Bạn cần phải đặt nó sang một bên và giữ nó, cho đến khi nó cần.

Tiền tố tin nhắn với độ dài của nó (giả sử, vì 5 ký tự số) trở nên phức tạp hơn, bởi vì (tin hay không), bạn có thể không nhận được tất cả 5 ký tự trong một

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Trong lợi ích của không gian, xây dựng nhân vật của bạn, (và bảo tồn vị trí cạnh tranh của tôi), những cải tiến này được để lại như một bài tập cho người đọc. Hãy chuyển sang dọn dẹp.

ready_to_read, ready_to_write, in_error = \
               select.select(
                  potential_readers,
                  potential_writers,
                  potential_errs,
                  timeout)

ready_to_read, ready_to_write, in_error = \
               select.select(
                  potential_readers,
                  potential_writers,
                  potential_errs,
                  timeout)

ready_to_read, ready_to_write, in_error = \
               select.select(
                  potential_readers,
                  potential_writers,
                  potential_errs,
                  timeout)

Ngắt kết nối

Nói đúng ra, bạn có thể sử dụng connect3 trên ổ cắm trước khi bạn connect4. connect3 là một lời khuyên cho ổ cắm ở đầu kia. Tùy thuộc vào đối số mà bạn vượt qua nó, điều đó có thể có nghĩa là tôi sẽ không gửi nữa, nhưng tôi vẫn nghe, hay tôi không nghe, câu đố tốt! Tuy nhiên, hầu hết các thư viện ổ cắm đều được sử dụng để các lập trình viên bỏ qua việc sử dụng phần nghi thức này mà thông thường là connect4 giống như connect7. Vì vậy, trong hầu hết các tình huống, một connect3 rõ ràng là không cần thiết.

Một cách để sử dụng connect3 một cách hiệu quả là trong một trao đổi giống như HTTP. Khách hàng gửi một yêu cầu và sau đó thực hiện một s0. Điều này cho máy chủ nói với máy khách này đã gửi xong, nhưng vẫn có thể nhận được. Máy chủ có thể phát hiện ra EOF EOF bằng cách nhận 0 byte. Nó có thể cho rằng nó có yêu cầu hoàn chỉnh. Máy chủ gửi trả lời. Nếu

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Python đưa tự động tắt máy thêm một bước nữa và nói rằng khi một ổ cắm được thu thập, nó sẽ tự động thực hiện connect4 nếu nó cần. Nhưng dựa vào điều này là một thói quen rất xấu. Nếu ổ cắm của bạn biến mất mà không làm connect4, ổ cắm ở đầu kia có thể treo vô thời hạn, nghĩ rằng bạn chỉ là chậm. Vui lòng connect4 ổ cắm của bạn khi bạn hoàn thành.

Ổ cắm không chặn

Nếu bạn đã hiểu trước đó, bạn đã biết hầu hết những gì bạn cần biết về cơ chế sử dụng ổ cắm. Bạn vẫn sẽ sử dụng các cuộc gọi tương tự, theo cùng một cách. Nó chỉ là điều đó, nếu bạn làm đúng, ứng dụng của bạn sẽ gần như từ trong ra ngoài.

Trong Python, bạn sử dụng s6 để làm cho nó không chặn. Trong C, nó phức tạp hơn, (đối với một điều, bạn sẽ cần phải lựa chọn giữa hương vị BSD s7 và hương vị POSIX gần như không thể phân biệt s8, hoàn toàn khác với s9), nhưng nó có cùng một ý tưởng. Bạn làm điều này sau khi tạo ổ cắm, nhưng trước khi sử dụng nó. (Trên thực tế, nếu bạn là hạt dẻ, bạn có thể chuyển đổi qua lại.)

Sự khác biệt cơ học chính là

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Sử dụng

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

Trong C, mã hóa

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

ready_to_read, ready_to_write, in_error = \
               select.select(
                  potential_readers,
                  potential_writers,
                  potential_errs,
                  timeout)

Bạn vượt qua

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

Đổi lại, bạn sẽ nhận được ba danh sách. Chúng chứa các ổ cắm thực sự có thể đọc được, có thể ghi và có lỗi. Mỗi danh sách này là một tập hợp con (có thể trống) của danh sách tương ứng bạn đã truyền vào.

Nếu một ổ cắm nằm trong danh sách có thể đọc được đầu ra, bạn có thể gần gũi với chúng ta khi chúng ta không phải là một doanh nghiệp mà một

while True:
    # accept connections from outside
    (clientsocket, address) = serversocket.accept()
    # now do something with the clientsocket
    # in this case, we'll pretend this is a threaded server
    ct = client_thread(clientsocket)
    ct.run()

Nếu bạn có một ổ cắm máy chủ trên máy chủ, hãy đặt nó vào danh sách tiềm năng_readers. Nếu nó xuất hiện trong danh sách có thể đọc được, công việc socket.gethostname()3 của bạn sẽ (gần như chắc chắn). Nếu bạn đã tạo một ổ cắm mới cho connect cho người khác, hãy đưa nó vào danh sách tiềm năng_writers. Nếu nó hiển thị trong danh sách có thể viết, bạn có một cơ hội tốt mà nó đã kết nối.

Trên thực tế,

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

Cảnh báo tính di động: Trên Unix,

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)

# create an INET, STREAMing socket
serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# bind the socket to a public host, and a well-known port
serversocket.bind((socket.gethostname(), 80))
# become a server socket
serversocket.listen(5)