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()
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 __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, 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
)
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, *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 _set_server(self, port):
"""对udp服务进行初始设置
Args:
port: udp服务的端口号
"""
self.port, self.bind = int(port), ":{}".format(port)
DatagramServer.__init__(self, self.bind)
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, 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:
self._resolver = Resolver(servers=dns_servers,
timeout=DNS_RESOLVER_TIMEOUT,
tries=1)
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 __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 __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 __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 __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,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,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, 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, address):
# UDP server
DatagramServer.__init__(self, address)
self.logger = logging.getLogger('synapse')
self.logger.setLevel(logging.INFO)
# Test connection to glia-server
url = "http://{host}/".format(host=app.config['LOGIN_SERVER'])
try:
requests.get(url)
except ConnectionError, e:
self.logger.error(
"Could not establish connection to glia server\n - {}".format(
e))
quit()
def __init__(self, port=53):
JSBASE.__init__(self)
DatagramServer.__init__(self, ":%s" % port, handle=self.handle)
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
def __init__(self,
listener,
handle=None,
backlog=None,
spawn='default',
**ssl_args):
"""Initializes the Server
Calls init_socket()
:param listener: Tuple (address, port) used by the server
:param handle: function called when application data is recieved
:param ssl_args: contains two keywords: "keyfile" and "certfile"
containing paths to respective files
"""
DatagramServer.__init__(self, listener, handle=handle, spawn=spawn)
self.backlog = backlog
self.ssl_args = ssl_args
def __init__(self, max_node_qsize, bind_ip):
s = ':' + str(bind_ip)
self.bind_ip = bind_ip
print(s)
DatagramServer.__init__(self, s)
self.process_request_actions = {
"get_peers": self.on_get_peers_request,
"announce_peer": self.on_announce_peer_request,
"ping":self.on_ping,
}
self.max_node_qsize = max_node_qsize
self.nid = random_id()
self.nodes = deque(maxlen=max_node_qsize)
self.peers = []
self.message_num = {"ping":0, "find_node":0, "get_peers":0, "announce_peer":0, "others":0}
#self.fnd = open("nodes.txt","w+")
self.peer_file = open("peers.txt","w+")
def __init__(self, port=53):
JSBASE.__init__(self)
DatagramServer.__init__(self, ":%s" % port, handle=self.handle)
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.db = j.clients.redis.core_get()
self.serve_forever()
def __init__(self,ioHubServer,address,coder='msgpack'):
self.iohub=ioHubServer
self.feed=None
self._running=True
if coder=='ujson':
self.iohub.log(" ioHub Server configuring ujson...")
import ujson
self.coder=ujson
self.pack=ujson.encode
self.unpack=ujson.decode
elif coder == 'msgpack':
self.iohub.log("ioHub Server configuring msgpack...")
import msgpack
self.coder=msgpack
self.packer=msgpack.Packer()
self.unpacker=msgpack.Unpacker(use_list=True)
self.pack=self.packer.pack
self.feed=self.unpacker.feed
self.unpack=self.unpacker.unpack
DatagramServer.__init__(self,address)
def __init__(self, ioHubServer, address, coder="msgpack"):
self.iohub = ioHubServer
self.feed = None
self._running = True
if coder == "ujson":
self.iohub.log(" ioHub Server configuring ujson...")
import ujson
self.coder = ujson
self.pack = ujson.encode
self.unpack = ujson.decode
elif coder == "msgpack":
self.iohub.log("ioHub Server configuring msgpack...")
import msgpack
self.coder = msgpack
self.packer = msgpack.Packer()
self.unpacker = msgpack.Unpacker(use_list=True)
self.pack = self.packer.pack
self.feed = self.unpacker.feed
self.unpack = self.unpacker.unpack
DatagramServer.__init__(self, address)
def __init__(self,ioHubServer,address,coder='msgpack'):
self.iohub=ioHubServer
self.feed=None
self._inHighPriorityMode=False
self._running=True
if coder=='ujson':
self.iohub.log(" ioHub Server configuring ujson...")
import ujson
self.coder=ujson
self.pack=ujson.encode
self.unpack=ujson.decode
elif coder == 'msgpack':
self.iohub.log("ioHub Server configuring msgpack...")
import msgpack
self.coder=msgpack
self.packer=msgpack.Packer()
self.unpacker=msgpack.Unpacker(use_list=True)
self.pack=self.packer.pack
self.feed=self.unpacker.feed
self.unpack=self.unpacker.unpack
DatagramServer.__init__(self,address)
print " **** TO DO: Implement multipacket sending when size of response is > packet size **** "
def __init__(self, address, gip, *args, **kwargs):
DatagramServer.__init__(self, listener=address, *args, **kwargs)
self.gip = gip
def registerTransport(self, tDomain, transport):
DatagramServer.__init__(self, transport, self.handle)
self.transportDomain = tDomain
def __init__(self, adapter, host="0.0.0.0", port=1813, pool_size=32):
DatagramServer.__init__(self, (host, port))
self.pool = Pool(pool_size)
self.adapter = adapter
def __init__(self, listen, store, *args, **kwargs):
self.store = store
DatagramServer.__init__(self, listen, *args, **kwargs)
def __init__(self, config):
self._configure(config)
self._log_handlers = []
# Parse command line args
self.config['server_number'] += self.config['args']['server_number']
self.config['procname'] += "_{}".format(self.config['server_number'])
# setup all our log handlers
for log_cfg in self.config['loggers']:
if log_cfg['type'] == "StreamHandler":
kwargs = dict(stream=sys.stdout)
else:
kwargs = dict()
handler = getattr(logging, log_cfg['type'])(**kwargs)
log_level = getattr(logging, log_cfg['level'].upper())
handler.setLevel(log_level)
fmt = log_cfg.get(
'format', '%(asctime)s [%(name)s] [%(levelname)s] %(message)s')
formatter = logging.Formatter(fmt)
handler.setFormatter(formatter)
self._log_handlers.append((log_cfg.get('listen'), handler))
self.logger = self.register_logger(self.__class__.__name__)
setproctitle.setproctitle(self.config['procname'])
self.version = powerpool.__version__
self.version_info = powerpool.__version_info__
self.sha = getattr(powerpool, '__sha__', "unknown")
self.rev_date = getattr(powerpool, '__rev_date__', "unknown")
if self.sha == "unknown":
# try and fetch the git version information
try:
output = subprocess.check_output(
"git show -s --format='%ci %h'",
shell=True).strip().rsplit(" ", 1)
self.sha = output[1]
self.rev_date = output[0]
# celery won't work with this, so set some default
except Exception as e:
self.logger.info("Unable to fetch git hash info: {}".format(e))
self.algos = {}
self.server_start = datetime.datetime.utcnow()
self.logger.info("=" * 80)
self.logger.info("PowerPool stratum server ({}) starting up...".format(
self.config['procname']))
if __debug__:
self.logger.warn(
"Python not running in optimized mode. For better performance "
"set enviroment variable PYTHONOPTIMIZE=2")
# Only try to detect blocking if running in debug mode.
# NOTE: BlockingDetector can cause (rare) PowerPool crashes
gevent.spawn(BlockingDetector(raise_exc=False))
# Detect and load all the hash functions we can find
for name, algo_data in self.config['algorithms'].iteritems():
self.algos[name] = algo_data.copy()
self.algos[name]['name'] = name
mod = algo_data['module']
try:
self.algos[name]['module'] = import_helper(mod)
except ImportError:
self.algos[name]['module'] = None
else:
self.logger.info(
"Enabling {} hashing algorithm from module {}".format(
name, mod))
self.event_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.events_enabled = self.config['events']['enabled']
if self.events_enabled:
self.logger.info(
"Transmitting statsd formatted stats to {}:{}".format(
self.config['events']['host'],
self.config['events']['port']))
self.events_address = (self.config['events']['host'].encode('utf8'),
self.config['events']['port'])
# Setup all our stat managers
self._min_stat_counters = []
self._sec_stat_counters = []
if self.config['datagram']['enabled']:
listener = (self.config['datagram']['host'],
self.config['datagram']['port'] +
self.config['server_number'])
self.logger.info(
"Turning on UDP control server on {}".format(listener))
DatagramServer.__init__(self, listener, spawn=None)
def __init__(self, *args, **kwargs): DatagramServer.__init__(self, *args, **kwargs) self.clients = []
def __init__(self, address, nases={}, dict=None):
DatagramServer.__init__(self, address)
self.address = address
self.dict = dict
self.start()
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 3000000)
def __init__(self, listener, spawn='default'):
DatagramServer.__init__(self, listener, self.handle, spawn)
self._sinks = []
self._session = get_config().collector.session
def __init__(self, *args, **kwargs):
self._seq = 0
self._payload = 'x' * 1024 # default MTU ~ 1400
DatagramServer.__init__(self, *args, **kwargs)
def __init__(self, *args, **kwargs):
DBG("NetoolDatagramServer __init__")
DatagramServer.__init__(self, *args, **kwargs)
def registerTransport(self, tDomain, transport):
DatagramServer.__init__(self, transport, self.handle)
self.transportDomain = tDomain
def __init__(self, config):
self._configure(config)
self._log_handlers = []
# Parse command line args
self.config['server_number'] += self.config['args']['server_number']
self.config['procname'] += "_{}".format(self.config['server_number'])
# setup all our log handlers
for log_cfg in self.config['loggers']:
if log_cfg['type'] == "StreamHandler":
kwargs = dict(stream=sys.stdout)
else:
kwargs = dict()
handler = getattr(logging, log_cfg['type'])(**kwargs)
log_level = getattr(logging, log_cfg['level'].upper())
handler.setLevel(log_level)
fmt = log_cfg.get('format', '%(asctime)s [%(name)s] [%(levelname)s] %(message)s')
formatter = logging.Formatter(fmt)
handler.setFormatter(formatter)
self._log_handlers.append((log_cfg.get('listen'), handler))
self.logger = self.register_logger(self.__class__.__name__)
setproctitle.setproctitle(self.config['procname'])
self.version = powerpool.__version__
self.version_info = powerpool.__version_info__
self.sha = getattr(powerpool, '__sha__', "unknown")
self.rev_date = getattr(powerpool, '__rev_date__', "unknown")
if self.sha == "unknown":
# try and fetch the git version information
try:
output = subprocess.check_output("git show -s --format='%ci %h'",
shell=True).strip().rsplit(" ", 1)
self.sha = output[1]
self.rev_date = output[0]
# celery won't work with this, so set some default
except Exception as e:
self.logger.info("Unable to fetch git hash info: {}".format(e))
self.algos = {}
self.server_start = datetime.datetime.utcnow()
self.logger.info("=" * 80)
self.logger.info("PowerPool stratum server ({}) starting up..."
.format(self.config['procname']))
if __debug__:
self.logger.info("Python not running in optimized mode. For best "
"performance set enviroment variable PYTHONOPTIMIZE=2")
gevent.spawn(BlockingDetector(raise_exc=False))
# Detect and load all the hash functions we can find
for name, algo_data in self.config['algorithms'].iteritems():
self.algos[name] = algo_data.copy()
self.algos[name]['name'] = name
mod = algo_data['module']
try:
self.algos[name]['module'] = import_helper(mod)
except ImportError:
self.algos[name]['module'] = None
else:
self.logger.info("Enabling {} hashing algorithm from module {}"
.format(name, mod))
self.event_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.events_enabled = self.config['events']['enabled']
if self.events_enabled:
self.logger.info("Transmitting statsd formatted stats to {}:{}".format(
self.config['events']['host'], self.config['events']['port']))
self.events_address = (self.config['events']['host'].encode('utf8'),
self.config['events']['port'])
# Setup all our stat managers
self._min_stat_counters = []
self._sec_stat_counters = []
if self.config['datagram']['enabled']:
listener = (self.config['datagram']['host'],
self.config['datagram']['port'] +
self.config['server_number'])
self.logger.info("Turning on UDP control server on {}"
.format(listener))
DatagramServer.__init__(self, listener, spawn=None)
def __init__(self, addr, handlecls):
DatagramServer.__init__(self, addr)
self._handlecls = handlecls
def __init__(self, listen, store, *args, **kwargs):
self.store = store
DatagramServer.__init__(self, listen, *args, **kwargs)
def __init__(self, name, handler, **kwargs):
listener = kwargs.pop("url")
if isinstance(listener, list):
listener = tuple(listener)
DatagramServer.__init__(self, listener)
SimulatorServerMixin.__init__(self, name, handler, **kwargs)
def __init__(self, *args, **kwargs):
self._seq = 0
self._payload = 'x' * 1024 # default MTU ~ 1400
DatagramServer.__init__(self, *args, **kwargs)
