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
