Socket 编程
Socket通讯原理描述：
套接字是为特定网络协议（例如TCP/IP，ICMP/IP，UDP/IP等）套件对上的网络应用程序提供者提供当前可移植标准的对象。它们允许程序接受并进行连接，如发送和接受数据。为了建立通信通道，网络通信的每个端点拥有一个套接字对象极为重要。和大多数语言一样，Python 支持面向连接和无连接，实现接口功能与步骤也大致相同。
面向连接即需要先连接然后通讯， 面向连接主要协议就是传输控制协议(tcp)，要创建tcp套接字时需要指定套接字类型为 SOCK_STRAM,表达了他作为流套接字的特点。
无连接，顾名思义无需建立连接就可以进行通讯，这时数据到达顺序、可靠性就无法保证了。实现这种连接的协议就是用户数据包协议（udp）。创建UDP时需要指定套接字类型为 SOCK_DGRAM。
服务器端通常是用来处理数据的，客户端是用来请求数据的。服务端可以同时处理多条数据。
同一个80端口
TCP服务器端：
1. 第一步是创建socket对象。调用socket构造函数。如：
socket = socket.socket( family, type )
family参数代表地址家族，可为AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用于同一台机器上的进程间通信。
type参数代表套接字类型，可为SOCK_STREAM(流套接字)和SOCK_DGRAM(数据报套接字)。
2. 第二步是将socket绑定到指定地址。这是通过socket对象的bind方法来实现的：
socket.bind( address )
由AF_INET所创建的套接字，address地址必须是一个双元素元组，格式是(host,port)。host代表主机，port代表端口号。如果端口号正在使用、主机名不正确或端口已被保留，bind方法将引发socket.error异常。
3. 第三步是使用socket套接字的listen方法接收连接请求。
socket.listen( backlog )
backlog指定最多允许多少个客户连接到服务器。它的值至少为1。收到连接请求后，这些请求需要排队，如果队列满，就拒绝请求。
4. 第四步是服务器套接字通过socket的accept方法等待客户请求一个连接。
connection, address = socket.accept()
调 用accept方法时，socket会时入“waiting”状态。客户请求连接时，方法建立连接并返回服务器。accept方法返回一个含有两个元素的 元组(connection,address)。第一个元素connection是新的socket对象，服务器必须通过它与客户通信；第二个元素 address是客户的Internet地址。
5. 第五步是处理阶段，服务器和客户端通过send和recv方法通信(传输 数据)。服务器调用send，并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接收信息。调用recv 时，服务器必须指定一个整数，它对应于可通过本次方法调用来接收的最大数据量。recv方法在接收数据时会进入“blocked”状态，最后返回一个字符 串，用它表示收到的数据。如果发送的数据量超过了recv所允许的，数据会被截短。多余的数据将缓冲于接收端。以后调用recv时，多余的数据会从缓冲区 删除(以及自上次调用recv以来，客户可能发送的其它任何数据)。
6. 传输结束，服务器调用socket的close方法关闭连接
伪代码大致如下：
1 创建套接字，绑定套接字到当地地址，然后开始监听连接。就是socket，bind，listen。
2 进入循环，不断接受客户端的连接请求，然后接收传来的数据，当然也可以发送给对方数据。就是accept一个连接，然后recv数据。
3 接收完毕可以关闭套接字，close。
ss.socket(Socket.AF_INET,Socket.SOCK_STRAM) #创建服务器套接字
ss.bind() #把本地地址绑到套接字上
ss.listen() #监听连接
inf_loop: #服务器无限循环
cs=ss.accept() #接受客户端的连接
comm._loop: #通信循环
cs.recv()/cs.send() #对话
cs.close() #关闭客户套接字
ss.close() #关闭服务器套接字
TCP客户端：
1. 第一步是创建一个socket以连接服务器：socket = socket.socket( family, type )
2. 第二步是使用socket的connect方法连接服务器。对于AF_INET家族,连接格式如下：
socket.connect( (host,port) )
host代表服务器主机名或IP，port代表服务器进程所绑定的端口号。如连接成功，客户就可通过套接字与服务器通信，如果连接失败，会引发socket.error异常。
3. 第三步是处理阶段，客户和服务器将通过send方法和recv方法通信。
4. 传输结束，客户通过调用socket的close方法关闭连接。
伪代码如下：
1 创建套接字，然后连接远端地址，socket ，connect。
2 建立连接之后开始发送数据。Send（data），当然可以从缓冲区读取服务器发来的数据。Recv（BUFF）
3 完毕后，关闭套接字。Close
cs=socket(Socket.AF_INET,Socket.SOCK_DGRAM)
#创建客户套接字
cs.connect() #尝试连接服务器
comm._loop: #通信循环
cs.send()/cs.recv() #对话
cs.close() #关闭套接字
简单的server 端和客户端（tcp协议）
服务端
import socket #socket模块
import commands #执行系统命令模块
HOST='127.0.0.1'
PORT=8085
s= socket.socket(socket.AF_INET,socket.SOCK_STREAM) #定义socket类型，网络通信，TCP协议，前面是ipv4协议，后面的tcp协议。
s.bind((HOST,PORT)) #套接字绑定的IP与端口，host用0.0.0.1就会包含本机的所有ip
s.listen(1) #开始TCP监听，listen中的参数表示可以多少客户端来进行连接
while 1:
conn,addr=s.accept() #接受TCP连接，并返回新的套接字与IP地址
print'Connected by',addr #输出客户端的IP地址
while 1:
data=conn.recv(1024) #把接收的数据实例化
print data
conn.sendall('got message from server:'+data.upper())
conn.close() #关闭连接
客户端：
import socket
HOST='127.0.0.1'
PORT=8085
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #定义socket类型，网络通信，TCP
s.connect((HOST,PORT)) #要连接的IP与端口
while 1:
cmd=raw_input("Please input cmd:") #与人交互，输入命令
s.sendall(cmd) #把命令发送给对端
data=s.recv(1024) #把接收的数据定义为变量
print data #输出变量
s.close() #关闭连接
变形：把上面的代码改成只能发3次
netstat -ano|findstr "1104" 查看windows上某个端口是否被占用
netstat -anp|grep 8080 linux使用的
服务端：
import socket #socket模块
import commands #执行系统命令模块
HOST='127.0.0.1'
PORT=8085
s= socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#定义socket类型，网络通信，TCP
s.bind((HOST,PORT)) #套接字绑定的IP与端口
s.listen(5)
#开始TCP监听，listen中的参数表示可以多少客户端来进行连接
while 1:
conn,addr=s.accept() #接受TCP连接，并返回新的套接字与IP地址
print'Connected by',addr #输出客户端的IP地址
while 1:
try:
data=conn.recv(1024) #把接收的数据实例化
print data
conn.sendall('got message from server:'+data.upper())
except Exception:
conn.close() #关闭连接
break
客户端：
import socket
HOST='127.0.0.1'
PORT=8085
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
#定义socket类型，网络通信，TCP
s.connect((HOST,PORT)) #要连接的IP与端口
times=3
while times>0:
cmd=raw_input("Please input cmd:") #与人交互，输入命令
s.sendall(cmd) #把命令发送给对端
data=s.recv(1024) #把接收的数据定义为变量
print data #输出变量
times-=1
s.close() #关闭连接
稍微复杂一点的客户端例子
服务端：
import time
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8009))
sock.listen(5)
while True:
time.sleep(0.1)
connection,address = sock.accept()
while 1:
try:
connection.settimeout(5)
buf = connection.recv(1024)
print "got message from client:",buf
if buf == '1':
print "1"
connection.send('welcome to server!')
elif buf == '2':
connection.send('please go out!')
elif buf == "close":
connection.send('bye!')
connection.close()
break
except socket.timeout:
print 'time out'
connection.close()
break
except Exception,e:
print e
connection.close()
break
客户端：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8009))
import time
time.sleep(2)
sock.send('2')
print sock.recv(1023)
sock.send('1')
print sock.recv(1024)
sock.send('close')
print sock.recv(1024)
print "Done!"
sock.close()
变形练习：服务端把客户端传来的消息全部存入文件中，然后给客户端回传一句话。
自己：
服务端：
import time
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 10015))
sock.listen(5)
while True:
time.sleep(0.1)
connection,address = sock.accept()
while 1:
try:
connection.settimeout(5)
buf = connection.recv(1024)
print "got message from client:",buf
fp = open("e:\test1.txt", "a")
if buf == "close":
connection.send('bye!')
connection.close()
break
else:
fp.write(buf+"
")
#fp.write("
")
fp.close()
except socket.timeout:
print 'time out'
connection.close()
break
except Exception,e:
print e
connection.close()
break
客户端：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 10015))
import time
time.sleep(2)
sock.send('2')
sock.send('1')
sock.send('close')
print "Done!"
sock.close()
老师：
>>> import traceback
>>> try:
... 1/0
... except:
... print "error"
...
error
>>> try:
... 1/0
... except Exception,e:
... print e
...
integer division or modulo by zero
>>> try:
... 1/0
... except:
... traceback.print_exc()
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
ZeroDivisionError: integer division or modulo by zero
服务端：
# encoding=utf-8
import time
import random
import traceback
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8009))
sock.listen(5)
AI_robot =[u'吃了么？',u"最近涨工资了么？",u"记得找对象",u"记得减肥"]
while True:
time.sleep(0.1)
connection,address = sock.accept()
while 1:
try:
connection.settimeout(5)
buf = connection.recv(1024)
fp=open("e:\chat_record.txt","a")
print "got message from client:",buf.decode("utf-8")
if buf == "close":
connection.send('bye!')
connection.close()
break
elif buf=='q':
connection.close()
break
else:
fp.write(buf+"
")
connection.send(str(time.ctime())+AI_robot[random.randint(0,3)].encode("utf-8"))
fp.close()
except socket.timeout:
print 'time out'
traceback.print_exc()
connection.close()
break
except Exception,e:
traceback.print_exc()
print e
connection.close()
break
客户端：
# encoding=utf-8
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8009))
import time
while 1:
try:
data=raw_input("say to server:")
sock.send(data.decode("gbk").encode("utf-8"))
print sock.recv(1023).decode("utf-8")
if data == "q":
sock.close()
break
except:
print "exception"
print "Done!"
实现一个类似ssh的功能（仅支持Linux操作系统）
ip：39.106.41.11
username：student
password：gloryroad987!
服务器端：
import commands
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8008))
sock.listen(5)
while True:
connection,address = sock.accept()
try:
connection.settimeout(5)
command = connection.recv(1024)
print command
code,result=commands.getstatusoutput(command)
print code
print result
except socket.timeout:
print 'time out'
connection.close()
客户端：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8008))
import time
time.sleep(2)
sock.send('ls -al /home/wxh')
print sock.recv(1024)
sock.close()
服务器端：
import commands
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('localhost', 8001))
sock.listen(5)
while True:
connection,address = sock.accept()
try:
connection.settimeout(5)
command = connection.recv(1024)
print command
code,result=commands.getstatusoutput(command)
print code
print result
connection.send(str(code))
connection.send(result)
except socket.timeout:
print 'time out'
connection.close()
客户端：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8001))
import time
time.sleep(2)
sock.send('ls -al /home/wxh')
print "command status:",sock.recv(1)
print "command result:",sock.recv(1024)
sock.close()
使用Socket 传送一个文件
服务器端
#-*- coding: UTF-8 -*-
import socket,time,SocketServer,struct,os,thread
host='127.0.0.1'
port=12307
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM) #定义socket类型
s.bind((host,port)) #绑定需要监听的Ip和端口号，tuple格式
s.listen(1)
def conn_thread(connection,address):
while True:
try:
connection.settimeout(600) #设置连接时间
fileinfo_size=struct.calcsize('128sl') #文件信息
buf = connection.recv(fileinfo_size) #接收此文件的信息在buf里面
if buf: #如果不加这个if，第一个文件传输完成后会自动走到下一句，需要拿到文件大小信息才可以继续执行
filename,filesize =struct.unpack('128sl',buf) #解包，解开后是两个值
filename_f = filename.strip(' 0') #解出文件名，去掉C语言中的字符串 0结束
filenewname = os.path.join('e:\',('new_'+ filename_f))
print 'file new name is %s, filesize is %s' %(filenewname,filesize)
recvd_size = 0 #定义接收了的文件大小
file = open(filenewname,'wb')
print 'stat receiving...'
while not recvd_size == filesize: #判断收到的和原有文件是不是一样大，不一样继续接收
if filesize - recvd_size > 1024:
rdata = connection.recv(1024)
recvd_size += len(rdata)
else:
rdata = connection.recv(filesize - recvd_size) #接收到的文件和告知的一样大了，停止接收，判定为接收完毕
recvd_size = filesize
file.write(rdata)
file.close()
print 'receive done'
#connection.close()
except socket.timeout:
connection.close()
while True:
connection,address=s.accept()
print('Connected by ',address)
#thread = threading.Thread(target=conn_thread,args=(connection,address)) #使用threading也可以
#thread.start()
thread.start_new_thread(conn_thread,(connection,address))
s.close()
客户端
#-*- coding: UTF-8 -*-
import socket,os,struct
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',12307))
while True:
filepath = raw_input('Please Enter chars: ')
if os.path.isfile(filepath):
fileinfo_size=struct.calcsize('128sl') #定义打包规则
#定义文件头信息，包含文件名和文件大小
fhead = struct.pack('128sl',os.path.basename(filepath),os.stat(filepath).st_size)
s.send(fhead)
print 'client filepath: ',filepath
# with open(filepath,'rb') as fo: 这样发送文件有问题，发送完成后还会发一些东西过去
fo = open(filepath,'rb')
while True:
filedata = fo.read(1024)
if not filedata:
break
s.send(filedata)
fo.close()
print 'send over...'
#s.close()
SocketServer模块的Fork方式（进程模式）linux 下执行
Server 端代码
#!/usr/bin/python
#encoding=utf-8
from SocketServer import TCPServer, ForkingMixIn, StreamRequestHandler
import time
class Server(ForkingMixIn, TCPServer): #自定义Server类 ，以进程模式启动
pass
class MyHandler(StreamRequestHandler):
def handle(self): #重载handle函数
addr = self.request.getpeername()
print 'Get connection from', addr #打印客户端地址
data= self.rfile.readline().strip() #客户端发送的信息必须带有回车，否则会一直等待客户端继续发送数据
print data
time.sleep(1) #休眠5秒钟
if data:
self.wfile.write('This is a ForkingMixIn tcp socket server') #给客户端发送信息
host = '127.0.0.1'
port = 8009
server = Server((host, port), MyHandler)
server.serve_forever() #开始侦听并处理连接
客户端：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8009))
import time
time.sleep(2)
sock.send('ls -al /home/wxh'+" ")
print sock.recv(1024)
sock.close()
注释：
多个连接同时到达服务器端的时候，每个连接主进程都生成一个子进程专门用来处理此连接，而主进程则依旧保持在侦听状态。因主进程和子进程是同时进行的，所以不会阻塞新的连接。但由于生成进程消耗的资源比较大，这种处理方式在有很多连接的时候会带来性能问题。Server类须继承ForkingMixIn和TCPServer两个类。
SocketServer模块的Fork方式（线程模式）linux 下执行
服务器端代码：
#!/usr/bin/python
#encoding=utf-8
from SocketServer import TCPServer, ThreadingMixIn, StreamRequestHandler
import time
class Server(ThreadingMixIn, TCPServer): #自定义Server类 ,以线程方式启动
pass
class MyHandler(StreamRequestHandler):
def handle(self): #重载handle函数
addr = self.request.getpeername()
print 'Get connection from', addr #打印客户端地址
data= self.rfile.readline().strip() #客户端发送的信息必须带有回车，否则会一直等待客户端继续发送数据
print data
time.sleep(1) #休眠5秒钟
if data:
self.wfile.write('This is a ForkingMixIn tcp socket server') #给客户端发送信息
host = '127.0.0.1'
port = 8001
server = Server((host, port), MyHandler)
server.serve_forever() #开始侦听并处理连接
线程是一种轻量级的进程，比Fork消耗的资源更少，而且主线程和子线程之间具有相同的地址空间，处理效率高。但大量的使用线程会带来线程之间的数据同步问题，处理不好可能使服务程序失去响应。上述与Fork方式中代码基本相同，仅仅是采用的ThreadingMixIn类不同。
SocketServer模块的Threading线程池方式
import SocketServer
import threading
class MyTCPHandler(SocketServer.BaseRequestHandler):
def handle(self):
while True:
self.data = self.request.recv(1024).strip()
cur_thread = threading.current_thread()
print cur_thread
if not self.data:
print "client:%s leave!" % self.client_address[0]
break
print "%s wrote:%s" % (self.client_address[0], self.data)
self.request.sendall(self.data.upper())
if __name__ == "__main__":
HOST, PORT = "127.0.0.1",8044
server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
server.serve_forever()
if __name__ == "__main__":
HOST, PORT = "127.0.0.1",8001
server = SocketServer.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
server.serve_forever()
#服务器可以自动判断客户端是否还会发送数据
客户端程序：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8044))
import time
time.sleep(2)
sock.send('ls -al /home/wxh'+" ")
print sock.recv(1024)
sock.close()
使用socketserver 传送一个文件
服务端：
#-*- coding: UTF-8 -*-
import socket,time,SocketServer,struct,os
host='127.0.0.1'
port=12307
ADDR=(host,port)
class MyRequestHandler(SocketServer.BaseRequestHandler):
def handle(self):
print('connected from:', self.client_address)
while True:
fileinfo_size=struct.calcsize('128sl') #定义文件信息。128s表示文件名为128bytes长，l表示一个int或log文件类型，在此为文件大小
self.buf = self.request.recv(fileinfo_size)
if self.buf: #如果不加这个if，第一个文件传输完成后会自动走到下一句
self.filename,self.filesize =struct.unpack('128sl',self.buf) #根据128sl解包文件信息，与client端的打包规则相同
print 'filesize is: ',self.filesize,'filename size is: ',len(self.filename) #文件名长度为128，大于文件名实际长度
self.filenewname = os.path.join('e:\',('new_'+ self.filename).strip(' 0')) #使用strip()删除打包时附加的多余空字符
print self.filenewname,type(self.filenewname)
recvd_size = 0 #定义接收了的文件大小
file = open(self.filenewname,'wb')
print 'stat receiving...'
while not recvd_size == self.filesize:
if self.filesize - recvd_size > 1024:
rdata = self.request.recv(1024)
recvd_size += len(rdata)
else:
rdata = self.request.recv(self.filesize - recvd_size)
recvd_size = self.filesize
file.write(rdata)
file.close()
print 'receive done'
#self.request.close()
tcpServ = SocketServer.ThreadingTCPServer(ADDR, MyRequestHandler)
print('waiting for connection...' )
tcpServ.serve_forever()
客户端：
#-*- coding: UTF-8 -*-
import socket,os,struct
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(('127.0.0.1',12307))
while True:
filepath = raw_input('Please Enter chars: ')
if os.path.isfile(filepath):
fileinfo_size=struct.calcsize('128sl') #定义打包规则
#定义文件头信息，包含文件名和文件大小
fhead = struct.pack('128sl',os.path.basename(filepath),os.stat(filepath).st_size)
s.send(fhead)
print 'client filepath: ',filepath
# with open(filepath,'rb') as fo: 这样发送文件有问题，发送完成后还会发一些东西过去
fo = open(filepath,'rb')
while True:
filedata = fo.read(1024)
if not filedata:
break
s.send(filedata)
fo.close()
print 'send over...'
#s.close()
Select :
I/O多路复用是在单线程模式下实现多线程的效果，实现一个多I/O并发的效果。
进程指定内核监听哪些文件描述符(最多监听1024个fd)的哪些事件，当没有文件描述符事件发生时，进程被阻塞；当一个或者多个文件描述符事件发生时，进程被唤醒。
当我们调用select()时：
1、上下文切换转换为内核态
2、将fd从用户空间复制到内核空间
3、内核遍历所有fd，查看其对应事件是否发生
4、如果没发生，将进程阻塞，当设备驱动产生中断或者timeout时间后，将进程唤醒，再次进行遍历
5、返回遍历后的fd
6、将fd从内核空间复制到用户空间
一个任务：
1 www.sohu.com
2 www.sogou.com
3 www.gloryroad.cn
4 www.baidu.com
单进程或者单线程：
1->2->3-4
多进程或者多线程：
一个线程、一个进程：去执行一个访问
select:
1 个线程：
1 www.sohu.com
5秒
2 www.sogou.com
4秒
3 www.gloryroad.cn
3秒
4 www.baidu.com
2秒 select不会等，一直发请求，哪个先返回用哪个。
fd:file descriptor 文件描述符
fd_r_list, fd_w_list, fd_e_list = select.select(rlist, wlist, xlist, [timeout])
参数： 可接受四个参数（前三个必须）
rlist: wait until ready for reading
wlist: wait until ready for writing(一般不使用)
xlist: wait for an “exceptional condition”
timeout: 超时时间
Server端：
import socket
import select
s = socket.socket()
s.bind(('127.0.0.1',8888))
s.listen(5)
r_list = [s,]
num = 0
while True:
rl, wl, error = select.select(r_list,[],[],10) #r_list读的句柄，[][]后面两个是异常的句柄，10是超时
执行过程：
#第一次执行循环体：客户端建立的连接的时候，rl和r_list分别是[s,]和[s,]
# 执行连接之后，r_list变为了[s,conn]
#第二次执行循环体：rl和r_list分别是[conn,]和[s,conn]
num+=1
print('counts is %s'%num)
print("rl's length is %s"%len(rl))
for fd in rl:
if fd == s:
conn, addr = fd.accept()
r_list.append(conn)
msg = conn.recv(200)
conn.sendall(('first----%s'%conn.fileno()).encode())
else:
try:
msg = fd.recv(200)
fd.sendall('second'.encode())
except ConnectionAbortedError:
r_list.remove(fd)
s.close()
客户端：
import socket
flag = 1
s = socket.socket()
s.connect(('127.0.0.1',8888))
while flag:
input_msg = input('input>>>')
if input_msg == '0':
break
s.sendall(input_msg.encode())
msg = s.recv(1024)
print(msg.decode())
s.close()
#注意客户端输入的数据需要外带引号，例如：’hi’
Twisted 框架
服务器端：
# coding=utf-8
from twisted.internet.protocol import Protocol
from twisted.internet.protocol import Factory
from twisted.internet.endpoints import TCP4ServerEndpoint
from twisted.internet import reactor
clients = []
class Spreader(Protocol):
def __init__(self, factory):
self.factory = factory
def connectionMade(self):
self.factory.numProtocols = self.factory.numProtocols + 1
self.transport.write(
"欢迎来到Spread Site, 你是第%s个客户端用户! " % (self.factory.numProtocols)
)
print "new connect: %d" % (self.factory.numProtocols)
clients.append(self)
def connectionLost(self, reason):
self.factory.numProtocols = self.factory.numProtocols - 1
clients.remove(self)
print "lost connect: %d" % (self.factory.numProtocols)
def dataReceived(self, data):
print "received data:",data
self.transport.write(data)
class SpreadFactory(Factory):
def __init__(self):
self.numProtocols = 0
def buildProtocol(self, addr):
return Spreader(self)
endpoint = TCP4ServerEndpoint(reactor, 8007)
endpoint.listen(SpreadFactory())
reactor.run()
客户端：
# coding=utf-8
from twisted.internet.protocol import Protocol, ClientFactory
from twisted.internet import reactor
import threading
import time
import sys
import datetime
class Echo(Protocol):
def __init__(self):
self.connected = False
def connectionMade(self):
self.connected = True
def connectionLost(self, reason):
self.connected = False
def dataReceived(self, data):
print "data from server:",data.decode("utf-8")
class EchoClientFactory(ClientFactory):
def __init__(self):
self.protocol = None
def startedConnecting(self, connector):
print "Start to Connect..."
def buildProtocol(self, addr):
print "Connected..."
self.protocol = Echo()
return self.protocol
def clientConnectionLost(self, connector, reason):
print "Lost connection. Reason: ", reason
def clientConnectionFailed(self, connector, reason):
print "Connection is failed, Reason: ", reason
bStop = False
def routine(factory):
while not bStop:
if factory.protocol and factory.protocol.connected:
factory.protocol.transport.write("hello, I'm %s %s" % (
sys.argv[0], datetime.datetime.now()
))
print sys.argv[0], datetime.datetime.now()
time.sleep(5)
host = '127.0.0.1'
port = 8007
factory = EchoClientFactory()
reactor.connectTCP(host, port, factory)
threading.Thread(target=routine, args=(factory,)).start()
reactor.run()
bStop = True
——————————————————————————————————————
#!/usr/bin/python
#encoding=utf-8
from twisted.internet import reactor
from twisted.internet.protocol import Protocol, Factory
class EchoServer(Protocol):
def connectionMade(self): #连接建立的时候
print 'Get connection from', self.transport.client
self.factory.numProtocols = self.factory.numProtocols+1
if self.factory.numProtocols > 2: #当连接超过2个的时候，断开连接
self.transport.write("Too many connections, try later ")
self.transport.loseConnection()
return
print 'Get connection from', self.transport.client
def connectionLost(self, reason): #断开连接
self.factory.numProtocols = self.factory.numProtocols-1
def dataReceived (self, data): #将收到的数据返回给客户端
self.transport.write(data)
print data
self.transport.loseConnection() #收到数据后就断开
factory = Factory()
factory.numProtocols = 0
factory.protocol = EchoServer
port = 1200
reactor.listenTCP(port, factory)
reactor.run() #进入循环
客户端程序：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8001))
import time
time.sleep(2)
sock.send('ls -al /home/wxh'+" ")
print sock.recv(1024)
sock.close()
twisted 官网的例子，保存为echoServ.py：
#!/usr/bin/env python
# coding: utf-8
from twisted.internet.protocol import Protocol
from twisted.internet.protocol import Factory
from twisted.internet import reactor
class Echo(Protocol):
'''协议类实现用户的服务协议，例如 http,ftp,ssh 等'''
def __init__(self, factory):
self.factory = factory
def connectionMade(self):
'''连接建立时被回调的方法'''
self.factory.numProtocols = self.factory.numProtocols + 1
self.transport.write("Welcome! There are currently %d open connections. " %(self.factory.numProtocols,))
def connectionLost(self, reason):
'''连接关闭时被回调的方法'''
self.factory.numProtocols = self.factory.numProtocols - 1
def dataReceived(self, data):
'''接收数据的函数，当有数据到达时被回调'''
print data
self.transport.write(data)
class EchoFactory(Factory):
'''协议工厂类，当客户端建立连接的时候，创建协议对象，协议对象与客户端连接一一对应'''
numProtocols = 0
#protocol = Echo
def buildProtocol(self, addr):
return Echo(self)
if __name__ == '__main__':
# 创建监听端口
FACTORY = EchoFactory()
reactor.listenTCP(1200, FACTORY)
# 开始监听事件
reactor.run()
协议工厂继承自twisted.internet.protocol.Factory，需实现buildProtocol方法，协议工厂负责实例化协议类，不应该保存于连接相关的状态信息，因为协议工厂类仅创建一个。协议类继承自twisted.internet.protocol.Protocol，需实现dataReceived等方法，在协议类中实现应用协议，每一个客户端连接都会创建一个新的协议类对象。transport就是连接对象，通过它进行网络写数据。
客户端：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 1200))
import time
time.sleep(2)
sock.send('ls -al /home/wxh'+" ")
print sock.recv(1024)
sock.send('ls -al /home/wxh'+" ")
print sock.recv(1024)
sock.close()
使用守护进程来运行服务器端程序
使用守护进程的方式运行服务，需要提供一个tac配置文件（这就是一个python文件，只是扩展名不同），并且在这个文件中需要创建一个应用程序对象，对象名必须是application。
首先创建一个echo.tac文件：
#!/usr/bin/env python
# coding: utf-8
from twisted.application import service, internet
import sys
sys.path.append("e:\") #echoServ.py保存在哪个目录，就把这个路径设定到哪里
from echoServ import EchoFactory
# 创建应用程序对象
application = service.Application('Echo 服务程序')
# 创建 service 对象
myServices = internet.TCPServer(1200, EchoFactory())
# 设置 application 为 service 的父元素
myServices.setServiceParent(application)
然后用守护进程方式运行服务，运行命令：#twistd -y echo.tac。
若想要停止服务：#kill -15 (pid)。
客户端程序：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 1200))
import time
time.sleep(2)
sock.send('ls -al /home/wxh'+" ")
print sock.recv(1024)
sock.close()
聊天的服务器版本：
服务器端：
from twisted.internet import protocol, reactor
class Echo(protocol.Protocol):
def dataReceived(self, data):
# As soon as any data is received, write it back
self.transport.write(data)
print data
class EchoFactory(protocol.Factory):
def buildProtocol(self, addr):
return Echo()
reactor.listenTCP(8000, EchoFactory())
reactor.run()
客户端：
from twisted.internet import reactor, protocol
class EchoClient(protocol.Protocol):
def connectionMade(self):
self.transport.write("hello, world!")
def dataReceived(self, data):
print "Server said:", data
self.transport.loseConnection()
def connectionLost(self, reason):
print "connection lost"
class EchoFactory(protocol.ClientFactory):
def buildProtocol(self, addr):
return EchoClient()
def clientConnectionFailed(self, connector, reason):
print "Connection failed - goodbye!"
reactor.stop()
def clientConnectionLost(self, connector, reason):
print "Connection lost - goodbye!"
reactor.stop()
reactor.connectTCP("localhost", 8000, EchoFactory())
reactor.run()
写一个聊天的服务器：
服务器端：
#!/usr/bin/python
#encoding=utf-8
from twisted.internet.protocol import Factory
from twisted.protocols.basic import LineReceiver
from twisted.internet import reactor
class Chat(LineReceiver):
def __init__(self, users):
self.users = users
self.name = None
self.state = "GETNAME"
def connectionMade(self):
self.sendLine("What's your name? ")
def connectionLost(self, reason):
if self.users.has_key(self.name):
del self.users[self.name]
def lineReceived(self, line):
if self.state == "GETNAME":
self.handle_GETNAME(line)
else:
self.handle_CHAT(line)
def handle_GETNAME(self, name):
if self.users.has_key(name):
self.sendLine("Name taken, please choose another."+" ")
return
self.sendLine("Welcome, %s! " % (name,))
self.name = name
self.users[name] = self
self.state = "CHAT"
def handle_CHAT(self, message):
message = "<%s> %s " % (self.name, message)
for name, protocol in self.users.iteritems():
if protocol == self:
self.sendLine(message+" ")
class ChatFactory(Factory):
def __init__(self):
self.users = {} # maps user names to Chat instances
def buildProtocol(self, addr):
return Chat(self.users)
if __name__ == '__main__':
reactor.listenTCP(1200, ChatFactory())
reactor.run()
客户端1：
#socket client end
from socket import *
s=socket(AF_INET,SOCK_STREAM)
remote_host=gethostname()
print 'remote_host:',remote_host
port=1200
s.connect((remote_host,port)) #发起连接
print("Connected from",s.getsockname()) ##返回本地IP和端口
print("Connected to",s.getpeername()) ##返回服务端IP和端口
s.send('Jack ')#发送一行字符串（以 结束）到服务器端
s.send('hi ')
s.send('hello ')
print 'the msg i got from select server is:'
print s.recv(1200)
客户端2：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 1200))
import time
time.sleep(2)
sock.send('fosterwu ')
print sock.recv(1020)
sock.send('hi ')
print sock.recv(1020)
sock.send('good ')
print sock.recv(120)
sock.send('gloryroad ')
print sock.recv(120)
sock.close()
Twisted框架中对文件的操作
服务端：
工厂有startFactory和stopFactory两种方式来执行相关应用的创建与销毁，下述代码从客户端接收到的信息都会被写入文件中。
#!/usr/bin/env python
# coding: utf-8
from twisted.internet.protocol import Factory
from twisted.protocols.basic import LineReceiver
from twisted.internet import reactor
class LoggingProtocol(LineReceiver):
def lineReceived(self, line):
self.factory.fp.write(line+' ')
self.factory.fp.flush()
self.sendLine("got it!")
class LogfileFactory(Factory):
protocol = LoggingProtocol
def __init__(self, fileName):
self.file = fileName
def startFactory(self):
self.fp = open(self.file, 'a')
def stopFactory(self):
self.fp.close()
print "close"
if __name__ == '__main__':
# 创建监听端口
FACTORY = LogfileFactory("e:\a.txt")
reactor.listenTCP(8007, FACTORY)
# 开始监听事件
reactor.run()
客户端：
if __name__ == '__main__':
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('localhost', 8007))
import time
time.sleep(2)
sock.send('fosterwu ')
print sock.recv(1020)
sock.send('hi ')
print sock.recv(1020)
sock.send('good ')
print sock.recv(120)
sock.send('gloryroad ')
print sock.recv(120)
sock.close()
Udp Server 端：
from socket import *
from time import ctime
HOST = ''
PORT = 1200
BUFSIZ = 128
ADDR = (HOST, PORT)
#创建一个服务器端UDP套接字
udpServer = socket(AF_INET, SOCK_DGRAM)
#绑定服务器套接字
udpServer.bind(ADDR)
while True:
print 'waiting for message...'
#接收来自客户端的数据
data, addr = udpServer.recvfrom(BUFSIZ)
print "got message:",data
#向客户端发送数据
udpServer.sendto('[%s] %s' % (ctime(), data), addr)
print '...received from and returned to:', addr
udpServer.close()
Udp 的客户端：
#encoding=utf-8
from socket import *
HOST = 'localhost'
PORT = 1200
BUFSIZ = 128
ADDR = (HOST, PORT)
# 创建客户端UDP套接字
udpClient = socket(AF_INET, SOCK_DGRAM)
while True:
data = raw_input('>')
if not data:
break
# 向服务器端发送数据
udpClient.sendto(data, ADDR)
# 接收来自服务器端的数据
data, ADDR = udpClient.recvfrom(BUFSIZ)
print data
if not data:
break
udpClient.close()
参考文献：
http://blog.csdn.net/taiyang1987912/article/details/40376067
https://www.cnblogs.com/earendil/p/7411115.html
基于广播的聊天程序
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
SO_LINGER选项用来设置当调用closesocket时是否马上关闭socket；
SO_REUSEADDR用于对TCP套接字处于TIME_WAIT状态下的socket，才可以重复绑定使用。server程序总是应该在调用bind()之前设置SO_REUSEADDR套接字选项。TCP，先调用close()的一方会进入TIME_WAIT状态
服务器端：Linux可以执行
import socket, select
#Function to broadcast chat messages to all connected clients
def broadcast_data (sock, message):
#Do not send the message to master socket and the client who has send us the message
for socket in CONNECTION_LIST:
if socket != server_socket and socket != sock :
try :
socket.send(message)
except :
# broken socket connection may be, chat client pressed ctrl+c for example
socket.close()
CONNECTION_LIST.remove(socket)
if __name__ == "__main__":
# List to keep track of socket descriptors
CONNECTION_LIST = []
RECV_BUFFER = 4096 # Advisable to keep it as an exponent of 2
PORT = 6001
server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# this has no effect, why ?
server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_socket.bind(("0.0.0.0", PORT))
server_socket.listen(10)
# Add server socket to the list of readable connections
CONNECTION_LIST.append(server_socket)
print "Chat server started on port " + str(PORT)
while 1:
# Get the list sockets which are ready to be read through select
read_sockets,write_sockets,error_sockets = select.select(CONNECTION_LIST,[],[])
for sock in read_sockets:
#New connection
if sock == server_socket:
# Handle the case in which there is a new connection recieved through server_socket
sockfd, addr = server_socket.accept()
CONNECTION_LIST.append(sockfd)
print "Client (%s, %s) connected" % addr
broadcast_data(sockfd, "[%s:%s] entered room " % addr)
#Some incoming message from a client
else:
# Data recieved from client, process it
try:
#In Windows, sometimes when a TCP program closes abruptly,
# a "Connection reset by peer" exception will be thrown
data = sock.recv(RECV_BUFFER)
if data:
broadcast_data(sock, " " + '<' + str(sock.getpeername()) + '> ' + data)
except:
broadcast_data(sock, "Client (%s, %s) is offline" % addr)
print "Client (%s, %s) is offline" % addr
sock.close()
CONNECTION_LIST.remove(sock)
continue
server_socket.close()
客户端：
import socket, select, string, sys
def prompt() :
sys.stdout.write('<You> ')
sys.stdout.flush()
#main function
if __name__ == "__main__":
if(len(sys.argv) < 3) :
print 'Usage : python telnet.py hostname port'
sys.exit()
host = sys.argv[1]
port = int(sys.argv[2])
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(6)
# connect to remote host
try :
s.connect((host, port))
except :
print 'Unable to connect'
sys.exit()
print 'Connected to remote host. Start sending messages'
prompt()
while 1:
rlist = [sys.stdin, s]
#s.connect((host, port))
# Get the list sockets which are readable
read_list, write_list, error_list = select.select(rlist , [], [])
for sock in read_list:
#incoming message from remote server
if sock == s:
data = sock.recv(4096)
if not data :
print ' Disconnected from chat server'
sys.exit()
else :
#print data
sys.stdout.write(data)
prompt()
#user entered a message
else :
msg = sys.stdin.readline()
s.send(msg)
prompt()
执行：
需要多开几个客户端，才能看到广告效果，执行如下：
python client.py 127.0.0.1 6001
Unix下是sock,而windows下是winsock，中间语法有很多是不同的，所以windows运行client程序有问题