CentOS+postfix+ExtMail+amavisd-new+Spam_Locker+DSpam配置指南：八、配置管理后台-ExtMan

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'ryan'
import socket
conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
conn.bind(('127.0.0.1',9000))
conn.listen(5)
while True:
print "waiting receiving from client....."
connetcion,address=conn.accept()
data = connetcion.recv(1024)
print "received from %s,%s" %(address,data)
connetcion.send(data)
connetcion.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'ryan'

import socket
client_conn=socket.socket()
client_conn.connect(('127.0.0.1',9000))
input_data = raw_input("pls input:")
client_conn.send(input_data)
received_server=client_conn.recv(1024)
print "received data from server: %s:" % received_server
client_conn.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'ryan'
#!/usr/bin/env python
#coding:utf-8
import socket
#导入socket模块
#定义handle_request函数
def handle_request(client):
#定义变量buf等于类clinet下的方法recv接收的内容（这里内容是1024）
buf = client.recv(1024)
#定义send方法发送的内容
client.send("HTTP/1.1 200 OK\r\n\r\n")
client.send("Hello, World")
#定义main函数
def main():
#通过socket.socket类实例化一个对象sock，即创建一个连接
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#对象sock调用类socket中的方法bind，并传入参数'localhost'和8080；即指定地址和打开的端口
sock.bind(('localhost',8080))
#对象sock调用类socket中的方法listen并传入参数5，这里定义最大连接数，同时连接过来的连接数超过5就会被拒绝掉
sock.listen(5)
while True:
#sock对象调用accept方法等待客户端发送过来的请求；
#connection代表客户端sock对象，address连接过来的客户端IP地址;connection类似于土电话（两个易拉罐底部串个
#细线）细线。
这里就会阻塞，等待客户端连接过来
connection, address = sock.accept()
connection.recv(1024)
#通过connection(细线/管道)最多接收客户端发送过来请求的字节数（这里定义1024）,
这里
#就会阻塞，等待客户端发送数据

#handle_request(connection)
#connection调用send方法发送数据，这里发送数据实际上是往缓冲区发，然后让缓冲区
#根据自己的算法发送出去（到客户端，这里的数据是"HTTP/1.1 200 OK\r\n\r\n"和"Hello,world"）
connection.send("HTTP/1.1 200 OK\r\n\r\n")
connection.sendall("HTTP/1.1 200 OK\r\n\r\n")
#sendall也是往缓冲区发，发完会后缓冲区立即发送出去不用再调用缓冲区的算法
connection.send("Hello, World")
#关闭连接端口
connection.close()
if __name__ == '__main__':
main()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'ryan'
import socket
#通过socket实例化一个对象obj
obj=socket.socket()
#调用socket类中的方法connect,并传入参数（localhost,8080）;换句话说建立连接
obj.connect(('localhost',8080))
#对象obj调用send方法传入参数"this is a client";即发送数据到服务端
obj.send("this is a client")
#对象obj调用recv方法接收数据，传入参数1024；即最大接收字节数为1024个
recv_server_data=obj.recv(1024)
print recv_server_data
#obj调用socket类中的方法close；即关闭连接
obj.close()

D:\Python27\python.exe C:/Users/ryan/PycharmProjects/day08/clientdemo.py
HTTP/1.1 200 OK

import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
sk.bind(ip_port)
while True:
data = sk.recv(1024)
print data
import socket
ip_port = ('127.0.0.1',9999)
sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)
while True:
inp = raw_input('数据：').strip()
if inp == 'exit':
break
sk.sendto(inp,ip_port)
sk.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
ip_port = ('127.0.0.1',8888)
sk = socket.socket()
sk.bind(ip_port)
sk.listen(5)
while True:
conn,address =  sk.accept()
conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
Flag = True
while Flag:
data = conn.recv(1024)
if data == 'exit':
Flag = False
elif data == '0':
conn.sendall('通过可能会被录音.balabala一大推')
else:
conn.sendall('请重新输入.')
conn.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
ip_port = ('127.0.0.1',8005)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)
while True:
data = sk.recv(1024)
print 'receive:',data
inp = raw_input('please input:')
sk.sendall(inp)
if inp == 'exit':
break
sk.close()

SocketServer模块

SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器是创建一个“线程”或者“进 程” 专门负责处理当前客户端的所有请求。

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'ryan'

import SocketServer

import os
class MyServer(SocketServer.BaseRequestHandler):

def handle(self):
#print self.request,self.client_address,self.server
print "got connection from", self.client_address
while True:
data = self.request.recv(1024)
print "Recv from  cmd:%s" %(data)

cmd_res = os.popen(data).read()
print 'cmd_res:',len(cmd_res)
self.request.send(str(len(cmd_res)))
self.request.recv(1024)#接收一次，将第一次与第二次之间数据隔开，解决连包问题
self.request.sendall(cmd_res)

if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
server.serve_forever()

代码说明:
server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
#实际上是实例化一个对象server，而参数(('127.0.0.1',8009),MyServer)是定义启动服务的地址和端口，MyServer其实是将上面定义的MyServer类进行实例化，换句话说就是当每次一个请求过来就通过server来实例化一个线程，即创建一个MyServer实例；
具体解释为:每一个客户端请求过来，类ThreadingTCPServer就会把类MyServer进行实例化一次，另外实例化之后服务端要跟客户端进行交互，那么交互的方式就是通过类MyServer中定义的handle方法来实现，然后调用类ThreadingTCPServer中的server_forever方法来启动服务.
另外MyServer类中因为继承了类BaseRequestHandler，所以在MyServer类定义handle方法的实质是对BaseRequestHandler类中的handle方法的改写，因为BaseRequestHandler类的代码中
有定义handle方法：源码如下:
class BaseRequestHandler:
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
self.setup()
try:
self.handle()
finally:
self.finish()
def setup(self):
pass
def handle(self):
pass
def finish(self):
pass
所以在语句server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)中，
其实就是传递两个参数给ThreadingTCPServer类进行创建实例，server.serve_forever()语句其实就是一个while循环，与以前写的，如下:
while True:
print "waiting receiving from client....."
connetcion,address=conn.accept()
data = connetcion.recv(1024)
print "received from %s,%s" %(address,data)
connetcion.send(data)
connetcion.close()
类似，当然这个不是accept，而是用的select，一直循环，当一个请求过来了，就会把上一句(server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer))中传递过来的参数MyServer类名后加一个括号，即MyServer()进行实例化，所以每次客户端请求过来，
都会执行一个MyServer()实例操作，即实例化一个对象，而实例化一个对象之后，就要执行类
MyServer的__init__方法，但是我们现在定义的类MyServer中没有__init__方法，所以就要到父类中继续查找__init__方法，即:
def __init__(self, request, client_address, server):
self.request = request
self.client_address = client_address
self.server = server
self.setup()
try:
self.handle()
finally:
self.finish()
def setup(self):
pass
def handle(self):
pass
def finish(self):
pass
由于父类中定义了handle方法，而且在try self.handle执行了handle方法，因为在父类中handle方法为空，所以就继续执行子类MyServer中定义的handle方法，这也是为什么我们在定义MyServer类中再定义一个方法时必须取名为handle而不能用其他名字

socket
ip_port = ()
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout()
:
inp = ()
sk.sendall(inp)
res_size=sk.recv()
res_size(res_size)
total_size = (res_size)
sk.send(inp)received_size=:
data=sk.recv()
received_size += (data)
total_size == received_size:
data
data
inp == :
sk.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'ryan'
import SocketServer
import os
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
#print self.request,self.client_address,self.server
print "got connection from", self.client_address
while True:
data = self.request.recv(1024)
print "Recv from  cmd:%s" %(data)
cmd_res = os.popen(data).read()
print 'cmd_res:',len(cmd_res)
self.request.send(str(len(cmd_res)))
self.request.recv(1024)#接收一次，将第一次与第二次之间数据隔开，解决连包问题
self.request.sendall(cmd_res)
if __name__ == '__main__':
server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)
server.serve_forever()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'ryan'

import socket
ip_port = ('127.0.0.1',8009)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)

while True:
inp = raw_input('please input:')
sk.sendall(inp)
res_size=sk.recv(1024)
print 'going to recv data size:',res_size,type(res_size)
total_size = int(res_size)
sk.send(inp)#---->多发送一次解决连包问题
received_size=0

while True:
data=sk.recv(1024)
received_size += len(data)
print '----data----'
#if len(data)<1024:
if total_size == received_size:
print data
print '----not data---'
break
print data

if inp == 'exit':
break

sk.close()

import socket
import threading
import select
def process(request, client_address):
print request,client_address
conn = request
conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
flag = True
while flag:
data = conn.recv(1024)
if data == 'exit':
flag = False
elif data == '0':
conn.sendall('通过可能会被录音.balabala一大推')
else:
conn.sendall('请重新输入.')
sk = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sk.bind(('127.0.0.1',8002))
sk.listen(5)
while True:
r, w, e = select.select([sk,],[],[],1)
print 'looping'
if sk in r:
print 'get request'
request, client_address = sk.accept()
t = threading.Thread(target=process, args=(request, client_address))
t.daemon = False
t.start()
sk.close()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import SocketServer
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
# print self.request,self.client_address,self.server
conn = self.request
conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')
Flag = True
while Flag:
data = conn.recv(1024)
if data == 'exit':
Flag = False
elif data == '0':
conn.sendall('通过可能会被录音.balabala一大推')
else:
conn.sendall('请重新输入.')
if __name__ == '__main__':
server = SocketServer.ForkingTCPServer(('127.0.0.1',8009),MyServer)
server.serve_forever()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import socket
ip_port = ('127.0.0.1',8009)
sk = socket.socket()
sk.connect(ip_port)
sk.settimeout(5)
while True:
data = sk.recv(1024)
print 'receive:',data
inp = raw_input('please input:')
sk.sendall(inp)
if inp == 'exit':
break
sk.close()

Twisted

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# event_drive.py
event_list = []
def run():
for event in event_list:
obj = event()
obj.execute()
class BaseHandler(object):
"""
用户必须继承该类，从而规范所有类的方法（类似于接口的功能）
"""
def execute(self):
raise Exception('you must overwrite execute')

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from source import event_drive
class MyHandler(event_drive.BaseHandler):
def execute(self):
print 'event-drive execute MyHandler'
event_drive.event_list.append(MyHandler)
event_drive.run()

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from twisted.internet import reactor, protocol
from twisted.web.client import getPage
from twisted.internet import reactor
import time
class Echo(protocol.Protocol):
def dataReceived(self, data):
deferred1 = getPage('http://cnblogs.com')
deferred1.addCallback(self.printContents)
deferred2 = getPage('http://baidu.com')
deferred2.addCallback(self.printContents)
for i in range(2):
time.sleep(1)
print 'execute ',i
def execute(self,data):
self.transport.write(data)
def printContents(self,content):
print len(content),content[0:100],time.time()
def main():
factory = protocol.ServerFactory()
factory.protocol = Echo
reactor.listenTCP(8000,factory)
reactor.run()
if __name__ == '__main__':
main()