def __init__(self,
host,
port,
socket=None,
protocol=None,
throttle_policy=DummyPolicy()):
self.protocol = protocol
if socket is not None:
self.server = DatagramServer(socket, handle=self.receive)
else:
self.server = DatagramServer((host, port), handle=self.receive)
self.host = self.server.server_host
self.port = self.server.server_port
self.throttle_policy = throttle_policy
def serv_start(handle):
global socket, server, cache
mode = config['mode']
if mode == 'gevent':
global geventsocks
from gevent.server import DatagramServer
from gevent import socket
import geventsocks
geventsocks.set_default_proxy(config['socks5_ip'],
config['socks5_port'])
server = DatagramServer((config['listen_ip'], config['listen_port']),
handle)
cache = {}
return server.serve_forever()
elif mode == 'multiprocessing':
global socks
import socket
import multiprocessing
import socks
socks.set_default_proxy(socks.SOCKS5, config['socks5_ip'],
config['socks5_port'])
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.bind((config['listen_ip'], config['listen_port']))
cache = multiprocessing.Manager().dict()
pool = multiprocessing.Pool(config['the_num_of_processes'])
while True:
data, cli_addr = server.recvfrom(512)
pool.apply_async(handle, args=(
data,
cli_addr,
))
def run():
self._tls.gevent = True
self._server = DatagramServer(self.bind_address, handle)
self._server.start()
while self.is_running() and not self._stop:
gevent.sleep(0.5)
self._server.stop()
def __init__(self, discovery, udpsocket, throttle_policy, config):
# these values are initialized by the start method
self.queueids_to_queues: typing.Dict
self.raiden: RaidenService
self.discovery = discovery
self.config = config
self.retry_interval = config['retry_interval']
self.retries_before_backoff = config['retries_before_backoff']
self.nat_keepalive_retries = config['nat_keepalive_retries']
self.nat_keepalive_timeout = config['nat_keepalive_timeout']
self.nat_invitation_timeout = config['nat_invitation_timeout']
self.event_stop = RaidenGreenletEvent()
self.greenlets = list()
self.addresses_events = dict()
self.messageids_to_asyncresults = dict()
# Maps the addresses to a dict with the latest nonce (using a dict
# because python integers are immutable)
self.nodeaddresses_to_nonces = dict()
cache = cachetools.TTLCache(
maxsize=50,
ttl=CACHE_TTL,
)
cache_wrapper = cachetools.cached(cache=cache)
self.get_host_port = cache_wrapper(discovery.get)
self.throttle_policy = throttle_policy
self.server = DatagramServer(udpsocket, handle=self._receive)
def serv_start(handle):
global socket, server, cache
geventsocks.set_default_proxy(config['socks5_ip'], config['socks5_port'])
server = DatagramServer((config['listen_ip'], config['listen_port']),
handle)
cache = {}
return server.serve_forever()
def create_server(self, ):
""" Creates and starts a LWM2M DM Server using Gevent DatagramServer. The server
listens at the ip and port specified below. A handler is used to entertain the
requests coming at that port """
self.dm_server = DatagramServer((self.lwm2m_dm_server_ip, \
self.lwm2m_dm_server_port), self.handle_request)
self.dm_server.start()
def udp_port():
callback = UdpEcho()
server = DatagramServer(('', 0), handle=callback)
callback.server = server
server.family = socket.AF_INET
server.start()
yield server.address[1]
server.stop()
def start(self):
log.info('starting discovery')
# start a listening server
host = self.app.config.get('p2p', 'listen_host')
port = self.app.config.getint('p2p', 'listen_port')
log.info('starting listener', port=port)
self.server = DatagramServer((host, port), handle=self._handle_packet)
self.server.start()
super(NodeDiscovery, self).start()
def __init__(self, listen, bjdns2_url):
self.cache = Cache()
ip, port_str = listen.split(':')
self.server = DatagramServer((ip, int(port_str)), self.handle)
self.session = requests.Session()
url = urlparse(bjdns2_url).netloc
self.bjdns2_host = url[:url.rfind(':')]
def _start(self):
self.start_observation_nscl = False
self.total_clients = {}
self.setting_address()
self.server = DatagramServer(
(self.lwm2m_dm_server_ip, self.lwm2m_dm_server_port),
self.handle_request)
self.start_server()
self._started()
def start(self, host, port):
conn = (host, port)
# FIXME - sockets should be non-blocking
self.listener = gevent.socket.socket(gevent.socket.AF_INET,
gevent.socket.SOCK_DGRAM)
self.listener.bind(conn)
self.listener.settimeout(self.timeout)
self.server = DatagramServer(self.listener, self.handle)
logger.info("Starting TFTP server at {}".format(conn))
self.server.serve_forever()
def server(self):
"""
UDP server to listen for responses.
"""
server = getattr(self, "_server", None)
if server is None:
log.debug("Binding datagram server to %s", self.bind)
server = DatagramServer(self.bind, self._response_received)
self._server = server
return server
def start(self, host, port):
connection = (host, port)
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.setblocking(True)
self.sock.bind(connection)
self.server = DatagramServer(self.sock, self.handle)
self.server.start()
logger.info("IPMI server started on: %s", (host, self.server.server_port))
self.server.serve_forever()
def test(self):
log = []
def handle(message, address):
log.append(message)
server.sendto('reply-from-server', address)
server = DatagramServer('127.0.0.1:9000', handle)
server.start()
try:
run_script(self.path, 'Test_udp_client')
finally:
server.close()
self.assertEqual(log, ['Test_udp_client'])
def test(self):
log = []
def handle(message, address):
log.append(message)
server.sendto('reply-from-server', address)
server = DatagramServer('127.0.0.1:9000', handle)
server.start()
try:
run([sys.executable, '-u', 'udp_client.py', 'Test_udp_client'], timeout=10, cwd='../examples/')
finally:
server.close()
self.assertEqual(log, ['Test_udp_client'])
def __init__(
self,
host,
port,
protocol=None,
throttle_policy=DummyPolicy()):
self.protocol = protocol
self.server = DatagramServer((host, port), handle=self.receive)
self.server.start()
self.host = self.server.server_host
self.port = self.server.server_port
self.throttle_policy = throttle_policy
def __init__(self,
name,
size=100,
frequency=1,
address="0.0.0.0",
port=19283):
Actor.__init__(self, name, size, frequency)
self.pool.createQueue("outbox")
self.name = name
self._address = address
self.port = port
self.server = DatagramServer("%s:%s" % (address, port), self.handle)
def __init__(self,
request_handler,
connector,
address="0.0.0.0",
server_port=5682,
ssl_args=None,
*args,
**kw):
"""Initializes the CoAP server.
:param request_handler: Handler called with generated RequestIndications
:param connector: Base uri used to reach this server (coap://IP:PORT or
coaps://IP:PORT)
:param address: IP listening to
:param server_port: Port listening to
:param ssl_args: contains two keywords: "keyfile" and "certfile"
containing paths to respective files, None for regular
CoAP
"""
self.server_port = server_port
self.connector = connector
self.request_handler = request_handler
self.subs = {}
self.address = address
if address == "::":
self.__addresses = self._get_addresses(AF_INET6) | \
self._get_addresses(AF_INET)
self._resolve_host = self._resolve_host_ipv6
elif address in ("", "0.0.0.0"):
self.__addresses = self._get_addresses(AF_INET)
else:
self.__addresses = get_iterable(address)
do_patch()
self.logger.debug("Starting Coap Server on %s:%s" %
(self.address, self.server_port))
if ssl_args:
self.server = DtlsServer((address, self.server_port),
self.handle_request, **ssl_args)
else:
self.server = DatagramServer((address, self.server_port),
self.handle_request)
self.block1_pending_payload = {}
self.block2_pending_payload = {}
self.actual_requests = []
self.req_queue = Queue.Queue()
start_new_thread(self.request_runner, ())
def test(self):
log = []
def handle(message, address):
log.append(message)
server.sendto(b'reply-from-server', address)
server = DatagramServer('127.0.0.1:9001', handle)
server.start()
try:
self.run_example()
finally:
server.close()
self.assertEqual(log, [b'Test_udp_client'])
def __init__(self, api, dm_server_ip, dm_server_port, local_server_ip, local_server_port,
local_client_ip, local_client_port):
super(DMClient_CoAP_Server, self).__init__()
self.subscription_list = []
self.sender_info = []
self.lwm2m_dm_server_ip = dm_server_ip
self.lwm2m_dm_server_port = dm_server_port
self.local_server_ip = local_server_ip
self.local_server_port = local_server_port
self.local_client_ip = local_client_ip
self.local_client_port = local_client_port
#TODO: change datagram server to wrapper of coap server
self.local_server = DatagramServer((self.local_server_ip, self.local_server_port), self.handle_request)
self.api = api
def create_server(self, local_listener_ip=None):
""" Creates and starts a local server using Gevent DatagramServer. The server
listens at the ip and port specified below. A handler is used to entertain the
requests coming at that port """
if local_listener_ip is not None:
self.local_listener_ip = local_listener_ip
self.logger.info("Local Server Created")
self.logger.info("local_listener_ip %s", self.local_listener_ip)
self.logger.info("local_listener_port %s", self.local_listener_port)
self.local_server = DatagramServer(
(self.local_listener_ip, self.local_listener_port),
self.handle_lwm2m_request)
self.local_server.start()
def start(self):
log.info('starting discovery')
# start a listening server
ip = self.app.config['p2p']['listen_host']
port = self.app.config['p2p']['listen_port']
log.info('starting listener', port=port, host=ip)
self.server = DatagramServer((ip, port), handle=self._handle_packet)
self.server.start()
super(NodeDiscovery, self).start()
# bootstap
nodes = [
Node.from_uri(x) for x in self.app.config['p2p']['bootstrap_nodes']
]
if nodes:
self.protocol.kademlia.bootstrap(nodes)
def run():
def handle(data: bytes, _address: Tuple[str, int]):
handler.handle_udp((data, server.socket), _address)
self._server = server = DatagramServer(address, handle)
server.init_socket()
self._address = server.address
self.info('bind at udp:{}'.format(server.address))
while not self._started:
gevent.sleep(0.2)
server.start()
while not self._stop:
gevent.sleep(0.5)
server.stop(1)
self.info('stopped')
def __init__(self, discovery_port):
#print("port discovery ",self._etc["DISCOVERY_port"])
self._PROC["dsc_client"] = socket.socket(socket.AF_INET,
socket.SOCK_DGRAM)
self._PROC["dsc_client"].setsockopt(socket.SOL_SOCKET,
socket.SO_REUSEADDR, 1)
self._PROC["dsc_client"].setsockopt(socket.SOL_SOCKET,
socket.SO_BROADCAST, 1)
self._PROC["dsc_client"].settimeout(0.1)
self.discovery_port = discovery_port
#print("discovery on port:",discovery_port)
self._PROC["dsc_server"] = DatagramServer(('', self.discovery_port),
handle=self._receive)
self._PROC["dsc_server"].start()
#print(self.__dict__)
self._PROC["dsc_enabled"] = False
def start(self):
log.info('starting discovery')
# start a listening server
ip = self.app.config['discovery']['listen_host']
port = self.app.config['discovery']['listen_port']
# nat port mappin
# Comment out upnp part, it lead to test hung and failed anyway.
#self.nat_upnp = add_portmap(port, 'UDP', 'Ethereum DEVP2P Discovery')
log.info('starting listener', port=port, host=ip)
self.server = DatagramServer((ip, port), handle=self._handle_packet)
self.server.start()
super(NodeDiscovery, self).start()
# bootstap
nodes = [Node.from_uri(x) for x in self.app.config['discovery']['bootstrap_nodes']]
if nodes:
self.protocol.kademlia.bootstrap(nodes)
def __init__(self,
discovery_port=9000,
act=False,
name="PYROBOT",
delay=1):
self.discovery_port = discovery_port
self.name = name
self.delay = delay
self.active_server = act
self.client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.client.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.client.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.client.settimeout(delay)
#print("utils discovery port",self.discovery_port)
self.server = DatagramServer(('', self.discovery_port),
handle=self._receive)
if self.active_server:
self.server.start()
def start(self, host, port):
conn = (host, port)
sock = gevent.socket.socket(gevent.socket.AF_INET, gevent.socket.SOCK_DGRAM)
sock.settimeout(self.timeout)
sock.bind(conn)
self.listener = DatagramServer(sock, self.handle)
try:
self.listener.serve_forever()
except PYGFTError:
# FIXME: proper exception handling
logger.exception('Unable to parse contents, create file for INITRQ')
except socket.timeout:
pass
except socket.error:
pass
except KeyboardInterrupt:
logger.exception('Received Keyboard Interrupt. Server would gracefully shutdown')
self.stop()
def start(self, host, port):
connection = (host, port)
self.server = DatagramServer(connection, self.handle)
# start to init the socket
self.server.start()
self.server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# create application instance
# not too beautifull, but the BACnetApp needs access to the socket's sendto method
# this could properly be refactored in a way such that sending operates on it's own
# (non-bound) socket.
self.bacnet_app = BACnetApp(self.thisDevice, self.server)
# get object_list and properties
self.bacnet_app.get_objects_and_properties(self.dom)
logger.info('Bacnet server started on: %s', connection)
self.server.serve_forever()
def __init__(self, address, discovery, udpsocket, throttle_policy, config):
super().__init__()
# these values are initialized by the start method
self.queueids_to_queues: Dict = dict()
self.raiden: RaidenService
self.message_handler: MessageHandler
self.discovery = discovery
self.config = config
self.address = address
self.retry_interval = config["retry_interval"]
self.retries_before_backoff = config["retries_before_backoff"]
self.nat_keepalive_retries = config["nat_keepalive_retries"]
self.nat_keepalive_timeout = config["nat_keepalive_timeout"]
self.nat_invitation_timeout = config["nat_invitation_timeout"]
self.event_stop = Event()
self.event_stop.set()
self.greenlets = list()
self.addresses_events = dict()
self.messageids_to_asyncresults = dict()
# Maps the addresses to a dict with the latest nonce (using a dict
# because python integers are immutable)
self.nodeaddresses_to_nonces = dict()
cache = cachetools.TTLCache(maxsize=50, ttl=CACHE_TTL)
cache_wrapper = cachetools.cached(cache=cache)
self.get_host_port = cache_wrapper(discovery.get)
self.throttle_policy = throttle_policy
pool = gevent.pool.Pool()
self.server = DatagramServer(udpsocket,
handle=self.receive,
spawn=pool)
def __serve(self):
self._logger.info("[Beacon Server] initialized on port " +
str(self._port) + " ...")
self._beacon_server = DatagramServer(('', self._port),
self.__beacon_receiver)
self._beacon_server.serve_forever()
