def __init__(self, cfg): mcast_addr = cfg.get("mcast.addr", DEFAULT_ADDR) mcast_port = cfg.get("mcast.port", DEFAULT_PORT) mcast_ttl = cfg.get("mcast.ttl", DEFAULT_TTL) Thread.__init__(self, name="McastServer") self.server = UDPServer((mcast_addr, mcast_port), McastHandler) ## allow other processes to bind to this port+addr self.server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) ## set packet TTL (hops) ttl = struct.pack('b', mcast_ttl) self.server.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl) ## disable receiving messages I send (no loopback) self.server.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 0) ## join the multicast group group = socket.inet_aton(mcast_addr) mreq = struct.pack('4sL', group, socket.INADDR_ANY) self.server.socket.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) ## ## note - all of the above may need to be wrapped into the server_bind() ## method of a derived UDPServer class ## logger.info("McastServer thread initialized with config: ...")
def run(self): addr = ( "", PORT ) # empty string corresponds to INADDR_ANY and means receiving from any host logging.info("UDP server listening on port {}".format(PORT)) server = UDPServer(addr, Handler) server.serve_forever()
def handle(self, *args, **options): host = settings.HEART_BEAT_SERVER port = settings.HEART_BEAT_PORT self.stdout.write('Starting Heart Beat receiver') self.stdout.write(f'Listening for pings on {host}:{port}/UDP...') listener = UDPServer((host, port), RequestHandler) listener.serve_forever()
def run_server(): from threading import Thread inter = Interval() t = Thread(target=inter.serve_forever, daemon=True) t.start() server = UDPServer(("", SERVER_RECV_PORT), UdpHandler) try: server.serve_forever() except Exception as e: logger.warning(e)
def run(self): if self.args['local']: logger.info("Running Local Mode") local_machine() server = UDPServer(("", LOCAL_RECV_PORT), UdpHandler) try: server.serve_forever() except Exception as e: logger.warning(e) else: if isServerPortAvailable(SERVER_RECV_PORT): logger.info("Running Server Mode") run_server()
def __init__( self, *, queue: Queue, server_host: str = HOSTNAME, server_port: int = PORT, client_host: str = HOSTNAME, client_port: int = PORT, await_response=False, ): super().__init__(queue=queue) UDPHandler.queue = self.queue self.server_address = (server_host, server_port) self.server = UDPServer(self.server_address, UDPHandler) self.client_address = (client_host, client_port) self.await_response = await_response
def main(): global daemon_im, daemon_bs, server_udp, UDP_SERVER server_udp = UDPServer(UDP_SERVER, udp_handle) daemon_im = info_maker() daemon_im.start() daemon_im.wait_for_start() daemon_bs = buff_sender() daemon_bs.start() daemon_bs.wait_for_start() daemon_us = udp_server() daemon_us.start() daemon_us.wait_for_start() logger.debug('UDP Server start at %s : %d' % (UDP_SERVER[0], UDP_SERVER[1])) daemon_im.join()
def main(): logging.basicConfig( format="%(asctime)s - SERVER - %(levelname)s - %(message)s", level=logging.DEBUG) # parse host and port args parser = argparse.ArgumentParser( description="battleship++ dedicated server") parser.add_argument('host') parser.add_argument('port', type=int) args = parser.parse_args() # start UPD discovery service udpdiscovery_server = UDPServer(("", 12345), UDPDiscoveryHandler) udpdiscovery_server_thread = threading.Thread( target=udpdiscovery_server.serve_forever) udpdiscovery_server_thread.daemon = True udpdiscovery_server_thread.start() logging.debug("UDP discovery server running in thread: " + udpdiscovery_server_thread.name) server = TCPServer((args.host, args.port), RequestHandler) logging.info("Listening on {}:{}".format(args.host, args.port)) server_thread = threading.Thread(target=server.serve_forever) server_thread.daemon = True server_thread.start() logging.debug("Server loop running in thread: " + server_thread.name) # block until keyboard interrupt or system exit try: server_thread.join() udpdiscovery_server_thread.join() except (KeyboardInterrupt, SystemExit) as e: logging.debug(repr(e)) # gracefully kill the server logging.info("Server shutting down...") server.shutdown() server.server_close() udpdiscovery_server.shutdown() udpdiscovery_server.server_close() logging.info("Bye!")
def pair(self): """Start app in pairing mode""" self.log.setLevel(logging.WARNING) self.dm = self.init_dm() code = str(randint(100000, 999999)) print('App running in pairing mode') print(f'Pair code:\n\n {code[:3]}-{code[3:]} \n') udp = UDPServer(('0.0.0.0', self.conf['port']), ServerSearchHandler) udp.app = self udp.pairing_code = code udp.paired_uin = None signal.signal( signal.SIGINT, lambda a, b: Thread(name='Thread-UDP-Main-Shutdown', target=udp.shutdown).start()) udp.serve_forever(0.25) paired_uin = udp.paired_uin print(f'Successful pairing with device {paired_uin}' if paired_uin else 'Pairing failed') udp.server_close() del udp sys.exit(0 if paired_uin else 1)
from LogHelp import logger logger.debug('程序启动') from socketserver import UDPServer from SocketHandle import UdpHandle from WorkThread import Instance import socket #from SecurityManager import Security if __name__ == '__main__': #s=Security() UDPSERVER = UDPServer(('', 2425), UdpHandle) UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) Instance.startMessage(UDPSERVER.socket.sendto) UDPSERVER.serve_forever()
print('接收数据了!') data, s = self.request print(self.client_address, data.decode(), end='') ''' s2 = socket.socket(socket.AF_INET,socket.SOCK_DGRAM) s2.sendto("dtfs".encode(),('localhost',1111)) print('send data success!') ''' #s2.sendto("dfsf".encode()) # data2 = data.decode() # print(data2) #self.request.sendto(self.data.upper(),addr) #Sensordatalist = data.split(',') # 调用saveAllData存储到数据库中 # saveAllData(Sensordatalist) #print(Sensordatalist) break except: traceback.print_exc() break if __name__ == "__main__": host = '' port = 2345 addr = (host, port) server = UDPServer(addr, Handler) # 创建服务器,开始循环监听 server.serve_forever()
#! /usr/bin/env python3 """ Usage: {name} <port> """ from socketserver import DatagramRequestHandler, UDPServer from sys import argv class EchoHandler(DatagramRequestHandler): def handle(self): print("Client connected: ", self.client_address) message = self.rfile.read() # read from the connecting client self.wfile.write(message) # write from the connecting client if len(argv) != 2: print(__doc__.format(name=argv[0])) else: UDPServer(('', int(argv[1])), EchoHandler).serve_forever()
def test_udp_server(): serv = UDPServer(('',20000),TimeHandler) serv.serve_forever()
from socketserver import BaseRequestHandler, UDPServer from stack import Stack class UDPHandler(BaseRequestHandler): stack = Stack() def handle(self): data = self.request[0].strip() socket = self.request[1] self.parse(socket, data) socket.sendto(data.upper(), self.client_address) def parse(self, socket, command): command = command.decode('utf-8').split(' ') if command[0] == 'push': self.stack.add(command[1], command[2]) if command[0] == 'pop': pop_value = self.stack.pop(command[1]) if pop_value: socket.sendto(bytes(pop_value, 'utf-8'), self.client_address) else: socket.sendto(bytes('none', 'utf-8'), self.client_address) if __name__ == "__main__": HOST, PORT = "localhost", 9999 server = UDPServer((HOST, PORT), UDPHandler) server.serve_forever()
mod_playwav.play(FileUtils.GetConfigValue("audio_ports", "1"), 'SystemSounds/gnarly.wav', 70, 0) #mod_MessageHandler.message("Airhorn audio environment controller is ready.") # Read the config to determine where we are getting our commands from if FileUtils.GetConfigValue("general", "consoleinput") == "on": while True: console_input = raw_input( 'Enter a switch number to play, n to listen to the network, or q to quit: ' ) if console_input == 'q' or console_input == 'Q': # turn off ambient sound processing. FileUtils.SetConfigValue("general", "ambientsound", "off") mod_MessageHandler.message("Ta Tah for now.") quit() #elif console_input == 'n' or console_input == 'N': else: ### Process switch numbers from console input. if 'sys' in console_input: x = 1 #wavplayer_pyglet.play('/home/mcalder/PycharmProjects/AirhornPlayer/SystemSounds/needinfo.wav', 1, 1, 0) else: ProcessSwitch(console_input) else: #Accept TCP socket AND console input until the letter q is entered. # Fire up the UDP Server port = FileUtils.GetConfigValue("network", "udpport") mod_MessageHandler.message("Now listening to UDP port " + port + " for input. Console input is disabled.") serv = UDPServer(('', int(port)), UDPMessageHandler) serv.serve_forever()
from socketserver import BaseRequestHandler, UDPServer from sample_part1 import run_client UDP_IP = 'localhost' UDP_PORT = 8000 class EchoUDP(BaseRequestHandler): def handle(self): print(f'Сервер|| Установлено соединение с ' f': {self.client_address}') msg, sock = self.request print(f'Сервер|| Принято сообщение: "{msg.decode("utf-8")}" ' f'от {self.client_address}') print(f'Сервер|| Эхо-сообщение: "{msg.decode("utf-8")}" ' f'отправлено {self.client_address}') sock.sendto(msg, self.client_address) if __name__ == "__main__": from multiprocessing import Process server = UDPServer((UDP_IP, UDP_PORT), EchoUDP) client = Process(target=run_client, args=(UDP_IP, UDP_PORT,)) client.start() server.serve_forever()
def main(): with UDPServer(('', 8080), MyHandler) as server: server.serve_forever()
print(inet.ip) # 123.45.67.64 exit(1) # 3 创建 UDP 服务器 class TimeHandler(BaseRequestHandler): def handle(self): print('Got connection from', self.client_address) msg, sock = self.request resp = time.ctime() sock.sendto(resp.encode('ascii'), self.client_address) if __name__ == '__main__': serv = UDPServer(('', 20000), TimeHandler) serv.serve_forever() exit(1) # 2 创建 tcp 服务器 socketserver class EchoHandler(BaseRequestHandler): def handle(self): print('Got connection from', self.client_address) while True: msg = self.request.recv(8192) if not msg: break self.request.send(msg)
datefmt="%Y-%m-%d %H:%M:%S") log = logging.getLogger(__name__) log.propagate = False log.setLevel(logging.INFO) if not log.hasHandlers(): file_handler = logging.FileHandler(LOG_FILE_NAME) file_handler.setFormatter(log_format) log.addHandler(file_handler) log_on_console = logging.StreamHandler() log_on_console.setFormatter(log_format) log.addHandler(log_on_console) class SyslogHandler(BaseRequestHandler): """ Server handler is required to handle udp request. See examples: https://www.programcreek.com/python/example/73643/SocketServer.BaseRequestHandler """ def handle(self): data = self.request[0].strip().decode("utf-8") log.info(f"{self.client_address[0]}: {str(data)}") if __name__ == "__main__": try: syslog = UDPServer(("0.0.0.0", 514), SyslogHandler) log.info("EZ syslog starts, CTRL-C to stop...") syslog.serve_forever(poll_interval=1) except KeyboardInterrupt: log.info("Ctrl-C detected, exit.")
"Usage: {0} <port>" import sys import time from socketserver import DatagramRequestHandler, UDPServer def upper(msg): time.sleep(1) # simulates a more complex job return msg.upper() class UpperHandler(DatagramRequestHandler): def __init__(self, *args): self.n = 0 DatagramRequestHandler.__init__(self, *args) def handle(self): self.n += 1 print('New request:', self.n, self.client_address) msg = self.rfile.read() self.wfile.write(upper(msg)) if len(sys.argv) != 2: print(__doc__.format(__file__)) sys.exit(1) server = UDPServer(('', int(sys.argv[1])), UpperHandler) server.serve_forever()
from socketserver import UDPServer, DatagramRequestHandler HOST, PORT = "localhost", 8084 SERVER_ADDRESS = HOST, PORT class EchoHandler(DatagramRequestHandler): def handle(self): message = bytes("Olá, você se conectou ao servidor\n", "utf-8") self.wfile.write(message) for line in self.rfile: self.wfile.write(line) print(line.decode("utf-8").strip()) if __name__ == "__main__": with UDPServer(SERVER_ADDRESS, EchoHandler) as server: print("Conectado") server.serve_forever() # 8. nc -u localhost 8084 # 9. curl localhost 8084
from socketserver import UDPServer, DatagramRequestHandler ADDRESS = "", 8084 class EchoHandler(DatagramRequestHandler): """Responde requisições repetindo o que foi recebido.""" def handle(self): for line in self.rfile: print(line.decode("utf-8").strip()) if __name__ == "__main__": with UDPServer(ADDRESS, EchoHandler) as server: print(f"Servidor ligado na PORT {ADDRESS}") server.serve_forever()
from socketserver import DatagramRequestHandler, UDPServer class UDPHandler(DatagramRequestHandler): def handle(self): self.wfile.write("Olá Cliente\n") while True: data = self.rfile.readline().strip().decode("UTF-8") if not data: break print(data) if __name__ == "__main__": server_address = ("localhost", 9090) with UDPServer(server_address, UDPHandler) as Server: print("Server Ativo") Server.serve_forever()
def handle(self): print(f"Got connection from {self.client_address}") while True: msg = self.request.recv(8192) if not msg: print("break") break self.request.send(msg) class TimeHandler(BaseRequestHandler): def handle(self): print(f"got connect from {self.client_address}") msg, sock = self.request resp = time.ctime() sock.sendto(resp.encode("ascii"), self.client_address) if __name__ == '__main__': # serv = TCPServer(("", 20000), EchoHandler) serv = UDPServer(("", 20000), TimeHandler) serv.serve_forever()
def UdpServer(): server = UDPServer(('', 10001), UDPRequestHandler) server.serve_forever()
from socketserver import BaseRequestHandler, UDPServer HOST = '127.0.0.1' PORT = 1337 class RequestHandler(BaseRequestHandler): def handle(self): received = self.request.recv(1024).decode() print(f'From: {self.client_address}/TCP, received: "{received}"') response = 'Thanks' self.request.sendto(response.encode(), self.client_address) with UDPServer((HOST, PORT), RequestHandler) as server: print(f'Accepting connections on {HOST}:{PORT}/UDP...') print(f'To stop the server use ``Ctrl-C``\n') server.serve_forever()
from socketserver import UDPServer, BaseRequestHandler from podcomm.definitions import getLogger, configureLogging class OmnipyBeacon(BaseRequestHandler): def handle(self): try: data = self.request[0].strip() socket = self.request[1] host, port = self.client_address[0] getLogger().info("UDP broadcast message from %s: %s" % (host, data)) socket.sendto("wut".encode("ascii"), (host, 6665)) except Exception: getLogger().exception() getLogger().warning("Error while responding to udp broadcast") try: configureLogging() address = ("", 6664) server = UDPServer(address, OmnipyBeacon) server.serve_forever() except Exception: getLogger().exception() getLogger().error("Error while running omnipy beacon") raise
def __enter__(self): self.server = UDPServer(('127.0.0.1', self.port), self._handler_class) self._server_thread = Thread(target=self.server.serve_forever) self._server_thread.start()
def start(self) -> None: UDPServer.allow_reuse_address = True self.server = UDPServer((self.ip_address, self.port), SyslogUDPHandler) th = Thread(target=self.server.serve_forever) th.daemon = True th.start()
def __init__(self, address, port, router): threading.Thread.__init__(self) self.port = port self.udp_server = UDPServer((address, port), Server.BroadcastHandler) self.udp_server.router = router