def _server(self):
"""
进程服务入口函数
"""
host = ''
ADDR = (host, self.port)
TCP.allow_reuse_address = True
tcpServ = TCP(ADDR, MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
data=tcp_client_socket.recv(BUFSIZ)#recieve TCP message
if not data:
break
tcp_client_socket.send('[%s] %s '%(bytes(ctime(),'utf-8'),data))
tcp_client_socket.close()
tcp_ser_socket.close()
"""
#creating socket server
from SocketServer import TCPServer as TCP
from SocketServer import StreamRequestHandler as srh
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT) #a tuple consisting of host and port
class My_request_handler(srh): #inheriting the stream request handler class
def handle(self):
#handle class treats the incoming data as a file
#this code returns both the server and sender data
print('connected from', self.client_address)
self.wfile.write('[%s]%s' % (ctime(), self.rfile.readline()))
tcp_server = TCP(ADDR, My_request_handler)
print('waiting for the connection')
#an infinite loop to serve the client requests
tcp_server.serve_forever()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
__title__ = tsTservSS.py
__author__ = Hughe
__time__ = 2017-04-23 06:49
"""
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
"""
请求处理程序，重写handle方法
"""
class MyRequsetHandler(SRH):
def handle(self):
print '...connected from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServ = TCP(ADDR, MyRequsetHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
if __name__ == '__main__':
pass
from SocketServer import TCPServer as TCP, StreamRequestHandler as SRH
from time import ctime
host = ""
port = 34567
addrs = (host, port)
class MyRequestHandler(SRH):
def handle(self):
print("Connection from " + str(self.client_address))
self.wfile.write("[" + str(ctime()) + "]" + str(self.rfile.readline()))
tcpServ = TCP(addrs, MyRequestHandler)
print "Waiting for connection...."
tcpServ.serve_forever()
# --coding: utf-8 --
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
__author__ = 'lovexiaov'
HOST = ''
PORT = 34568
ADDRESS = (HOST, PORT)
class MyRequestHeader(SRH):
def handle(self):
print '...connected from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServer = TCP(ADDRESS, MyRequestHeader)
print 'waiting for connection...'
tcpServer.serve_forever()
def start_server():
listen = (wanip or natip, 843)
tcpServ = TCP(listen, RequestHandler)
print 'listen on %s:%d' % listen
tcpServ.serve_forever()
#!/usr/bin/python
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyReqHandler(SRH):
def handle(self):
print '...request from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServ = TCP(ADDR, MyReqHandler)
print 'waiting for connection ..'
tcpServ.serve_forever()
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
ADDR = ('', 8888)
class TS_RequestHandler(SRH):
def handle(self):
print '...connected from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpSrv = TCP(ADDR, TS_RequestHandler)
print 'waiting for connection ...'
tcpSrv.serve_forever()
from SocketServer import TCPServer as TCP, StreamRequestHandler as SRH
from time import ctime
HOST = ''
PORT = 21528
ADDR = (HOST, PORT)
class MyServerHandler(SRH):
def handle(self):
print '... connected from ', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServer = TCP(ADDR, MyServerHandler)
print '...waiting ', tcpServer.server_address
tcpServer.serve_forever()
#!/usr/bin/env python
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 8899
ADDR = (HOST, PORT)
class MyRequestHandler(SRH):
def handle(self):
print("...Conneted from: ", self.client_address)
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcp_server = TCP(ADDR, MyRequestHandler)
print("Waiting for connection...")
tcp_server.serve_forever()
while True:
try:
data = tcpclisock.recv(BUFSIZ)
if not data:
break
tcpclisock.send('[%s] %s' % (ctime(),data))
except:
break
if data == 'quit':
break
tcpclisock.close()
tcpsersock.close()
print 'closed!'
"""
from SocketServer import (TCPServer as TCP ,StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21568
ADDR = (HOST,PORT)
class Myrequesthandler(SRH):
def handle(self):
print '...connectted from:' , self.client_address
self.wfile.write('[%s] %s' % (ctime(),self.rfile.readline()))
tcpserv = TCP(ADDR,Myrequesthandler)
print 'waiting for connecting...'
tcpserv.serve_forever()
# -*- coding: cp936 -*-
# 导入模块
from SocketServer import (TCPServer as TCP,
StreamRequestHandler as SRH)
from time import ctime
# 定义处理接收事件类
class MyRequestHandler(SRH):
# 定义事件处理函数
def handle(self):
print "……connected from:", self.client_address
self.wfile.write("[%s] %s" % (ctime(), self.rfile.readline()))
# 定义主机等信息
Host = ""
Port = 21567
Addr = (Host, Port)
ts = TCP(Addr, MyRequestHandler)
print "waiting for connection……"
ts.serve_forever()
from SocketServer import TCPServer as TCP, StreamRequestHandler as SRH
from time import ctime
HOST = ''
PORT = 8000
ADDR = (HOST, PORT)
# 通过继承SocketServer重写handle方法，实现处理请求
# 好处是：只需要调用该类的属性，同时只需要传入参数就可以建立socket通信
class MyRequerstHandler(SRH):
def handle(self):
print 'connect from:', self.client_address
self.wfile.write('[%s]%s' % (ctime(), self.rfile.readline()))
TcpServer = TCP(ADDR, MyRequerstHandler)
print 'waiting for connection'
TcpServer.serve_forever()
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
host = ''
port = 21567
addr = (host, port)
class MyRequestHandler(SRH):
def handle(self):
print('...connected from:', self.client_address)
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
server = TCP(addr, MyRequestHandler)
print('waiting for connection...')
server.serve_forever()
from SocketServer import(TCPServer as TCP,StreamRequestHandler as SRH)
from tqdm import tqdm
import time
import sys
c=0
from time import ctime
host=''
port=44444
addr=(host,port)
class MyRequestHandler(SRH):
def handle(self):
for i in tqdm(range(10000)):
time.sleep(0.001)
print "Connected from:",self.client_address
self.wfile.write('[%s]%s' % (ctime(),self.rfile.readline()))
tcp=TCP(addr,MyRequestHandler)
print "Waiting for the connection"
#for i in tqdm(range(10000)):
# time.sleep(0.00001)
if c==0:
tcp.serve_forever()
c+=1
else:
print "Thanks for Connecting with me!"
sys.exit()
#!/usr/bin/env python
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyRequestHandler(SRH):
def handle(self):
print '...connected from:', self.client_address
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServ = TCP(ADDR, MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
# Client is requesting user password authentication on login screen.
# message[2] = <userName>
# message[3] = <password>
elif self.messageType == codes["LoginRequest"]:
userName = self.message[2]
password = self.message[3]
serverFunctions.Login(userName, password)
# Client is requesting the creation of a new work order.
# message[2] = <WorkOrder Object>
elif self.messageType == codes["WorkOrderCreationRequest"]:
serializedNewWorkOrder = self.message[2]
serverFunctions.CreateWorkOrder(serializedNewWorkOrder)
# This method returns the Recieve buffer size which is specified
# in the parameters file.
elif self.messageType == codes["BufferSizeRequest"]:
serverFunctions.SendReceiveBufferSize()
elif self.messageType == codes["CurrentWorkOrdersRequest"]:
serverFunctions.SendCurrentWorkOrders(currentWorkOrders.workOrders)
log.WriteToLogWithTimeStamp("Session with %s closed" %
str(self.client_address))
def SendMessage(self, message):
self.wfile.write(message)
server = TCP(address, RequestHandler)
server.serve_forever()