def __init__(self, address, config):
DatagramServer.__init__(self, address)
self.config = config
if self.config.radiusd.adapter == 'rest':
from toughradius.radiusd.adapters.rest import RestAdapter
self.adapter = RestAdapter(self.config)
self.start()
class UDPTransport(object):
""" Node communication using the UDP protocol. """
def __init__(self, host, port, protocol=None):
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
def receive(self, data, host_port): # pylint: disable=unused-argument
self.protocol.receive(data)
# enable debugging using the DummyNetwork callbacks
DummyTransport.track_recv(self.protocol.raiden, host_port, data)
def send(self, sender, host_port, bytes_):
""" Send `bytes_` to `host_port`.
Args:
sender (address): The address of the running node.
host_port (Tuple[(str, int)]): Tuple with the host name and port number.
bytes_ (bytes): The bytes that are going to be sent throught the wire.
"""
self.server.sendto(bytes_, host_port)
# enable debugging using the DummyNetwork callbacks
DummyTransport.network.track_send(sender, host_port, bytes_)
def register(self, proto, host, port): # pylint: disable=unused-argument
assert isinstance(proto, RaidenProtocol)
self.protocol = proto
def __init__(self, proto, call_id, session, invite_message):
logger.debug("{:s} __init__".format(self))
logger.debug("SipCall {} session {} ".format(self, session))
connection.__init__(self, proto)
# Store incoming information of the remote host
self.__session = session
self.__state = SipCall.SESSION_SETUP
self.__msg = invite_message
# list of messages
self._msg_stack = []
self.__call_id = invite_message.headers.get(b"call-id").value
self._call_id = call_id
self._rtp_streams = {}
self.local.host = self.__session.local.host
self.local.port = self.__session.local.port
self.remote.host = self.__session.remote.host
self.remote.port = self.__session.remote.port
user = self.__msg.headers.get(b"to").get_raw().uri.user
self._user = g_sipconfig.get_user_by_username(
self.__session.personality,
user
)
class BeaconServer:
def __init__(self, port, task_queue):
self._port = port
self._serving = False
self._serving_greenlet = None
self._beacon_server = None
self._logger = logging.getLogger(__name__)
self._task_queue = task_queue
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()
def __beacon_receiver(self, msg, address):
self._task_queue.put([address, msg])
def serve(self):
if not self._serving:
self._serving_greenlet = gevent.spawn(self.__serve)
self._serving = True
gevent.sleep(0)
else:
pass
def close(self):
logger.debug("{:s} close".format(self))
logger.debug("SipCall.close {} Session {}".format(self, self.__session))
global g_call_ids
g_call_ids[self._call_id] = None
self.__state = SipCall.CLOSED
# stop timers
for name, timer in self._timers.items():
if not timer:
continue
logger.debug("SipCall timer {} active {} pending {}".format(timer,timer.active,timer.pending))
#if timer.active == True or timer.pending == True:
# logger.warn("SipCall Stopping {}".format(name))
timer.stop()
self._timers = {}
# close rtpStream
for n, v in self._rtp_streams.items():
if v:
v.close()
self._rtp_streams[n] = None
self._rtp_streams = {}
# close connection
connection.close(self)
def __init__(self, name, call, session, local_address, local_port, remote_address, remote_port, bistream_enabled=False, pcap=None):
logger.debug("{:s} __init__".format(self))
connection.__init__(self, 'udp')
self._call = call
self._name = name
self._pcap = pcap
self._session = session
# Bind to free random port for incoming RTP traffic
self.bind(local_address, local_port)
self.connect(remote_address, remote_port)
# The address and port of the remote host
self.remote.host = remote_address
self.remote.port = remote_port
self._bistream = []
self._bistream_enabled = bistream_enabled
# Send byte buffer
self.__sendBuffer = b''
logger.info("Created RTP channel on ports :{} <-> :{}".format(
self.local.port, self.remote.port))
def __init__(self, bindaddr, registry, dns_servers=None):
DatagramServer.__init__(self, bindaddr)
self._registry = registry
self._resolver = None
if dns_servers:
self._resolver = Resolver(servers=dns_servers,
timeout=DNS_RESOLVER_TIMEOUT, tries=1)
def __init__(self, *args, **kwargs):
self.proxy_ip = kwargs.pop('proxy_ip')
self.proxy_ip_reversed = '.'.join(reversed(self.proxy_ip.split('.')))
self.mapped_domains_regexed = [FROM_DOMAIN(domain) for domain in kwargs.pop('mapped_domains')]
self.mapped_domain_cache = set()
self.logger = logging.getLogger('unblockme.dns.DNSServer')
DatagramServer.__init__(self, *args, **kwargs)
def _init(self, **kwargs):
DatagramServer.__init__(self, ":%s" % self.port, handle=self.handle)
self.socket = self.get_listener(self.address, self.family)
self.address = self.socket.getsockname()
self._socket = self.socket
try:
self._socket = self._socket._sock
except AttributeError:
pass
self.TTL = 60 * 5
self.rtypes = {}
self.rtypes["A"] = dnslib.QTYPE.A
self.rtypes["AAAA"] = dnslib.QTYPE.AAAA
self.rtypes["NS"] = dnslib.QTYPE.NS
self.rtypes["MX"] = dnslib.QTYPE.MX
self.rdatatypes = {}
self.rdatatypes["A"] = dnslib.A
self.rdatatypes["AAAA"] = dnslib.AAAA
self.rdatatypes["NS"] = dnslib.NS
self.rdatatypes["MX"] = dnslib.MX
self._resolver = None
def _set_server(self, port):
"""对udp服务进行初始设置
Args:
port: udp服务的端口号
"""
self.port, self.bind = int(port), ":{}".format(port)
DatagramServer.__init__(self, self.bind)
def stop(self, timeout=None):
"""
Stop
"""
if not self._is_started:
logger.warn("Not started, bypass")
return
# Base stop
logger.info("Stopping base")
DatagramServer.stop(self, timeout=timeout)
logger.info("Stopped base")
# Greenlet stop
if self._server_greenlet:
logger.info("Killing _server_greenlet")
self._server_greenlet.kill()
self._server_greenlet = None
# Close socket
SocketHelpers.safe_close_socket(self._soc)
# Remove socket
try:
if os.path.exists(self._socket_name):
os.remove(self._socket_name)
except Exception as e:
logger.warn("Socket file remove ex=%s", SolBase.extostr(e))
# Signal stopped
self._is_started = False
class UDPTransport(object):
""" Node communication using the UDP protocol. """
def __init__(self, host, port, protocol=None):
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
def receive(self, data, host_port): # pylint: disable=unused-argument
self.protocol.receive(data)
# enable debugging using the DummyNetwork callbacks
DummyTransport.track_recv(self.protocol.raiden, host_port, data)
def send(self, sender, host_port, bytes_):
""" Send `bytes_` to `host_port`.
Args:
sender (address): The address of the running node.
host_port (Tuple[(str, int)]): Tuple with the host name and port number.
bytes_ (bytes): The bytes that are going to be sent throught the wire.
"""
self.server.sendto(bytes_, host_port)
# enable debugging using the DummyNetwork callbacks
DummyTransport.network.track_send(sender, host_port, bytes_)
def register(self, proto, host, port): # pylint: disable=unused-argument
assert isinstance(proto, RaidenProtocol)
self.protocol = proto
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 __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)
class BeaconServer(Server):
def __init__(self, port, task_queue):
self._port = port
self._serving = False
self._serving_greenlet = None
self._beacon_server = None
self._logger = logging.getLogger(__name__)
self._task_queue = task_queue
def __serve(self):
self._logger.info("[BeaconServer] initialized on port " + str(self._port) + " ...")
self._beacon_server = DatagramServer(('', self._port), self.__beacon_receiver)
self._beacon_server.serve_forever()
def __beacon_receiver(self, msg, address):
self._task_queue.put([address, msg])
def start_server(self):
if not self._serving:
self._serving_greenlet = gevent.spawn(self.__serve)
self._serving = True
gevent.sleep(0)
def stop_server(self):
if self._serving:
gevent.kill(self._serving_greenlet)
self._serving = False
self._beacon_server.close()
self._logger.info("[BeaconServer] shut down")
def __init__(self, *args, **kwargs): """Set up some vars for this instance""" self.queue = Queue() pixelcanvas = Canvas(self.queue, kwargs['options']) __request_processing_greenlet = spawn(pixelcanvas.CanvasUpdate) del (kwargs['options']) DatagramServer.__init__(self, *args, **kwargs)
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()
class UDPTransport(object):
""" Node communication using the UDP protocol. """
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 receive(self, data, host_port): # pylint: disable=unused-argument
self.protocol.receive(data)
# enable debugging using the DummyNetwork callbacks
DummyTransport.track_recv(self.protocol.raiden, host_port, data)
def send(self, sender, host_port, bytes_):
""" Send `bytes_` to `host_port`.
Args:
sender (address): The address of the running node.
host_port (Tuple[(str, int)]): Tuple with the host name and port number.
bytes_ (bytes): The bytes that are going to be sent through the wire.
"""
sleep_timeout = self.throttle_policy.consume(1)
# Don't sleep if timeout is zero, otherwise a context-switch is done
# and the message is delayed, increasing it's latency
if sleep_timeout:
gevent.sleep(sleep_timeout)
if not hasattr(self.server, 'socket'):
raise RuntimeError('trying to send a message on a closed server')
self.server.sendto(bytes_, host_port)
# enable debugging using the DummyNetwork callbacks
DummyTransport.network.track_send(sender, host_port, bytes_)
def stop(self):
self.server.stop()
def stop_accepting(self):
self.server.stop_accepting()
def start(self):
assert not self.server.started
# server.stop() clears the handle, since this may be a restart the
# handle must always be set
self.server.set_handle(self.receive)
self.server.start()
class NodeDiscovery(BaseService, DiscoveryProtocolTransport):
"""
Persist the list of known nodes with their reputation
"""
name = 'discovery'
server = None # will be set to DatagramServer
def __init__(self, app):
BaseService.__init__(self, app)
log.info('NodeDiscovery init')
self.protocol = DiscoveryProtocol(app=self.app, transport=self)
@property
def address(self):
return Address(self.app.config.get('p2p', 'listen_host'),
self.app.config.getint('p2p', 'listen_port'))
def _send(self, address, message):
assert isinstance(address, Address)
sock = gevent.socket.socket(type=gevent.socket.SOCK_DGRAM)
# sock.bind(('0.0.0.0', self.address.port)) # send from our recv port
sock.connect((address.ip, address.port))
log.debug('sending', size=len(message), to=address)
sock.send(message)
def send(self, address, message):
assert isinstance(address, Address)
log.debug('sending', size=len(message), to=address)
self.server.sendto(message, (address.ip, address.port))
def receive(self, address, message):
assert isinstance(address, Address)
self.protocol.receive(address, message)
def _handle_packet(self, message, ip_port):
log.debug('handling packet', address=ip_port, size=len(message))
assert len(ip_port) == 2
address = Address(ip=ip_port[0], port=ip_port[1])
self.receive(address, message)
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 _run(self):
log.debug('_run called')
evt = gevent.event.Event()
evt.wait()
def stop(self):
log.info('stopping discovery')
self.server.stop()
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 __init__(self, address,nases={},dict=dictionary.Dictionary("dictionary")):
DatagramServer.__init__(self,address)
self.nases = nases
self.address = address
self.dict = dict
self.start()
self.socket.setsockopt(socket.SOL_SOCKET,
socket.SO_RCVBUF,10240000)
class UdpServer(TcpRpcServer):
def __init__(self, port):
self.port = port
self.server = DatagramServer(('', self.port), handle=self.handle)
self.protocol = PT_UDP
def handle(self, data, address):
self.server.sendto(data, address)
def __init__(self, name, address="0.0.0.0", port=19283):
DatagramServer.__init__(self, "%s:%s"%(address, port))
Actor.__init__(self, name, setupbasic=False)
self.createQueue("outbox")
self.name = name
self._address = address
self.port = port
self.logging.info ( 'Started and listening on %s:%s' % (self._address, self.port) )
def __init__(self, bindaddr, registry, dns_servers=None):
DatagramServer.__init__(self, bindaddr)
self._registry = registry
self._resolver = None
if dns_servers:
self._resolver = Resolver(servers=dns_servers,
timeout=DNS_RESOLVER_TIMEOUT,
tries=1)
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 __init__(self, server, **config):
self._set_config(**config)
self.server = server
self.jails = server.jails
self.jails_members = server.jails_members
self.jails_config = server.jails_config
self.stats = server.stats
self.logger = server.register_logger("action_server")
DatagramServer.__init__(self, (self.config['host'], self.config['port']))
def __init__(self,
socket_name=None,
windows_host=None,
windows_port=None,
*args,
**kwargs):
"""
Init
:param socket_name: str,None
:type socket_name: str,None
:param windows_host: str,None
:type windows_host: str,None
:param windows_port: int,None
:type windows_port: int,None
"""
# Call base
DatagramServer.__init__(self, *args, **kwargs)
# NAME
if socket_name:
self._socket_name = socket_name
else:
# If UNITTEST, force
if "KNOCK_UNITTEST" in os.environ:
self._socket_name = UdpServer.UDP_UNITTEST_SOCKET_NAME
else:
self._socket_name = UdpServer.UDP_SOCKET_NAME
# WINDOWS HOST
if windows_host:
self._windows_host = windows_host
else:
# If UNITTEST, force
if "KNOCK_UNITTEST" in os.environ:
self._windows_host = UdpServer.UDP_WINDOWS_UNITTEST_SOCKET_HOST
else:
self._windows_host = UdpServer.UDP_WINDOWS_SOCKET_HOST
# WINDOWS PORT
if windows_port:
self._windows_port = windows_port
else:
# If UNITTEST, force
if "KNOCK_UNITTEST" in os.environ:
self._windows_port = UdpServer.UDP_WINDOWS_UNITTEST_SOCKET_PORT
else:
self._windows_port = UdpServer.UDP_WINDOWS_SOCKET_PORT
# Init
self._is_started = False
self._server_greenlet = None
# Logs
logger.info("_socket_name=%s", self._socket_name)
logger.info("_windows_host=%s", self._windows_host)
logger.info("_windows_port=%s", self._windows_port)
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()
class UDPIn(Actor):
'''**A UDP server.**
A UDP server.
Parameters:
- name(str)
| The name of the module.
- size(int)
| The default max length of each queue.
- frequency(int)
| The frequency in seconds to generate metrics.
- address(string)("0.0.0.0")
| The address to bind to.
- port(int)(19283)
| The port to listen on.
- reuse_port(bool)(False)
| Whether or not to set the SO_REUSEPORT socket option.
| Allows multiple instances to bind to the same port.
| Requires Linux kernel >= 3.9
Queues:
- outbox
| Incoming events.
'''
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 handle(self, data, address):
'''Is called upon each incoming message'''
self.submit({'header': {}, 'data': data}, self.pool.queue.outbox)
def preHook(self):
self.logging.info('Started listening on %s:%s' %
(self._address, self.port))
self.server.start()
def __init__(self, server, **config):
self._set_config(**config)
self.server = server
self.jails = server.jails
self.jails_members = server.jails_members
self.jails_config = server.jails_config
self.stats = server.stats
self.logger = server.register_logger("action_server")
DatagramServer.__init__(self,
(self.config['host'], self.config['port']))
def __init__(self, addr, proto=None):
logger.debug("SipSession __init__")
self.transport = proto
connection.__init__(self, addr)
# FIXME: Use the proper address
self.personality = g_sipconfig.get_personality_by_address("192.168.1.2")
logger.info("SIP Session created with personality '{}'".format(self.personality))
self._auth = None
self._state = None
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 __init__(self,
address,
nases={},
dict=dictionary.Dictionary("dictionary")):
DatagramServer.__init__(self, address)
self.nases = nases
self.address = address
self.dict = dict
self.start()
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 10240000)
def __init__(self, bindaddr, registry, dns_servers=None):
DatagramServer.__init__(self, bindaddr)
self._registry = registry
self._resolver = None
if dns_servers:
log.info("[namesrv] starting with failover resolver %s",
dns_servers)
self._resolver = Resolver(servers=dns_servers,
timeout=DNS_RESOLVER_TIMEOUT,
tries=1)
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()
class Server(object):
def __init__(self, bind_ip='127.0.0.1', tcp_port=DEFAULT_TCP, udp_port=DEFAULT_UDP, redis_host='localhost', redis_port=6379, redis_queue='logstash', message_type='pystash', fqdn=True, logstash_version=1, logstash_tags=None):
self.redis = redis.Redis(redis_host, redis_port)
self.redis_queue = redis_queue
if logstash_version == 1:
self.formatter = formatter.LogstashFormatterVersion1(message_type, logstash_tags, fqdn)
else:
self.formatter = formatter.LogstashFormatterVersion0(message_type, logstash_tags, fqdn)
self.udp_server = DatagramServer('%s:%s' % (bind_ip, udp_port), self.udp_handle)
self.tcp_server = StreamServer('%s:%s' % (bind_ip, tcp_port), self.tcp_handle)
logging.info('Listening on %s (udp=%s tcp=%s) sending to %s:%s.', bind_ip, udp_port, tcp_port, redis_host, redis_port)
def obj_to_redis(self, obj):
record = logging.makeLogRecord(obj)
payload = self.formatter.format(record)
#logger.debug('message %s', payload)
try:
self.redis.rpush(self.redis_queue, payload)
except redis.RedisError as exc:
logging.error('Redis error: %s' % exc)
def udp_handle(self, data, address):
slen = struct.unpack('>L', data[:4])[0]
chunk = data[4:slen+4]
try:
obj = cPickle.loads(chunk)
except EOFError:
logging.error('UDP: invalid data to pickle %s', chunk)
return
self.obj_to_redis(obj)
def tcp_handle(self, socket, address):
fileobj = socket.makefile()
while True:
chunk = fileobj.read(4)
if len(chunk) < 4:
break
slen = struct.unpack(">L", chunk)[0]
chunk = fileobj.read(slen)
while len(chunk) < slen:
chunk = chunk + fileobj.read(slen - len(chunk))
fileobj.flush()
try:
obj = cPickle.loads(chunk)
except EOFError:
logging.error('TCP: invalid data to pickle %s', chunk)
break
self.obj_to_redis(obj)
def start(self):
self.udp_server.start()
self.tcp_server.start()
gevent.wait()
class Broadcast_Sub(object):
def __init__(self, host, port, on_handler, qos=0):
self.host = host
self.port = port
self.qos = qos
self.bcast = DatagramServer(('', self.port), handle=on_handler)
self.bcast.start()
def receive(self, data, address):
value = json.loads(data.decode())
payload, type, date = json.loads(data.decode())
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([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, max_node_qsize, bind_ip):
s = ':' + str(bind_ip)
self.bind_ip = bind_ip
DatagramServer.__init__(self, s)
self.process_request_actions = {
"get_peers": self.on_get_peers_request,
"announce_peer": self.on_announce_peer_request,
}
self.max_node_qsize = max_node_qsize
self.nid = random_id()
self.nodes = deque(maxlen=max_node_qsize)
def __init__(self, ioHubServer, address):
self.iohub = ioHubServer
self.feed = None
self._running = True
self.iohub.log('ioHub Server configuring msgpack...')
self.coder = msgpack
self.packer = msgpack.Packer()
self.pack = self.packer.pack
self.unpacker = msgpack.Unpacker(use_list=True)
self.unpack = self.unpacker.unpack
self.feed = self.unpacker.feed
DatagramServer.__init__(self, address)
def __init__(self, ioHubServer, address):
self.iohub = ioHubServer
self.feed = None
self._running = True
self.iohub.log('ioHub Server configuring msgpack...')
self.coder = msgpack
self.packer = msgpack.Packer()
self.pack = self.packer.pack
self.unpacker = msgpack.Unpacker(use_list=True)
self.unpack = self.unpacker.unpack
self.feed = self.unpacker.feed
DatagramServer.__init__(self, address)
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'])
class UDPIn(Actor):
'''**A UDP server.**
A UDP server.
Parameters:
- name(str)
| The name of the module.
- size(int)
| The default max length of each queue.
- frequency(int)
| The frequency in seconds to generate metrics.
- address(string)("0.0.0.0")
| The address to bind to.
- port(int)(19283)
| The port to listen on.
- reuse_port(bool)(False)
| Whether or not to set the SO_REUSEPORT socket option.
| Allows multiple instances to bind to the same port.
| Requires Linux kernel >= 3.9
Queues:
- outbox
| Incoming events.
'''
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 handle(self, data, address):
'''Is called upon each incoming message'''
self.submit({'header': {}, 'data': data}, self.pool.queue.outbox)
def preHook(self):
self.logging.info('Started listening on %s:%s' % (self._address, self.port))
self.server.start()
def __init__(self,ioHubServer,address,coder='msgpack'):
self.iohub=ioHubServer
self.feed=None
self._running=True
if coder == 'msgpack':
self.iohub.log("ioHub Server configuring msgpack...")
self.coder=msgpack
self.packer=msgpack.Packer()
self.unpacker=msgpk_unpacker
self.pack=self.packer.pack
self.feed=msgpk_unpacker.feed
self.unpack=msgpk_unpack
DatagramServer.__init__(self,address)
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,ioHubServer,address,coder='msgpack'):
global MAX_PACKET_SIZE
import psychopy.iohub.net
MAX_PACKET_SIZE = psychopy.iohub.net.MAX_PACKET_SIZE
self.iohub=ioHubServer
self.feed=None
self._running=True
if coder == 'msgpack':
self.iohub.log("ioHub Server configuring msgpack...")
self.coder=msgpack
self.packer=msgpack.Packer()
self.pack=self.packer.pack
self.unpacker=msgpack.Unpacker(use_list=True)
self.unpack=self.unpacker.unpack
self.feed=self.unpacker.feed
DatagramServer.__init__(self,address)
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 __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 = Event()
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 __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 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 start(self):
self.register_logger("gevent_helpers")
for comp in self.components.itervalues():
comp.manager = self # Add a backreference for leaky abstractions
comp.counters = self.register_stat_counters(comp, comp.one_min_stats, comp.one_sec_stats)
# Register a separate logger for each component
if comp is not self:
comp.logger = self.register_logger(comp.name)
comp.start()
# Starts the greenlet
Component.start(self)
# Start the datagram control server if it's been inited
if self.config['datagram']['enabled']:
DatagramServer.start(self, )
# This is the main thread of execution, so just continue here waiting
# for exit signals
######
# Register shutdown signals
gevent.signal(signal.SIGUSR1, self.dump_objgraph)
gevent.signal(signal.SIGHUP, exit, "SIGHUP")
gevent.signal(signal.SIGINT, exit, "SIGINT")
gevent.signal(signal.SIGTERM, exit, "SIGTERM")
try:
gevent.wait()
# Allow a force exit from multiple exit signals (Ctrl+C mashed multiple times)
finally:
self.logger.info("Exiting requested, allowing {} seconds for cleanup."
.format(self.config['term_timeout']))
try:
for comp in self.components.itervalues():
self.logger.debug("Calling stop on component {}".format(comp))
comp.stop()
if gevent.wait(timeout=self.config['term_timeout']):
self.logger.info("All threads exited normally")
else:
self.logger.info("Timeout reached, shutting down forcefully")
except gevent.GreenletExit:
self.logger.info("Shutdown requested again by system, "
"exiting without cleanup")
self.logger.info("Exit")
self.logger.info("=" * 80)
def __init__(self, bind_ip='127.0.0.1', tcp_port=DEFAULT_TCP, udp_port=DEFAULT_UDP, redis_host='localhost', redis_port=6379, redis_queue='logstash', message_type='pystash', fqdn=True, logstash_version=1, logstash_tags=None):
self.redis = redis.Redis(redis_host, redis_port)
self.redis_queue = redis_queue
if logstash_version == 1:
self.formatter = formatter.LogstashFormatterVersion1(message_type, logstash_tags, fqdn)
else:
self.formatter = formatter.LogstashFormatterVersion0(message_type, logstash_tags, fqdn)
self.udp_server = DatagramServer('%s:%s' % (bind_ip, udp_port), self.udp_handle)
self.tcp_server = StreamServer('%s:%s' % (bind_ip, tcp_port), self.tcp_handle)
logging.info('Listening on %s (udp=%s tcp=%s) sending to %s:%s.', bind_ip, udp_port, tcp_port, redis_host, redis_port)
class UDPIn(Actor):
"""**A UDP server.**
A UDP server.
Parameters:
- address(string)("0.0.0.0")
| The address to bind to.
- port(int)(19283)
| The port to listen on.
- reuse_port(bool)(False)
| Whether or not to set the SO_REUSEPORT socket option.
| Allows multiple instances to bind to the same port.
| Requires Linux kernel >= 3.9
Queues:
- outbox
| Incoming events.
"""
def __init__(self, actor_config, address="0.0.0.0", port=19283):
Actor.__init__(self, actor_config)
self.pool.createQueue("outbox")
self.server = DatagramServer("%s:%s" % (self.kwargs.address, self.kwargs.port), self.handle)
def handle(self, data, address):
"""Is called upon each incoming message"""
event = self.createEvent()
event.data = data
self.submit(event, self.pool.queue.outbox)
def preHook(self):
self.logging.info("Started listening on %s:%s" % (self.kwargs.address, self.kwargs.port))
self.server.start()
def __init__(self, loggly_token, bind_ip='127.0.0.1', tcp_port=DEFAULT_TCP, udp_port=DEFAULT_UDP, fqdn=True, hostname=None, tags=None):
self.loggly_token = loggly_token
self.formatter = formatter.JSONFormatter(tags, hostname, fqdn)
self.udp_server = DatagramServer('%s:%s' % (bind_ip, udp_port), self.udp_handle)
self.tcp_server = StreamServer('%s:%s' % (bind_ip, tcp_port), self.tcp_handle)
self.queue = Queue()
[gevent.spawn(self.sender) for i in range(100)]
logging.info('Listening on %s (udp=%s tcp=%s).', bind_ip, udp_port, tcp_port)
class UDPTransport(object):
def __init__(self, host, port, protocol=None):
self.protocol = protocol
self.server = DatagramServer(('', 0), handle=self.receive)
self.server.start()
self.host = self.server.server_host
self.port = self.server.server_port
def receive(self, data, host_port):
self.protocol.receive(data)
def send(self, sender, host_port, data):
log.info('TRANSPORT SENDS')
self.server.sendto(data, host_port)
DummyTransport.network.track_send(sender, host_port, data) # debuging
def register(self, proto, host, port):
assert isinstance(proto, RaidenProtocol)
self.protocol = proto
def setUp(self):
# clean up before we start...
conpot_core.get_sessionManager().purge_sessions()
self.databus = conpot_core.get_databus()
self.databus.initialize("conpot/templates/default/template.xml")
args = namedtuple("FakeArgs", "")
bacnet = bacnet_server.BacnetServer("conpot/templates/default/bacnet/bacnet.xml", "none", args)
self.bacnet_server = DatagramServer(("127.0.0.1", 47808), bacnet.handle)
gevent.spawn(self.bacnet_server.start)
gevent.sleep(1)
def setUp(self):
# clean up before we start...
conpot_core.get_sessionManager().purge_sessions()
self.databus = conpot_core.get_databus()
self.databus.initialize('conpot/templates/default/template.xml')
args = namedtuple('FakeArgs', '')
bacnet = bacnet_server.BacnetServer('conpot/templates/default/bacnet/bacnet.xml', 'none', args)
self.bacnet_server = DatagramServer(('127.0.0.1', 0), bacnet.handle)
gevent.spawn(self.bacnet_server.start)
gevent.sleep(1)
assert self.bacnet_server.server_port
def close(self):
logger.debug("{:s} close".format(self))
logger.debug("Closing stream dump (in)")
connection.close(self)
if len(self._bistream) == 0:
return
now = datetime.datetime.now()
dirname = "%04i-%02i-%02i" % (now.year, now.month, now.day)
bistream_path = os.path.join('bistreams', dirname)
if not os.path.exists(bistream_path):
os.makedirs(bistream_path)
fp = tempfile.NamedTemporaryFile(
delete=False,
prefix="SipCall-{local_port}-{remote_host}:{remote_port}-".format(local_port=self.local.port, remote_host=self.remote.host, remote_port=self.remote.port),
dir=bistream_path
)
fp.write(b"stream = ")
fp.write(str(self._bistream).encode())
fp.close()
