def server_bind(self): if utils.OsInterfaceIsSupported(): try: self.socket.setsockopt(socket.SOL_SOCKET, 25, responder_settings.Config.Bind_To+'\0') except: pass UDPServer.server_bind(self)
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 __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 __init__(self, server_address, HandlerClass, nametodns, nameserver, ipv6): self.ipv6 = ipv6 self.nametodns = nametodns self.nameserver = nameserver self.address_family = socket.AF_INET6 if self.ipv6 else socket.AF_INET UDPServer.__init__(self, server_address, HandlerClass)
def __init__(self, server_address, handler, resolver, bind_and_activate=True): self.resolver = resolver logger.info('starting UDP DNS server at %s:%s' % (server_address[0], server_address[1])) UDPServer.__init__(self, server_address, handler, bind_and_activate)
def __init__(self, port): UDPServer.__init__(self, ('', port), BroadcastEventNotifierHandler) Thread.__init__(self) # self.daemon = True self.packet_received = Event() self.packet_received_error = Event() self.allow_reuse_address = 1
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()
class Server(threading.Thread): class BroadcastHandler(BaseRequestHandler): def handle(self): # Get message and client socket msg, sock = self.request if DEBUG: print("Router {} received packet: {}".format( self.server.router.name, msg.decode("ascii"))) msg = json.loads(msg.decode("ascii")) sender = msg["sender"] timestamp = msg["timestamp"] if sender in self.server.router.dead_nodes: self.server.router.dead_nodes.remove(sender) need_broadcast = False if sender not in self.server.router.sent.keys(): need_broadcast = True else: last_timestamp = self.server.router.sent[sender] if last_timestamp < timestamp: need_broadcast = True if need_broadcast: self.server.router.router_lock.acquire() self.server.router.update_edges(sender, msg["neighbours"]) self.server.router.sent[sender] = timestamp if DEBUG: print("{} will relay for {}".format( self.server.router.name, sender)) # broadcast to neighbours, but don't send # it back to sender, that's a waste self.server.router.broadcast_packets(msg, exception={sender}) self.server.router.router_lock.release() else: if DEBUG: print("{} will not relay for {}".format( self.server.router.name, sender)) # resp = "Hello " + msg.decode('ascii') # sock.sendto(resp.encode('ascii'), self.client_address) 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 def run(self): self.udp_server.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 __init__(self, server_address, RequestHandlerClass, address_family = socket.AF_INET): self.address_family = address_family UDPServer.__init__(self, server_address, RequestHandlerClass) self.values = {} self.clients = set() def handle_timeout(): self.__handle_timeout() self._has_pending_requests = False self.__handle_timeout = self.handle_timeout self.handle_timeout = handle_timeout
class UDPServerThread(threading.Thread): server = None def run(self): addr = ("", PORT) print("UDP server listening on", addr) self.server = UDPServer(addr, Handler) self.server.serve_forever() def shutdown(self): self.server.shutdown()
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, local_port, remote_port, torchsong, songbook_manager): UDPServer.__init__(self, ('localhost', local_port), TorchRequestHandler) self.torchsong = torchsong self.songbook_manager = songbook_manager self.send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self.send_socket.connect(('localhost', remote_port)) self.status_updater = Thread(target=self._status_updater_loop) self.status_updater.setDaemon(True) self.status_updater.start()
class PipelineStatusListener(object): """Creates a server to listen for progress updates sent out by the pipeline callbacks. Note that this should be used as a context manager to start the server in a background thread and close it automatically:: with PipelineStatusListener(callback): # do stuff here pass Parameters ---------- callback : callable Callback to execute upon receiving a message. This should take a single dict argument. pipeline_id : str or None Pipeline ID to filter on or None to listen to all. port : int Port number to listen on Notes ----- Start the server in a separate thread and stop it with the ``shutdown`` method. """ def __init__(self, callback, pipeline_id=None, port=50001): class Handler(DatagramRequestHandler): def handle(self): data = self.request[0] record = logging.makeLogRecord(pickle.loads(data[4:])) if pipeline_id is not None: if record.name != pipeline_id: return msg = json.loads(record.msg) callback(msg) self._handler_class = Handler self.host = '127.0.0.1' self.port = port self.server = None self._server_thread = None # type: Thread 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 __exit__(self, type, value, traceback): self.server.shutdown()
def server_bind(self): MADDR = "224.0.0.252" self.socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, 255) Join = self.socket.setsockopt(socket.IPPROTO_IP,socket.IP_ADD_MEMBERSHIP,socket.inet_aton(MADDR) + responder_settings.Config.IP_aton) if utils.OsInterfaceIsSupported(): try: self.socket.setsockopt(socket.SOL_SOCKET, 25, responder_settings.Config.Bind_To+'\0') except: pass UDPServer.server_bind(self)
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
class UDPManager(object): """This class starts and stops the sending and receiving threads. """ def __init__(self, host_ip): """Initializes the attributes :param host_ip: The ip of the network interface where this service is running. :return: None """ # initializes the Sender Thread self._sending_thread = UDPSenderThread() # initializes the udpserver with our ThreadedUDPMulticastRequestHandler # as arguments for the constructor of the RequestHandler we have to pass # the update method of the Observable Implementation and the ip-address of the network interface # where this service is running. self.udp_server = UDPServer(MULTICAST_GROUP, lambda *args, **keys: ThreadedUDPMulticastRequestHandler( UDPObservableSingleton.instance.observable.update_received_list, host_ip, self._sending_thread.expand_timeout, *args, **keys)) self._receiver_thread = Thread(target=self.udp_server.serve_forever, daemon=True) self._logger = Log.get_logger(self.__class__.__name__) def start(self): if not self._sending_thread.is_alive(): self._logger.info("Started SenderThread.") self._sending_thread.start() if not self._receiver_thread.is_alive(): self._logger.info("Started UDPServer.") self._receiver_thread.start() def stop(self): if self._sending_thread.is_alive(): self._logger.info("Stopping SenderThread...") self._sending_thread.stop() if self._receiver_thread.is_alive(): self._logger.info("Stopping UDPServer...") self.udp_server.shutdown() self.udp_server.server_close()
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)
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 __init__(self, host_ip): """Initializes the attributes :param host_ip: The ip of the network interface where this service is running. :return: None """ # initializes the Sender Thread self._sending_thread = UDPSenderThread() # initializes the udpserver with our ThreadedUDPMulticastRequestHandler # as arguments for the constructor of the RequestHandler we have to pass # the update method of the Observable Implementation and the ip-address of the network interface # where this service is running. self.udp_server = UDPServer(MULTICAST_GROUP, lambda *args, **keys: ThreadedUDPMulticastRequestHandler( UDPObservableSingleton.instance.observable.update_received_list, host_ip, self._sending_thread.expand_timeout, *args, **keys)) self._receiver_thread = Thread(target=self.udp_server.serve_forever, daemon=True) self._logger = Log.get_logger(self.__class__.__name__)
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!")
class IPComms(Comms): 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 read_telemetry_forever(self): self.server.serve_forever() def stop(self): self.server.shutdown() self.server.server_close() # XXX def send_packet(self, packet: bytes): try: sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock.sendto(packet, self.client_address) print(f"Sent packet: {packet}") if self.await_response: received_data = str(sock.recv(1024), "utf-8") print(f"Received: {received_data}") finally: sock.close()
from socketserver import (UDPServer as UDP, BaseRequestHandler as SRH) from time import ctime HOST = '' PORT = 21567 BUFSIZ = 1024 ADDR = (HOST, PORT) class MyRequestHandler(SRH): def handle(self): print ('...msg from:', self.client_address) data = self.request[0].strip() socket = self.request[1] socket.sendto(bytes(ctime() + " : ", 'utf-8') + data, self.client_address) udpServ = UDP(ADDR, MyRequestHandler) print("waiting for mdg") udpServ.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 main(): with UDPServer(('', 8080), MyHandler) as server: server.serve_forever()
def UdpServer(): server = UDPServer(('', 10001), UDPRequestHandler) 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 run(self): # start discovery addr = ("", discoveryPort) print ("listening on %s:%s" % addr) server = UDPServer(addr, DiscoveryHandler) server.serve_forever()
tr=0 for e in range(0,4): if licz[e]!=0: kier = e if licz==[0,0,0,0] and tab[g][x][y]==1: tr=1 ZatopStatek(tab, kraniec[0], kraniec[1], gracz, kier) print("Trafiony zatopiony") return 1 elif ZliczStatek(tab[g+1],kraniec[0], kraniec[1],kier)==tab[g][kraniec[0]][kraniec[1]]: print("Trafiony zatopiony") return 1 ZatopStatek(tab, kraniec[0], kraniec[1], gracz, kier) tr=1 if tr==0: print("trafiony") return 1 tab[(gracz+2)%3][x][y] = 1 else: print("Już raz strzelałeś w to miejsce, wybierz inne.") return 1 if __name__ == "__main__": host, port = "localhost", 2223 server = UDPServer((host, port), MyUDPHandler) server.serve_forever()
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()
def test_udp_server(): serv = UDPServer(('',20000),TimeHandler) serv.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 start(self): addr = ("", 50505) print("listening on %s:%s" % addr) sensor_server = UDPServer(addr, Handler) sensor_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)
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()
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()
#coding=utf-8 ''' Created on 2013-1-11 @author: zhaojp ''' from socketserver import UDPServer; from bookexample.lession_21.lession_21_7 import TimeServerHandler; server = UDPServer(('', 10000), TimeServerHandler); server.serve_forever();