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