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()
class McastThread(Thread):
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):
logger.debug("McastServer thread started.")
self.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()
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)
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 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)
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()
#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();
def run(self):
# start discovery
addr = ("", discoveryPort)
print ("listening on %s:%s" % addr)
server = UDPServer(addr, DiscoveryHandler)
server.serve_forever()
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.")
}
r = json.dumps(r_dict)
self.wfile.write(r.encode('utf-8'))
super().finish()
if __name__ == "__main__":
print('%s start...' % __file__)
try:
with open(CONFIG_PATH, 'r') as f:
config = f.read(1024)
c_dict = json.loads(config)
DBPORT = c_dict['dbconfig']['DBPORT']
DBIP = c_dict['dbconfig']['DBIP']
except:
DBIP = 'localhost'
DBPORT = 9000
dbserver = UDPServer((DBIP, DBPORT), DBServer)
try:
engine = create_engine(r'sqlite:///gateway.db?check_same_thread=False',
echo=True)
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
except Exception as e:
print(e)
dbserver.serve_forever()
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)
def UdpServer():
server = UDPServer(('', 10001), UDPRequestHandler)
server.serve_forever()
def test_udp_server():
serv = UDPServer(('',20000),TimeHandler)
serv.serve_forever()
def on_upgrade(self, url=None, restore=False):
'''
@url: 固件源位置
@restore:
'''
if url:
# 将固件下载至指定位置
os.system('wget %s -O %s' %
(url, c_dict['systemconfig']['FIRMWARE_PATH']))
pass
if __name__ == "__main__":
try:
with open(CONFIG_PATH, 'r') as f:
config = f.read(-1)
c_dict = json.loads(config)
SYSPORT = c_dict['systemconfig']['SYSPORT']
SYSIP = c_dict['systemconfig']['SYSIP']
except:
SYSIP = 'localhost'
SYSPORT = 9002
# 创建服务启动线程
serviceStartThread = threading.Thread(target=serviceStartHandler,
name='serviceStartHandler')
sysserver = UDPServer((SYSIP, SYSPORT), SysServer)
serviceStartThread.start()
sysserver.serve_forever()
# pass
if __name__ == "__main__":
HOST, PORT = "localhost", 1000
lst_argv = argv[1:]
if lst_argv:
try:
PORT = int(lst_argv[0])
except TypeError:
print("not int")
finally:
PORT = 1000
UPDListener = UDPServer((HOST, PORT), MyUDPHandler)
UPDListener.serve_forever()
#UDPSocket = ThreadingUDPServer((HOST, PORT), MyUDPHandler)
#UDPSocketThread = Thread(target=UDPSocket.serve_forever)
#UDPSocketThread.daemon = True
#start_time = time()
#UDPSocketThread.start()
#print("start server", "on Port:", PORT, "at", start_time)
#UDPSocketThread.join(5)
#while time() < start_time + 10.0:
# pass
#print("stop server")
#UDPSocket.shutdown()
def start(self):
addr = ("", 50505)
print("listening on %s:%s" % addr)
sensor_server = UDPServer(addr, Handler)
sensor_server.serve_forever()
cnn = mysql.connector.connect(host="localhost",
user="******",
passwd="HanbookRadar97",
database="diseno")
class GestorSolicitudesHora(BaseRequestHandler):
def handle(self):
print('se ah recibido una conexion desde {}'.format(
self.client_address))
mensaje, sock = self.request
respuesta = time.ctime()
sock.sendto(respuesta.encode('ascii'), self.client_address)
mensaje = str(mensaje)
mensaje = mensaje[2:7]
cordenada = mensaje
hora = respuesta
cur = cnn.cursor()
cur.execute(
"INSERT INTO gru (cordenada, hora) VALUES ('{}','{}')".format(
hora, cordenada))
cnn.commit()
cur.close()
if __name__ == '__main__':
servidor = UDPServer(('', 37777), GestorSolicitudesHora)
print('se ah iniciado el servidor')
servidor.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 start(self):
addr = ("", 50505)
print("listening on %s:%s" % addr)
sensor_server = UDPServer(addr, Handler)
sensor_server.serve_forever()
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()
def time_server():
server = UDPServer(('', 2000), TimeHanlder)
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()
#!/usr/bin/env python
import logging
from socketserver import UDPServer, BaseRequestHandler
logging.basicConfig(level=logging.INFO, format='%(message)s')
class SyslogUDPHandler(BaseRequestHandler):
def handle(self):
data = bytes.decode(self.request[0].strip())
socket = self.request[1]
print("%s : " % self.client_address[0], str(data))
logging.info(str(data))
if __name__ == "__main__":
try:
server = UDPServer(('0.0.0.0', 514), SyslogUDPHandler)
server.serve_forever(poll_interval=0.5)
except (IOError, SystemExit):
raise
except KeyboardInterrupt:
print("Crtl+C Pressed. Shutting down.")
