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 __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 __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 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();
