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, ))
