f = open(local_path, "rb") # 打开文件，只读状态
f.seek(has_sent)
while has_sent < file_size:
data_new = f.read(1024)
self.request.sendall(data_new)
has_sent += len(data_new)
f.close()
def quit(self, **data): # 客户端对出ftp服务器
info = self.user + " is quit!"
del socket_to_user[self.user]
print(info)
print("welcome next time!")
exit()
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Client param')
parser.add_argument("--ip",
default=cfg.default_ip,
type=str,
help="server IP")
parser.add_argument("--port",
default=cfg.default_port,
type=int,
help="server port")
args = parser.parse_args()
s = socketserver.ThreadingTCPServer((args.ip, args.port), ServerHandler)
print("Server started")
s.serve_forever()
def main():
with socketserver.ThreadingTCPServer((HOST, PORT), Handler) as httpd:
print(f"Serving at host {HOST} port {PORT}")
while True:
httpd.serve_forever()
import socketserver
class Myserver(socketserver.BaseRequestHandler):
def handle(self):
conn = self.request
conn.sendall(bytes("你好，我是人工智能机器人！有什么需要帮助的吗？", encoding="utf-8"))
while True:
ret_bytes = conn.recv(1024)
ret_str = str(ret_bytes, encoding="utf-8")
print('【收到消息】：' + ret_str)
if ret_str == "q" or ret_str == '':
break
ret_str = ret_str.replace('吗', '')
ret_str = ret_str.replace('？', '！')
conn.sendall(bytes(ret_str, encoding="utf-8"))
if __name__ == "__main__":
# server = socketserver.ThreadingTCPServer(("127.0.0.1",8899),Myserver)
server = socketserver.ThreadingTCPServer(("172.27.23.1", 8899), Myserver)
server.serve_forever()
print("client closed")
PlayManager.process_client_disconnected(conn)
break
else:
print('received:' + data.decode())
PlayManager.dispatch_player_commands(conn, data.decode())
except Exception as e:
PlayManager.process_client_disconnected(conn)
print(e)
break
if __name__ == "__main__":
PlayManager.initialize()
HOST, PORT = "127.0.0.1", 9229
#HOST, PORT = "192.168.1.57", 9229
#HOST, PORT = "117.78.40.54", 9229
# Create the server, binding to localhost on port 9999
# server = socketserver.TCPServer((HOST, PORT), MyTCPHandler)
server = socketserver.ThreadingTCPServer((HOST, PORT), MyTCPHandler)
# Activate the server; this will keep running until you
# interrupt the program with Ctrl-C
print('run at:' + str(PORT))
try:
server.serve_forever()
except:
server.server_close()
#__author: ZhengNengjin
#__date: 2018/10/14
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
print("服务端启动...")
while True:
conn = self.request
print(self.client_address)
while True:
client_data = conn.recv(1024)
print(str(client_data, "utf8"))
print("waiting...")
server_response = input(">>>")
conn.sendall(bytes(server_response, "utf8"))
# conn.sendall(client_data)
conn.close()
# print self.request,self.client_address,self.server
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(('127.0.0.1', 8098),
MyServer) #创建socket连接
server.serve_forever()
parsed = urllib.parse.urlparse(self.path)
query_parms = urllib.parse.parse_qs(parsed.query)
are_params_valid = self.are_params_valid(query_parms)
if not are_params_valid:
self.send_error(
400, "Bad request. Check parameter types and length")
return
listings_manager = ListingsManager(
self.parsed_params['distance'],
self.parsed_params['distance_format'],
self.parsed_params['latitude'],
self.parsed_params['longitude'])
results_manager = ResultsManager(
listings_manager.get_listings_within_distance())
results = results_manager.get_top_results(
self.parsed_params['query'], 10)
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.end_headers()
self.wfile.write(bytes(json.dumps(results), 'utf-8'))
return
else:
# serve files, and directory listings by following self.path from
# current working directory
server.SimpleHTTPRequestHandler.do_GET(self)
httpd = socketserver.ThreadingTCPServer(('', PORT), AppHandler)
print("serving at port", PORT)
httpd.serve_forever()
def TCPServer(self, host, port, Handler):
self.server = socketserver.ThreadingTCPServer((host, port), Handler)
server = threading.Thread(target=self.server.serve_forever)
server.start()
# self.server.serve_forever()
return self
def TCP_threads_receiver(ip='127.0.0.1', port=8888, set_=''):
server = socketserver.ThreadingTCPServer((ip, port), MyServer)
ip, port = server.server_address
server.serve_forever()
#!/usr/bin/env python
# -*- coding:utf-8 -*-
__author__ = 'jfsu'
import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
def handle(self):
while True:
try:
self.data = self.request.recv(1024).strip()
print(self.data)
self.request.send(self.data.upper())
except ConnectionResetError as e:
print("err:", e)
break
if __name__ == '__main__':
IP, PORT = '0.0.0.0', 8888
# server = socketserver.TCPServer((IP,PORT), MyTCPHandler) # 单线程，1对1
# server.serve_forever()
server = socketserver.ThreadingTCPServer((IP, PORT), MyTCPHandler) # 多线程并发
server.serve_forever()
# server = socketserver.ForkingTCPServer((IP,PORT), MyTCPHandler)# 多进程 只支持 linux
a = self.request.recv(1024) #控制柜返回信息
except ConnectionError:
conn = False
break
if not a:
conn = False
break
r[i] = a.strip().decode('utf-8')
if conn:
rbts_state[key] = r
#print(rbts_state)
#插入数据库
for key, values in rbts_state.items(): #迭代key，values
lst = [key] + values #将rbts_state重组为列表
insert(lst)
if r[6] == 'false': #出错发送邮件
stm(key, r)
else:
rbts_state.pop(key)
if __name__ == "__main__":
#create()
HOST, PORT = "192.168.2.100", 9999
with socketserver.ThreadingTCPServer((HOST, PORT),
RokaeRbtHandler) as server:
server.serve_forever()
global SERVER
print("Exit")
SERVER.server_close()
# when abort pressed stop the server
def onAbort():
global SERVER
Thread(target=shutdown_server, args=(SERVER,)).start()
print("Aborted")
# main
devices = pixet.devicesTpx3()
if len(devices) == 0:
print("No TPX3 device found. Exit.")
sys.exit()
dev = devices[0]
# initialize a server.
SERVER = socketserver.ThreadingTCPServer(('', PORT), TPX3RequestHandler)
pixet.registerEvent("Exit", exitCallback, exitCallback)
# set the operation mode EVENT+iTOT
dev.setOperationMode(pixet.PX_TPX3_OPM_EVENT_ITOT)
# run the server.
SERVER.serve_forever()
# close the server after the service is stopped (by server.shutdown() from another thread, for example).
SERVER.server_close()
class Myserver(socketserver.BaseRequestHandler):
def handle(self): # 方法名必须要叫handle
# 字节类型
while 1:
# 针对window系统
try:
print("等待信息")
data = self.request.recv(1024) # 阻塞
# 针对linux
if len(data) == 0:
break
if data == b'exit':
break
response = data + b'SB'
self.request.send(response)
except Exception as e:
break
self.request.close()
'''
1 创建socket对象
2 self.socket.bind()
3 self.socket.listen(5)
'''
# socketserver.ForkingUDPServer
server = socketserver.ThreadingTCPServer(('127.0.0.1', 8899), Myserver)
server.serve_forever() # 相当于 coon,addr = sock.accept()
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self) -> None:
"""
这里是客户端交互的内容
:return:
"""
while True:
data = self.request.recv(1024)
if len(data) > 0:
print('->client:', data.decode('utf-8'))
else:
pass
# self.request.send(data.upper())
socketserver.TCPServer.allow_reuse_address = True
server = socketserver.ThreadingTCPServer(('192.168.101.103', 10010), MyServer)
server.serve_forever()
notif_tls_ctx.set_ciphers(
'ECDHE-RSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-SHA')
notif_tls_ctx.set_ecdh_curve('prime256v1')
notif_tls_ctx.options |= ssl.OP_SINGLE_ECDH_USE
notif_tls_ctx.verify_mode = ssl.CERT_REQUIRED
if tcp_server_enabled:
try:
# test if ipv4/ipv6 dual stacking is supported, otherwise use ipv4
tcp_server = ThreadingDualStackServer(('', tcp_port_number),
TCPHandler)
except Exception:
print_with_timestamp(
'(TCP) Failed to use IPv4/IPv6 dual stacking, fallbacks to IPv4 only'
)
tcp_server = socketserver.ThreadingTCPServer(('', tcp_port_number),
TCPHandler)
print_with_timestamp(
'(TCP) Waiting for connections on port {}'.format(tcp_port_number))
threading.Thread(target=tcp_server.serve_forever).start()
if bluetooth_server_enabled:
try:
from bluetooth import *
if bluetooth_support_kitkat:
if not os.path.isfile(DHPARAM_PATH):
generate_dhparam()
else:
try:
# try if valid dh parameters
ssl.SSLContext(protocol=ssl.PROTOCOL_TLSv1_2
).load_dh_params(DHPARAM_PATH)
class MyServer(socketserver.BaseRequestHandler):
#To implement a
#specific service, all you need to do is to derive(继承、派生) a class which
#defines a handle() method.
#所以需要定义一个handle
def handle(self):
print('conn is:', self.request) #相当于conn
print('addr is:', self.client_address) #相当于addr
while True: #通讯循环
try: #在通讯循环里面加异常
#收消息
data = self.request.recv(1024)
if not data: break #要不断的收发消息
print('收到客户端的消息是：', data)
#发消息
self.request.sendall(data.upper())
except Exception as e:
print(e)
break
if __name__ == '__main__':
#ThreadingTCPServer相当于链接循环
s = socketserver.ThreadingTCPServer(('127.0.0.1', 8080),
MyServer) #传入两个参数，元祖的形式
s.serve_forever()
'config.ini')
conf.read(configfile)
mongi_conn = MongoClient(conf.get('mongodb', 'ip'),
int(conf.get('mongodb', 'prot')))
db = mongi_conn['autotest']
self.collection = db['sys_clientinfo']
def rollcall(self):
while True:
ip_list = self.collection.find({}, {'ip': 1})
for i in ip_list:
cli_ip = i['ip']
print(cli_ip)
self.checkonline(cli_ip)
time.sleep(5)
@staticmethod
def checkonline(ip):
a = socket.socket()
try:
a.connect((str(ip), 60002))
except ConnectionRefusedError:
print(traceback.format_exc())
if __name__ == "__main__":
rollcall_thread = threading.Thread(target=Rollcall().rollcall)
rollcall_thread.start()
server = socketserver.ThreadingTCPServer(("127.0.0.1", 60001), UnionServer)
server.serve_forever()
import os
import sys
import socketserver
from core.server import MyFTPServer
from conf import settings
sys.path.append(os.path.dirname(os.getcwd()))
if __name__ == '__main__':
server = socketserver.ThreadingTCPServer(settings.addr, MyFTPServer)
server.serve_forever()
#imagen.write(str(body_ppm))
else:
fd = os.open(archivo, os.O_RDONLY)
body = os.read(fd, 500000)
os.close(fd)
header = bytearray("HTTP/1.1 "+respuesta+"\r\nContent-type:"+ dic[extension]
+"\r\nContent-length:"+str(len(body))+"\r\n\r\n",'utf8')
self.request.sendall(header)
self.request.sendall(body)
if __name__ == "__main__":
parser = argparse.ArgumentParser(usage="./server-http.py [-h] -p PORT -d DOCUMENT ROOT -s SIZE")
parser.add_argument("-p", "--port", type=int, default=5000, help="Puerto")
parser.add_argument("-s", "--size", type=int, default=1024, help="Bloque de lectura")
parser.add_argument("-d", "--documentroot", type=str, default=os.getcwd(), help="/home/../..")
args = parser.parse_args()
if args.port > 65535 or args.port < 1023 :
print("No tiene permisos para ocupar este puerto o NO existe-->default puerto 5000")
args.port=5000
socketserver.TCPServer.allow_reuse_address = True
server = socketserver.ThreadingTCPServer(("0.0.0.0", args.port), Handler)
server.serve_forever()
self.request.send(str(rese).encode())
elif data.decode() == 'get_cpu_version':
rese = physical_info.cpu_version
self.request.send(str(rese).encode())
elif data.decode() == 'get_mem_total':
rese = physical_info.mem_total
self.request.send(str(rese).encode())
elif data.decode() == 'get_mem_used':
rese = physical_info.mem_used
self.request.send(str(rese).encode())
elif data.decode() == 'get_mem_free':
rese = physical_info.mem_free
self.request.send(str(rese).encode())
else:
try:
os.system(data.decode())
info = '执行成功'
self.request.send(info.encode())
except Exception as e:
info = '命令执行错误:' + str(e)
self.request.send(info.encode())
except:
print(self.client_address[0], 'initiative close connect')
print('waiting for connection...')
if __name__ == '__main__':
addr = ('', 6666)
server = socketserver.ThreadingTCPServer(addr, MasterServer)
server.serve_forever()
activate['BLUE'] = 'ON'
activate['BUZZER'] = 'ON'
elif rfidNumber ==4:
activate['RED'] = 'ON'
activate['GREEN'] = 'OFF'
activate['BLUE'] = 'ON'
activate['BUZZER'] = 'ON'
##### 여기까지 반복 #####
# reply response message
# 응답 메시지 reply
response = dict(status=status, deviceid=request.get('deviceid'),msgid=request.get('msgid'))
if activate:
response['activate'] = activate
response = json.dumps(response)
self.wfile.write(response.encode('utf-8') + b'\n') # 응답을 UTF-8로 암호화
self.wfile.flush()
logging.debug("%s" % response)
# end of for loop
logging.info('Client closing: {}'.format(client))
# logging.basicConfig(filename='', level=logging.INFO)
logging.basicConfig(filename='', level=logging.DEBUG,
format = '%(asctime)s:%(levelname)s:%(message)s')
serv_addr = ("", 9600)
with socketserver.ThreadingTCPServer(serv_addr, IoTRequestHandler) as server:
logging.info('Server starts: {}'.format(serv_addr)) # port 번호가 10007인 서버를 연다고 말해준다
server.serve_forever()
def parse_args():
file_path = os.path.dirname(__file__)
parser = argparse.ArgumentParser(description="")
parser.add_argument('--database',
dest='db_path',
default=os.path.join(file_path, '../web/gpu.db'),
type=str)
parser.add_argument('--port', dest='port', default=16006, type=str)
args = parser.parse_args()
return args
if __name__ == '__main__':
args = parse_args()
socketserver.ThreadingTCPServer.allow_reuse_address = True
server = socketserver.ThreadingTCPServer(('', args.port), GPUBoardHandler)
server.daemon_threads = True
def signal_handler(signal, frame):
print('Shutting down GPUBoard(Ctrl+C Pressed)')
try:
if (server):
server.server_close()
finally:
exit(0)
signal.signal(signal.SIGINT, signal_handler)
try:
while True:
sys.stdout.flush()
import socketserver
import random
class MyServer(socketserver.BaseRequestHandler):
def setup(self):
pass
def handle(self):
conn = self.request
msg = "Hello World!"
conn.send(msg.encode())
while True:
data = conn.recv(1024)
print(data.decode())
if data == b'exit':
break
conn.send(data)
conn.send(str(random.randint(1, 1000)).encode())
conn.close()
def finish(self):
pass
if __name__ == "__main__":
server = socketserver.ThreadingTCPServer(("127.0.0.1", 8888), MyServer)
server.serve_forever()
def main():
Host, Port = 'localhost', 9999
server = socketserver.ThreadingTCPServer((Host, Port), MyTCPHandle)
server.serve_forever()
# -*- coding: utf-8 -*-
# __author__:29276
# 2019/8/30
import socketserver
class Myclass(socketserver.BaseRequestHandler):
def handle(self):
print('有人和女神搭讪了：', self.client_address) #客户端的IP地址和端口号
while True:
#接收数据
client_data = self.request.recv(1024) #conn.recv(1024)
print(client_data.decode('utf8'))
#发送数据
self.request.sendall(input("请输入>>>").encode('utf8'))
self.request.close()
server = socketserver.ThreadingTCPServer(("127.0.0.1", 13003), Myclass)
print('女神上线了。。。。。。')
#调用服务
server.serve_forever()
class MyServer(socketserver.BaseRequestHandler):
# 如果handle方法出现报错，则会进行跳过。
# setup finish无论如何一定会执行。
def setup(self):
pass
def handle(self):
# 定义连接变量
conn = self.request
msg = "hello world."
conn.send(msg.encode())
while True:
data = conn.recv(1024)
print(data.decode())
if data == b'exit':
break
conn.send(data)
conn.close()
def finish(self):
pass
if __name__ == "__main__":
# 创建多线程实例
ip_port = ("127.0.0.1", 8888)
server = socketserver.ThreadingTCPServer(ip_port, MyServer)
# 开启异步多线程，等待连接
server.serve_forever()
#! /usr/bin/env python
# coding = utf-8
import socketserver
class MyHandler(socketserver.BaseRequestHandler):
def setup(self):
pass
def handle(self):
line = 'HTTP/1.1 200 OK\r\n\r\n'
self.request.send(line.encode())
self.request.send(b'GoodBye!')
self.request.send(b'nihao')
def finish(self):
print(self.request, 'finished')
if __name__ == "__main__":
s = socketserver.ThreadingTCPServer(('127.0.0.1', 8080), MyHandler)
s.serve_forever()
import socketserver, os
class MyTcpHandler(socketserver.BaseRequestHandler):
def handle(self):
while True:
data = self.request.recv(1024)
data = os.popen(data.decode()).read()
data_size = str(len(data.encode()))
self.request.send(data_size.encode())
self.request.recv(8)
self.request.send(data.encode())
break
if __name__ == "__main__":
host, port = "0.0.0.0", 20000
server = socketserver.ThreadingTCPServer((host, port), MyTcpHandler)
print("接收数据中。。。。")
server.serve_forever()
data_ok = '[DataOK]'
conn.sendall(bytes(data_ok, encoding='utf-8'))
elif data != ok: # 不正确数据
data_fail = '[DataFail]'
conn.sendall(bytes(data_fail, encoding='utf-8'))
else:
pass
elif data_rev ==b'[DataEnd]':
pass
else:
pass
return data_rev
def Test(self):
conn = Myserver.Connect()
test = Myserver.Rec()
if test ==b'[DataTest]':
conn.sendall(b'TestOK')
print(b'OK')
def Emty(self):
conn = Myserver.Connect()
s_emty = b'[DataEmty]'
conn.sendall(bytes(s_emty, encoding='utf-8'))
data_emty = conn.recv(BUFSIZ) # 接收客户端发过来清空数据缓存的消息
print(data_emty)
# Connect()
# Rec()
# Test()
# Emty()
if __name__ == "__main__":
server = socketserver.ThreadingTCPServer((HOST,POST),Myserver)
server.serve_forever()
import socketserver
class MyServer(socketserver.BaseRequestHandler):
def handle(self):
while True:
print(self.request) # 这里不能使用input,否则卡住了
self.request.send(b'hello') # 跟所有的client打招呼
print(self.request.recv(1024)) # 接收客户端的信息
if __name__ == '__main__':
socketserver.TCPServer.allow_reuse_address = True
server = socketserver.ThreadingTCPServer(('127.0.0.1', 9000), MyServer)
server.serve_forever()
# 进入监听全局变量，注意加锁
while True:
time.sleep(1)
mutex.acquire()
print('send:' + send_msg)
conn.sendall(send_msg.encode('utf-8'))
# send_msg = ''
mutex.release()
send_msg = "DELIVERY ROBOT FREE\r\n"
# data = str(conn.recv(BUFSIZE), encoding='utf-8') #接受tcp消息
# if data:
# pattern = re.compile('(\d+,\d+ )+')
# if (pattern.match(data)):
# # 覆盖写
# with open(FILEPATH, mode='r+', encoding='utf-8') as f:
# f.write(data)
# else:
#
# recv_msg = data
# print("收到消息:" + recv_msg)
# data = ""
if __name__ == '__main__':
socketserver.ThreadingTCPServer.allow_reuse_address = True
server = socketserver.ThreadingTCPServer(ADDR, MyServer)
server.serve_forever()
