网络编程

[eziceice]

Socket

• 网络编程中的一个基本组建是socket, 它是一个信息通道, 两端各有一个程序. 这些程序可能位于(通过网络相连的)不同的计算机上, 通过socket向对方发送信息. 在Python中, 大多数网络编程都隐藏了模块socket的基本工作原理, 不与socket直接交互.

  1. Socket分为两类, Server socket和Client socket. 创建了服务端的socket后,就可以让它等待连接请求的到来. 这样, 它将在某个网络地址(由IP和Port组成)处监听, 直到客户端的socket与之建立连接. 这样客户端和服务端就能与之通信了.

  2. 通常客户端的socket处理起来比较容易,因为它只需要完成任务并且断开连接. 而服务端的socket略微复杂一些, 因为服务器必须准备随时处理客户端的连接,并且还必须可以处理多个连接.

  3. Python中的socket存在于socket module中, 实例化socket时最多可指定三个参数: 一个地址族(默认为socket.AF_INET), 一个是流socket(socket.SOCK_STREAM,默认设置)还是数据报socket(socket.SOCK_DGRAM), 还有一个是协议(默认值0). 创建普通socket时,不需要提供任何参数.

  4. 服务器端的socket先调用bind方法绑定host IP和Port, 再使用listen来监听特定的地址. 然后, 客户端的socket就可以连接至服务器了, 办法是调用方法connect并提供调用方式bind时指定的地址(在服务器端, 可使用方法socket.gethostname获取当前机器的主机名). 这里的地址是一个格式为(host ,port)的tuple, host为主机名(如www.example.com), 而port是端口号(一个整数). 方法listen接受一个参数 - 待办任务清单的长度(即最多可有多少个连接在队列中等待接纳, 到达这个数量后将开始拒绝连接).

  5. 服务器socket开始监听后, 就可以接受客户端的连接了, 这是使用方法accept来完成的. 这个方法将阻断(同步式的)到客户端连接的到来, 然后返回一个格式为(client, address)的tuple. 其中client是一个客户端的socket, 而address是前面的地址解释过的地址. 服务器能以其认为合适的方式处理客户端的连接,然后再次调用accept以接着等待新连接的到来. 这通常是在一个无限循环中完成的.

  6. 为了在服务端和客户端传输数据, socket主要有两种方法: send和recv. 发送数据可使用send并提供一个字符串; 而接收数据, 可以调用recv并指定最多接收多少个字节的数据.

  7. 在Linux或者Unix系统中, 需要有管理员权限才能使用1024以下的port, 这些较小的port都是提供标准服务使用的. 比如port 80是提供web服务器的使用.

import socket
import threading

class MyThread(threading.Thread):
    def run(self):
        create_server()

def create_server():
    s = socket.socket()
    host = socket.gethostname()
    port = 1234
    s.bind((host, port))
    s.listen(5)
    while True:
        c, addr = s.accept()
        print('Got connection from', addr)
        message = 'Thanks for your messages'
        c.send(message.encode())
        c.close()

def create_client():
    s = socket.socket()
    host = socket.gethostname()
    port = 1234
    s.connect((host, port))
    print(s.recv(1024))

def main():
    t = MyThread()
    t.start()
    create_client()

if __name__ == '__main__':
    main()

[eziceice]

urllib和urllib2

• 使用这两个module几乎可以像打开本地文件一样打开远程文件,差别是只能使用读取模式, 以及使用模块urllib.request中的函数urlopen, 而不是open. urlopen返回的类似于文件的对象支持方法close, read, readline和readlines - 并且支持迭代.

from urllib.request import urlopen
webpage = urlopen('https://www.google.com')

• 如果想获取或者下载远程的文件, 可以使用urlretrieve()方法. 这个方法不返回一个类似于文件的对象, 而返回一个格式为(filename, headers)的元组, 其中filename是本地文件的名称(由urllib自动创建), 而headers包含一些有关远程文件的信息. 如果要给下载的副本指定文件名, 可以通过第二个参数.

from urllib.request import *
webpage = urlretrieve('https://www.google.com')
print(webpage) 
# ('C:\\Users\\yutianli\\AppData\\Local\\Temp\\tmp2lsl3d81', <http.client.HTTPMessage object at 0x02B60330>)
urlcleanup() #清理文件

[eziceice]

SocketServer

• 简单的socket server并不难编写. 但是如果想要创建更加复杂的服务器, 则需要使用服务器的模块. SocketServer是Python服务器框架的基石库. 这个框架包括 - BaseHTTPServer, SimpleHTTPServer, CGIHTTPServer, SimpleXMLRPCServer和DocXMLRPCServer. 这几种服务器都是在基本服务器上添加了各种功能.

• SocketServer包含4个基本的服务器: TCPServer(支持TCP socket), UDPServer(支持UDP socket), 以及更难懂的UnixStreamServer和UnixDatagramServer. 使用SocketServer编写服务器时, 大部分代码都位于请求处理器中. 每当服务器收集到客户端的连接请求, 都会实例化一个请求处理程序, 并对其调用各种处理方法来处理请求. 具体调用哪些方法取决于使用的服务器类和请求处理程序类, 还可以从这些请求处理类派生出子类, 从而让服务器调用一组自定义的处理方法.

• 基本请求处理程序类BaseRequestHandler将所有操作都放在同一个方法中—服务器调用的方法handle. 这个方法可以通过属性self.request来访问客户端的socket. 如果处理的是流(使用TCPServer时很可能如此), 可以使用StreamRequestHandler类, 它包含另外的两个属性: self.rfile(用于读)和self.wfile(用于写). 可以使用这两个类似的文件对象和客户端进行通信.

from socketserver import TCPServer, StreamRequestHandler
import socket

class Handler(StreamRequestHandler):
    def handle(self):
        addr = self.request.getpeername()
        print('Got connection from', addr)
        self.wfile.write('Thank you for connecting'.encode()) #str is not supported, encode it first.

server = TCPServer((socket.gethostname(),1234), Handler)
server.serve_forever()

[eziceice]

多个连接

• Python中也有支持同时处理多个连接的方式,并且不会阻塞任何程序. 主要有三种方式, 分别为forking(分叉), 线程化(threading)和异步I/O(asynchronous I/O). 通过结合使用SocketServer中的混合类和服务器类, 很容易实现forking和线程化. 但是forking和线程化也有缺点, forking占用的资源较多, 并且在客户端很多时的伸缩性不佳(但只要客户端数量适中, forking在UNIX和Linux系统中的效率很高. 如果有多个CPU, 效率就更高了); 而线程化容易带来同步问题.

• forking是一个Unix术语. 对进程进行分叉时, 基本上是复制它, 而这样得到的两个进程都将从当前位置开始继续往下执行, 并且每个进程都有自己独立的内存副本(变量等-内存空间). 原来的进程为父进程, 复制的进程为子进程. 进程能够判断它们到底是原始进程还是子进程(通过查看函数fork的返回值), 因此能够执行不同的操作. 在forking服务器中, 对于每个客户端的连接, 都将通过分叉创建一个子进程. 父进程继续监听新连接, 而子进程负责处理客户请求. 客户端请求处理结束后, 子进程直接退出. 由于forking出来的进程并行地运行, 因此客户端无需等待. Windows暂时不支持forking.

from socketserver import TCPServer, ForkingMixIn, StreamRequestHandler
import socket

class Server(ForkingMixIn, TCPServer):
    pass

class Handler(StreamRequestHandler):
    def handle(self):
        addr = self.request.getpeername()
        print('Got connection from', addr)
        self.wfile.wirte('Thank you for connecting'.encode())

server = Server((socket.gethostname(), 1234), Handler)
server.serve_forever()

• 线程可以解决forking占用资源较多的问题, 因为所有位于同一个进程中的线程将共享内存. 这将会减少占用的资源, 但是同时又带来了另一个问题, 你必须确保每个线程不会彼此干扰或者同时修改一项数据, 否则会引起混乱. 因此使用线程时必须去处理同步问题.

from socketserver import TCPServer, ThreadingMixIn, StreamRequestHandler
import socket
class Server(ThreadingMixIn, TCPServer):
    pass

class Handler(StreamRequestHandler):
    def handle(self):
        addr = self.request.getpeername()
        print('Got connection from', addr)
        self.wfile.write('Thank you for connecting'.encode())

server = Server((socket.gethostname(), 1234), Handler)
server.serve_forever()

• 还有一种避免线程和forking的方法是使用Stackless Python, 它是一个能够快速而轻松地在不同上下文之间切换的Python版本, 支持一种类似于线程的并行方式, 名为微线程, 其伸缩性比真正的线程高的多.

• 在较低层次使用异步I/O较为困难, 其基本机制是在模块select中使用select方法. 不过现在有用于实现异步I/O的高级框架, 使其能够通过简单而抽象的接口使用可伸缩性的强大机制. 该框架由asyncore和asynchat组成.

• 使用select和poll实现异步I/O, 当服务器与客户端通信时, 来自客户端的数据可能时断时续. 如果使用了forking和线程化, 就可以解决这种问题, 因为总有一个进程或线程在处理数据, 其他进程或线程可继续处理其客户端. 另一种做法是只处理当前正在通信的客户端, 你甚至无需不断监听, 只需监听后将客户端加入队列即可.这就是框架asyncore/asynchat和Twisted采取的方法. 这种功能的基石是函数select或poll, poll的伸缩性更高, 但只有Unix支持(Windows不支持).

• select()方法需要3个序列作为它的必选参数,此外还有一个可选的以秒为单位的超时时间作为第四个参数. 3个序列用于输入, 输出以及异常情况. 如果没有给定超时时间, select会阻塞(处于等待状态), 直到其中的一个文件描述符已经为行动做好了准备; 如果给定了超时时间, select最多阻塞给定的超时时间, 如果给定的超时时间是0, 那么就给出一个连续的poll(既不阻塞). select的返回值是三个序列, 每个代表相应参数的一个活动子集.

import socket, select
s = socket.socket()
host = socket.gethostname()
port = 1234
s.bind((host, port))
s.listen(5)
inputs = [s]
while True:
    rs, ws, es = select.select(inputs,[],[]) #如果没有输入会阻塞
    for r in rs:
        if r is s: #如果是新的服务器,那么就进行监听
            c, addr = s.accept()
            print('Got connection from ', addr)
            inputs.append(r) #将新连接过来的client放入输出list
        else: #如果client端准备就绪,则尝试读取数据
            try:
                data = r.receive(1024)
                disconnected = not data
            except socket.error:
                disconnected = True
            if disconnected:
                print(r.getpeername(), ' disconnected')
                inputs.remove(r)
            else:
                print(data)

• poll()方法使用起来比select简单一些. 在调用poll时, 会得到一个poll对象. 然后就可以使用poll对象的register方法注册一个文件描述符(或者是带有fileno方法的对象). 注册后可以使用unregister方法移除注册的对象. 注册了一些对象(比如socket)之后, 就可以调用poll方法并且得到一个(fd, event)的tuple列表(可能为空), 其中fd是文件描述符, event则告诉你发生了什么.event是一个位掩码(bitmask), 意思是它是一个整数,这个整数的每个位对应不同的事件. 所以我们需要在这里使用位操作符(&).

import socket, select
s = socket.socket()
host = socket.gethostname()
port = 1234
s.bind((host, port))
s.listen(5)
fdmap = {s.fileno(): s}
p = select.poll()
p.register(s)
while True:
    events = p.poll()
    for fd, event in events:
        if fd == s.fileno():
            c, addr = s.accept()
            print('Got connection from ', addr)
            p.register(c)
            fdmap[c.fileno()] = c
        elif event & select.POLLIN:
            data = fdmap[fd].recv(1024)
            if not data:
                print(fdmap[fd].getpeername(), ' disconnected')
                p.unregister(fd)
                del fdmap[fd]
        else:
            print(data)

[eziceice]

小结

• Socket以及Socket模块, 进程之间进行通信的信息通道可能会通过网络来通信. socket模块给提供了对客户端和服务端socket的低级访问功能. 服务器端socket会在指定的地址监听客户端的连接, 而客户机是直接连接的.

• urllib和urllib2, 这些模块可以在给出数据源url时让从不同的服务器读取和下载数据. urllib模块是一个简单一些的实现, 而urllib2是可扩展的, 而且十分强大.

• SocketServer框架, 这是一个同步的网络服务器基类. 位于标准库中, 使用它可以很容易地编写服务器. 它甚至用CGI支持简单的Web服务(Http). 如果想同时处理多个连接, 可以使用forking或者threading来处理混入类.

• select和poll, 这两个函数让你可以考虑一组连接并且能找出已经准备好读取或者写入的连接. 这就意味着能为通过时间片轮转来为几个连接提供服务. 看起来就像是同时处理几个连接. 尽管代码可能更复杂一点, 但在伸缩性和效率上要比threading或者forking好得多.

• Twisted, to be continued.