from socketserver import ThreadingTCPServer, StreamRequestHandler class MyStreamRequestHandler(StreamRequestHandler): def handle(self): print("connection:", self.client_address) while True: data = self.request.recv(1024) if not data: break self.request.send(data.upper() + b"\n") self.request.close() if __name__ == '__main__': myHost = "" myPort = 9292 serverObj = ThreadingTCPServer((myHost, myPort), MyStreamRequestHandler) serverObj.serve_forever()
from socketserver import ThreadingTCPServer, StreamRequestHandler PORT = 2000 class MyRequestHandler(StreamRequestHandler): def handle(self): conn = self.request print('connection from', self.client_address) buf = conn.recv(1024) if not buf: print('nothing') else: print(buf) server = ThreadingTCPServer(('127.0.0.1', 2000), MyRequestHandler) print('listening on port', PORT) server.serve_forever() # svrSock = socket(AF_INET,SOCK_STREAM) # svrSock.bind(('127.0.0.1',2000)) # svrSock.listen(1) # conn, addr = svrSock.accept() # # recvBuf = conn.recv(1024) # print(len(recvBuf)) # print(recvBuf)
logger.exception(E) sys.exit(1) try: REMOTE_SERVER = configini.get("ADVANCED-CONFIG", "REMOTE_SERVER") except Exception as E: logger.debug(E) logger.info("Use SERVER_LISTEN as REMOTE_SERVER") if REMOTE_SERVER.startswith("http://") is not True: REMOTE_SERVER = "http://{}".format(REMOTE_SERVER) logger.info(" ------------Client Config------------") logger.info( "\nLOG_LEVEL: {}\nSLEEP_TIME:{}\nREAD_BUFF_SIZE: {}\nWEBSHELL: {}\nREMOTE_SERVER: {}\nLOCAL_ADDR: {}\nSOCKET_TIMEOUT: {}\n" .format(LOG_LEVEL, SLEEP_TIME, READ_BUFF_SIZE, WEBSHELL, REMOTE_SERVER, LOCAL_ADDR, SOCKET_TIMEOUT)) cache_conns = {} webthread = LoopThread() if webthread.check_server() is not True: sys.exit(1) webthread.start() server = ThreadingTCPServer( (LOCAL_ADDR.split(":")[0], int(LOCAL_ADDR.split(":")[1])), TCPClient) logger.warning("Tcpserver start") server.serve_forever() logger.warning("Tcpserver exit")
re.sendall(data) self.Ssession = re def handle(self): '''TCP处理''' lock.acquire() global ID ID += 1 self.id = ID lock.release() Logs(self.id, 'I', 'Accepting from %s:%s' % self.client_address) try: self.Hello() except Exception as err: Logs(self.id, 'W', str(err)) Logs(self.id, 'D', 'End.') if __name__ == "__main__": laddr = (LADDR, LPORT) try: server = ThreadingTCPServer(laddr, Socks5) Logs(ID, 'I', "Listening " + str(laddr)) server.serve_forever() except Exception as err: Logs(ID, 'E', "Listen close! " + str(err))
for line in self.rfile: # self.wfile is a file-like object for writing self.wfile.write(line) if __name__ == '__main__': serv = TCPServer(('', 20000), EchoHandler) serv.serve_forever() # socketserver 可以让我们很容易的创建简单的 TCP 服务器。但是,你需要注意的 # 是,默认情况下这种服务器是单线程的,一次只能为一个客户端连接服务。如果你想 # 处理多个客户端,可以初始化一个 ForkingTCPServer 或者是 ThreadingTCPServer 对 # 象。例如: from socketserver import ThreadingTCPServer if __name__ == '__main__': serv = ThreadingTCPServer(('', 20000), EchoHandler) serv.serve_forever() # 使用 fork 或线程服务器有个潜在问题就是它们会为每个客户端连接创建一个新的 # 进程或线程。由于客户端连接数是没有限制的,因此一个恶意的黑客可以同时发送大 # 量的连接让你的服务器奔溃。 # 如果你担心这个问题,你可以创建一个预先分配大小的工作线程池或进程池。你先 # 创建一个普通的非线程服务器,然后在一个线程池中使用 serve forever() 方法来启 # 动它们。 if __name__ == '__main__': from threading import Thread NWORKERS = 16 serv = TCPServer(('', 20000), EchoHandler) for n in range(NWORKERS): t = Thread(target=serv.serve_forever) t.daemon = True
import multiprocessing import time from socketserver import ThreadingTCPServer import threading from RequestHandler import RequestHandler from setting import SERVER_ADDRESS, CONSTRUCTION_TYPE, print_settings if __name__ == '__main__': print_settings() with ThreadingTCPServer(SERVER_ADDRESS, RequestHandler) as server: threading.Thread(target=server.serve_forever, daemon=True).start() print('open server with {} method'.format(CONSTRUCTION_TYPE)) while threading.active_count() > 1: time.sleep(2) print('-Active threads(In main)-\n', threading.enumerate()) print('\n\nserver closed...') while not multiprocessing.Queue.empty(): print(multiprocessing.Queue.g)
class Handler(BaseRequestHandler): def handle(self): address, pid = self.client_address print('%s connected!' % address) while True: data = self.request.recv(BUF_SIZE) if len(data) > 0: print('receive=', data.decode('utf-8')) Replydata = input('Reply msssage:') cur_thread = threading.current_thread() #response = '{}:{}'.format(cur_thread.ident,data) # self.request.sendall(data) self.request.sendall(Replydata.encode('utf-8')) # self.request.sendall(address.encode()) print('send:', Replydata.decode('utf-8')) else: print('close') break if __name__ == '__main__': HOST = '172.20.4.47' PORT = 12345 ADDR = (HOST, PORT) server = ThreadingTCPServer(ADDR, Handler) print('listening') server.serve_forever() print(server)
def finish(self): super().finish() self.event.set() def handle(self): super().handle() while not self.event.is_set(): data = self.request.recv(1024).decode() msg = "{} {}".format(self.client_address, data).encode() self.request.send(msg) print('End') addr = ('0.0.0.0', 9989) server = ThreadingTCPServer(addr, EchoHandler) server_thread = threading.Thread(target=server.serve_forever, name='EchoServer', daemon=True) server_thread.start() try: while True: cmd = input('>>>') if cmd.strip() == 'quit': break print(threading.enumerate()) except Exception as e: print(e) except KeyboardInterrupt: pass finally:
def test_socket_server(): # startup server on separate thread global serv serv = ThreadingTCPServer(('', PORT), SocketServer) server_thread = threading.Thread(target=serv.serve_forever) server_thread.start()
ref_line_map_file = file_dir + "/ref_line.json" connect_map_dict = getConnectMapFromJson(connect_map_file) for _, key in enumerate(connect_map_dict): print('main:{}:{}'.format(key, connect_map_dict[key])) ref_line_dict, ref_line_time_map_dict = getRefLineTimeMapFromJson( ref_line_map_file) for _, key in enumerate(ref_line_time_map_dict): print('main:ref_line->{}:{}'.format(key, ref_line_time_map_dict[key])) # 通过networkx画连通图 DiGraphic = nx.DiGraph() for _, key in enumerate(connect_map_dict): value = connect_map_dict[key] print('main: for nextID:{}:{}'.format(key, value)) for nextID in value: # print('main: for nextID:{}:{}'.format(key, nextID)) # 需要走过的是车辆所在的ID,所以用所在车道的长度/限速来度量经过的路程 DiGraphic.add_weighted_edges_from( [(key, nextID, ref_line_time_map_dict[key])], weight='length') # print(list(DiGraphic[21].keys())[0]) HOST = get_host_ip() print(HOST) PORT = 19001 ADDR = (HOST, PORT) server = ThreadingTCPServer(ADDR, Handler) # 参数为监听地址和已建立连接的处理类 print('listening') server.serve_forever() # 监听,建立好TCP连接后,为该连接创建新的socket和线程,并由处理类中的handle方法处理
server_port = 7000 gLock = threading.Lock() class EchoHandler(BaseRequestHandler): def handle(self): self.data = None while True: self.data = self.request.recv(1024) if not self.data: break gLock.acquire() print( "Server received {0} bytes on thread {1} from {2}:{3}".format( len(self.data), threading.current_thread().name, *self.client_address)) print(' {0}'.format(self.data)) gLock.release() self.request.send(self.data) try: s = ThreadingTCPServer((server_addr, server_port), EchoHandler) s.allow_reuse_address = True print("Server started") s.serve_forever() except (KeyboardInterrupt, SystemExit): pass finally: s.shutdown() print("Server stopped")
quit() # configure the loggers logger = configureRootLogger(args) # Start ! mode = 'prod' if args['--prod'] else 'dev' if args['--dev'] else 'debug' logger.message("") logger.message("#=====================================================#") logger.message("# Coding Game Server is going to start (mode=`%s`) #" % mode) logger.message("#=====================================================#") logger.message("") # Run the webserver threading.Thread( target=runWebServer, kwargs={'host': args['--host'], 'port': args['--web'], 'quiet': False} ).start() # Start TCP Socket server (connection to players) PlayerServer = ThreadingTCPServer((args['--host'], args['--port']), PlayerSocketHandler) logger.message("Run the game server on port %d...", args['--port']) threading.Thread(target=PlayerServer.serve_forever()) # !TODO: add a timeout for the dataReceive (this exists in the BaseRequestHandler class) # TODO: send pretty emails (when send from webserver) # !TODO: allows the C API do not quit when there is an error (and to get back the error message) -> in some hidden variables "onErrorContinue" and "lastError" ? # !TODO: unify the docstrings (`Parameters` vs `param:`, check with sphinx) # FIXME: when a player play (or wait for a move) but it's not his turn, the client exits and disconnects. This should be a problem in tournament (should only loose the game): in the client API, should display the error and return LOSING_MOVE/WINNING_MOVE
def run_command_server(): serv = ThreadingTCPServer(('', 9000), CommandHandler) serv.serve_forever()
def get_host_ip(): try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(('8.8.8.8', 80)) ip = s.getsockname()[0] finally: s.close() return ip if __name__ == '__main__': time.sleep(30) try: host = get_host_ip() port = 10086 addr = (host, port) except: logging.error('Failed to get local host name.') sys.exit(0) try: logging.info('Starting the server...') server = ThreadingTCPServer(addr, TCP_Server) logging.info('Server started, bind to %s', addr) server.serve_forever() except: logging.error('Server stopped!.')
while True: try: cmd = self.request.recv(1024).decode('utf8') except socket.timeout: print(f'{self.client_address} 接收超时,即将断开连接...') break if not cmd: break print(f'执行cmd: {cmd}') with os.popen(cmd=cmd) as fobj: data = fobj.read() if not data: data = "命令错误,请重新输入" data = cmd + ':\r\n' + data print(f'data2={data}') header = struct.pack('i', len(data)) self.request.send(header) self.request.sendall(f'{data}'.encode('utf8')) # 数据 def finish(self): print(f'{self.client_address} 断开连接...') ThreadingTCPServer.allow_reuse_address = True with ThreadingTCPServer(ADDR, ThreadTCPRequestHandler) as tcpServ: print('waiting for connection') tcpServ.serve_forever()
break client.sendall(request) except: self.request.close() client.close() break if __name__ == '__main__': if len(sys.argv) != 2: print("usage: proxy port", file=sys.stderr) sys.exit(1) black_file = open('black-list') black_re = black_file.readlines() if black_re: black_re = [r.strip() for r in black_re] black_re = '|'.join(black_re) RE_BLACK = re.compile(black_re) # TODO should also check if integer server_port = int(sys.argv[1]) server = ThreadingTCPServer(('', server_port), ReqHandler) try: server.serve_forever() except KeyboardInterrupt: server.server_close() print('server closed, clean up down.', file=sys.stderr) sys.exit(0)
frame_name = ret.group(1) app_name = ret.group(2) frame = __import__(frame_name) app = getattr(frame, app_name) return app def _is_validate_param_num(self): if len(self.param) == 3: return True if __name__ == '__main__': with open("./web_server.conf") as conf: conf_dict = json.loads(''.join(conf.read().split('\n'))) sys.path.append(conf_dict['dynamic_path']) cli_param = CliParam(sys.argv) port, frame_app = cli_param.get_port_and_application() if all((port, frame_app)): ADDR = '0.0.0.0', int(port) ThreadingTCPServer.allow_reuse_address = True # 允许地址复用 with ThreadingTCPServer(ADDR, ThreadedTCPRequestHandler) as wsgi_server: print('waiting for connection') wsgi_server.serve_forever() # 运行服务器,直到shutdown() print("请按照以下方式运行:") print("python3 xxx.py 9999 frame:application")
def __init__(self, address, port): self.servers = [ ThreadingUDPServer((address, port), UDPHandler), ThreadingTCPServer((address, port), TCPHandler), ]
name = conn.recv(1024) # print('connection from', self.client_address) print(name.decode('utf-8') + '님이 입장하셨습니다!') # 사용자가 입장했으므로 카운트 증가 cnt += 1 while True: buf = conn.recv(1024) if not buf: pass # 퇴장 elif buf.decode('utf-8') == 'EXIT': print(name.decode('utf-8') + '님이 퇴장하셨습니다!') cnt -= 1 # 카운트가 0이면 채팅 이용자가 없으므로 서버 종료 # 서버(스레드) 종료 함수를 잘모르겠다 # 왠지 shutdown() 함수는 강제종료인것같다 # 정상 종료 함수 없나? if (0 == cnt): server.shutdown() return else: # 사용자들이 입력한 문자열을 UTF-8로 인코딩하여 출력 print(name.decode('utf-8') + ' : ' + buf.decode('utf-8')) server = ThreadingTCPServer((IP, PORT), MyRequestHandler) print('listening on port', PORT) server.serve_forever() # 이 함수가 스레드 종료 함수 아닌가? # server.server_close()
# Classe que lida com as requisições do cliente class HandlesClientRequests(BaseRequestHandler): def handle(self): # Lida com cada requisição do cliente print(self.client_address, now()) # Simula processamento dos dados time.sleep(5) while True: # Recebe dados enviados pelo cliente data = self.request.recv(1024) # Se não receber nada paramos o loop if not data: break # Escreve a resposta answer = 'Resposta eco => {data} as {time}'.format(data=data, time=now()) # Servidor manda de volta a resposta self.request.send(answer.encode()) # Fecha a conexão criada depois de responder o cliente self.request.close() # Cria uma thread server e lida com a entrada e requisitos do cliente ip_address = configure_server() server = ThreadingTCPServer(ip_address, HandlesClientRequests) server.serve_forever()
import threading from xbmc import Monitor, executebuiltin from kodi_six import xbmcgui def serveForever(handler): try: handler.serve_forever() except Exception as e: Script.log(e, lvl=Script.DEBUG) pass ThreadingTCPServer.allow_reuse_address = True _PORT = 48996 handler = ThreadingTCPServer(("", _PORT), proxy.JioTVProxy) t = threading.Thread(target=serveForever, args=(handler, )) t.setDaemon(True) t.start() if not Settings.get_boolean("popup"): xbmcgui.Dialog().ok( "JioTV Notification", "Now you can create your custom playlist from BotAllen Dashboard. [CR]Find out more at [B]https://botallen.com/#dashboard[/B] [CR][CR]If you like this add-on then consider donating from [B]https://botallen.com/#donate[/B] [CR][CR]Github: [B]https://github.com/botallen/repository.botallen[/B] [CR]Discord: [B]https://botallen.com/discord[/B] [CR][CR][I]You can disable this popup from settings[/I]" ) if Settings.get_boolean("m3ugen"): executebuiltin( "RunPlugin(plugin://plugin.video.jiotv/resources/lib/main/m3ugen/?notify=no)" )
signal.signal(signal.SIGINT, f) if len(sys.argv) < 2: print("lcx -h 获取帮助!") sys.exit() usage = "lcx -s 127.0.0.1 -l 8080 -d 192.168.0.1 -p 8888" parser = optparse.OptionParser(usage=usage) parser.add_option("-s", "--lhost", dest="lhost", default="0.0.0.0", help="绑定本地地址") parser.add_option("-l", "--lport", dest="lport", help="监听本地端口") parser.add_option("-d", "--dhost", dest="dhost", help="连接远程IP") parser.add_option("-p", "--dport", dest="dport", help="连接远程端口") (options, args) = parser.parse_args() lhost = options.lhost lport = options.lport dhost = options.dhost dport = options.dport thread_status = [] threads = [] if lport and lhost: with ThreadingTCPServer((lhost, int(lport)), MyTcpHandler) as server: print("监听本地 %s:%s 成功,并连接到远程 %s:%s !" % (lhost, lport, dhost, dport)) server.serve_forever() else: print("lcx -h 获取帮助!")
from socketserver import BaseRequestHandler, ThreadingTCPServer class EchoHanlder(BaseRequestHandler): def handle(self): print('Got connection from ', self.client_address) while True: msg = self.request.recv(8092) if not msg: break self.request.send(msg) if __name__ == '__main__': serv = ThreadingTCPServer(('', 20010), EchoHanlder) serv.serve_forever()
if message is None: self.request.sendall(Message('reply', 'No message received')) elif message.msg_type == 'signup': self.signup(message) def login(self, message): """Realiza login de clientes :param message: mensagem do cliente """ user_manager = UserManager() login, password = message.data response = user_manager.check_user(login, password) if response.data[0] == 'User exists': response.data = response.data[1] else: self.request.sendall(dumps(response)) def signup(self, message): """Realiza cadastro de clientes :param message: mensagem do cliente """ user_manager = UserManager() name, login, password = message.data response = user_manager.create_user(name, login, password) self.request.sendall(dumps(response)) serv = ThreadingTCPServer(('localhost', 9990), Handler, True) serv.serve_forever()
saveDC.BitBlt((0, 0), (w, h), mfcDC, (0, 0), win32con.SRCCOPY) saveBitMap.SaveBitmapFile(saveDC, filename) class RemoteDesktopServer(StreamRequestHandler): def handle(self): # 打印客户端地址和端口 print('新连接:', self.client_address) # 循环 while True: # 接收客户发送的数据 data = self.request.recv(1024) if not data: break # 如果接收数据为空就跳出,否则打印 print('Client data:', data.decode()) beg = time.time() for i in range(10): filename = "%s.jpg" % str(i) window_capture(filename) with open(filename, "rb") as f: self.request.send(f.read()) # 将收到的信息再发送给客户端 end = time.time() print(end - beg) if __name__ == "__main__": host, port = "10.7.103.205", 9000 # 定义服务器地址和端口 server = ThreadingTCPServer((host, port), RemoteDesktopServer) # 实现了多线程的socket通话 server.serve_forever( ) # 不会出现在一个客户端结束后,当前服务器端就会关闭或者报错,而是继续运行,与其他的客户端继续进行通话。
filter(lambda d: not d.startswith('_'), dir(liw.application))) }).encode('utf8')) elif not authed: self.json_headers() if not globals()['run_already']: open_new_tab(liw.authentication.authorization_url) globals()['run_already'] = True self.wfile.write( dumps({ 'path': self.path, 'authed': type(liw.authentication.token) is None }).encode('utf8')) elif authed and len(parsedurl.path) and parsedurl.path[1:] in dir( liw.application): self.json_headers() self.wfile.write( dumps(getattr(liw.application, parsedurl.path[1:])()).encode('utf8')) else: self.json_headers(501) self.wfile.write(dumps({'error': 'NotImplemented'}).encode('utf8')) if __name__ == '__main__': httpd = ThreadingTCPServer(('localhost', PORT), CustomHandler) print('Server started on port:{}'.format(PORT)) httpd.serve_forever()
def initSPI(bus, device): spi = spidev.SpiDev() spi.open(bus, device) spi.max_speed_hz = 4000000 # 500000 spi.mode = 3 spi.lsbfirst = False return spi if __name__ == '__main__': try: GPIO.setmode(GPIO.BCM) # use GPIO number GPIO.setup(BUSY_PIN, GPIO.IN) spi = initSPI(0, 1) board = L6470(spi, RESET_PIN, BUSY_PIN) board_agent = BoardAgent(board) board_agent.setBoardParameters(100, 50, 144) board_agent.searchHome() if board_agent.getCurPos() == 0: print('Motor Search Home Finshed!\n') srv = ThreadingTCPServer(('', PCR_PORT), ConnectionHandler) print('Server running at 0.0.0.0:%d\n' % PCR_PORT) srv.serve_forever() except (KeyboardInterrupt, SystemExit): print('\nReceived keyboard interrupt, quitting threads.\n') g_is_accepted = False
:return: """ file_name = cmd_dict["file_name"] file_size = os.path.getsize("%s/%s" % (ROOT_DIR, file_name)) if os.path.isfile("%s/%s" % (ROOT_DIR, file_name)): self.request.send(b"1") else: self.request.send(b"0") return head_dict = { 'file_size': file_size, } head_json = json.dumps(head_dict) head_bytes = head_json.encode('utf-8') self.request.send(struct.pack('i', len(head_bytes))) self.request.send(head_bytes) with open("%s/%s" % (ROOT_DIR, file_name), 'rb') as f: for line in f: self.request.send(line) if __name__ == '__main__': tcp_Server = ThreadingTCPServer(("127.0.0.1", 8081), FTPServer) tcp_Server.allow_reuse_address = True tcp_Server.serve_forever()
def __init__(self, ip, port): self.server = ThreadingTCPServer((ip, port), UniformRequestHandler)
def __init__(self): self.server = ThreadingTCPServer(('', 5100), DataHandler) self.thread = Thread(target=DeviceServer.start, args=(self, ))