def __init__(self, host="", port=COBRA_PORT, sslcrt=None, sslkey=None, sslca=None, msgpack=False, json=False):
'''
Construct a cobra daemon object.
Parameters:
host - Optional hostname/ip to bind the service to (default: inaddr_any)
port - The port to bind (Default: COBRA_PORT)
msgpack - Use msgpack serialization
# SSL Options
sslcrt / sslkey - Specify sslcrt and sslkey to enable SSL server side
sslca - Specify an SSL CA key to use validating client certs
'''
self.thr = None
self.run = True
self.shared = {}
self.dowith = {}
self.host = host
self.port = port
self.reflock = RLock()
self.refcnts = {}
self.authmod = None
self.sflags = 0
if msgpack and json:
raise Exception('CobraDaemon can not use both msgpack *and* json!')
if msgpack:
requireMsgpack()
self.sflags |= SFLAG_MSGPACK
if json:
self.sflags |= SFLAG_JSON
# SSL Options
self.sslca = sslca
self.sslcrt = sslcrt
self.sslkey = sslkey
self.cansetattr = True
self.cangetattr = True
if sslcrt and not os.path.isfile(sslcrt):
raise Exception('CobraDaemon: sslcrt param must be a file!')
if sslkey and not os.path.isfile(sslkey):
raise Exception('CobraDaemon: sslkey param must be a file!')
if sslca and not os.path.isfile(sslca):
raise Exception('CobraDaemon: sslca param must be a file!')
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, (host, port), CobraRequestHandler)
if port == 0:
self.port = self.socket.getsockname()[1]
self.daemon_threads = True
self.recvtimeout = None
def __init__(self, host='localhost', port=DEFAULT_LOGGING_CONFIG_PORT,
handler=None):
ThreadingTCPServer.__init__(self, (host, port), handler)
logging._acquireLock()
self.abort = 0
logging._releaseLock()
self.timeout = 1
def __init__(self, host='localhost',
port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
handler=LogRecordStreamHandler):
ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = False
self.timeout = 0.1
self.finished = threading.Event()
def __init__(self, host="", port=COBRA_PORT, sslcrt=None, sslkey=None, sslca=None, sess_timeout=24, attr=True):
'''
Construct a cobra daemon object.
Parameters:
host - Optional hostname/ip to bind the service to (default: inaddr_any)
port - The port to bind (Default: COBRA_PORT)
timeout - The length any session can last, before forcing reconnect
attr - Toggle to turn off the ability to set or get attributes
# SSL Options
sslcrt / sslkey - Specify sslcrt and sslkey to enable SSL server side
sslca - Specify an SSL CA key to use validating client certs
'''
self.shared = {}
self.host = host
self.port = port
self.reflock = RLock()
self.refcnts = {}
self.authmod = None
self.attr = attr
self.sessions = {} # authenticated sessions
self.sess_timeout=sess_timeout*60
# SSL Options
self.sslca = sslca
self.sslcrt = sslcrt
self.sslkey = sslkey
if sslcrt and not os.path.isfile(sslcrt):
raise Exception('CobraDaemon: sslcrt param must be a file!')
if sslkey and not os.path.isfile(sslkey):
raise Exception('CobraDaemon: sslkey param must be a file!')
if sslca and not os.path.isfile(sslca):
raise Exception('CobraDaemon: sslca param must be a file!')
#ThreadingTCPServer.__init__(self, (host, port), CobraHttpConnectionHandler)
ThreadingTCPServer.__init__(self, (host, port), CobraHttpRequestHandler)
t = Thread(target=self._timeoutSessions)
t.setDaemon(1)
t.start()
if port == 0:
self.port = self.socket.getsockname()[1]
self.daemon_threads = True
self.recvtimeout = None
def __init__(self, host, port, traceback_frames, ignore_selects,
ignored_sources, ignored_request_paths):
ThreadingTCPServer.__init__(self, (host, port), LogRecordStreamHandler)
self.timeout = 1
self.traceback_frames = traceback_frames
self.ignore_selects = ignore_selects
self.ignored_sources = [
ignored_line_re.match(s).groupdict() for s in ignored_sources
]
self.ignored_request_paths = {
self._process_path(x)
for x in ignored_request_paths
}
def __init__(self,
host='localhost',
port=DEFAULT_LOGGING_CONFIG_PORT,
handler=None,
ready=None,
verify=None):
ThreadingTCPServer.__init__(self, (host, port), handler)
logging._acquireLock()
self.abort = 0
logging._releaseLock()
self.timeout = 1
self.ready = ready
self.verify = verify
def __init__(self,
port,
auth=False,
user_manager=UserManager(),
allowed=None):
ThreadingTCPServer.__init__(self, ('', port), Socks5RequestHandler)
self.__port = port
self.__users = {}
self.__auth = auth
self.__user_manager = user_manager
self.__sessions = {}
self.allowed = allowed
self.th = threading.Thread(target=self.serve_forever)
def __init__(self, config, handler_class):
server_address = (config['server']['ip'], config['server']['port'],)
# Bind and activate server in I{activate} method
ThreadingTCPServer.__init__(self, server_address, handler_class, 0)
Daemon.__init__(self, config['server']['pid'])
# Signals not catched in serve_forever, we need to execute serve_forever
# again because signals are raised exception in I{main} method
self.__by_signal_do = 0
self.__local_sock = None
self.allow_reuse_address = 1
self._config = config.copy()
self._aliases = {}
self.timeout = config['server']['timeout']
def run(self):
ThreadingTCPServer.__init__(self, (self.host, self.port), self.handler)
self.abort = 0
self.timeout = 1
self.logname = None
import select
abort = 0
while not abort:
rd, wr, ex = select.select([self.socket.fileno()], [], [],
self.timeout)
if rd:
self.handle_request()
abort = self.abort
def __init__(
self,
host,
port,
handler=_Handler,
bind_and_activate=True,
abort=0,
timeout=1,
logname=None,
):
ThreadingTCPServer.__init__(self, (host, port),
handler,
bind_and_activate=bind_and_activate)
self.abort = abort
self.timeout = timeout
self.logname = logname
def run(self):
ThreadingTCPServer.__init__(self, (self.host, self.port), self.handler)
self.abort = 0
self.timeout = 1
self.logname = None
import select
abort = 0
while not abort:
rd, wr, ex = select.select([self.socket.fileno()],
[], [],
self.timeout)
if rd:
self.handle_request()
abort = self.abort
def __init__(self):
""" Initialisation of the Proxy TCP server """
from socket import socket, AF_INET, SOCK_STREAM
sock = socket(AF_INET, SOCK_STREAM)
while True:
try:
sock.bind(('127.0.0.1', 0))
_, port = sock.getsockname()
sock.close()
ThreadingTCPServer.__init__(self, ('127.0.0.1', port),
ProxyHTTPD)
self.port = port # Save the current binded port
break
except:
pass
def __init__(
self,
server_address: Tuple[str, int],
accounts: Dict[str, SIAAccount],
func: Callable[[SIAEvent], None],
counts: Counter,
):
"""Create a SIA TCP Server.
Arguments:
server_address Tuple[string, int] -- the address the server should listen on.
accounts Dict[str, SIAAccount] -- accounts as dict with account_id as key, SIAAccount object as value.
func Callable[[SIAEvent], None] -- Function called for each valid SIA event, that can be matched to a account.
counts Counter -- counter kept by client to give insights in how many errorous events were discarded of each type.
"""
ThreadingTCPServer.__init__(self, server_address, SIATCPHandler)
BaseSIAServer.__init__(self, accounts, func, counts)
def __init__(self,listen,prefix): self.allow_reuse_address=True ThreadingTCPServer.__init__(self,listen, TCPCauldronRequestHandler) CauldronServer.__init__(self, prefix)
def __init__(self,http_address,binding): self.http_address = http_address ThreadingTCPServer.__init__(self,binding,SocksHandler)
def __init__(self, *args, nlvl):
ThreadingTCPServer.__init__(self, *args)
TWEngine.__init__(self, nlvl=nlvl)
Thread(target=self.__temp_spawner).start() # тестовый спавнер (зачем)
def __init__(self, addr, handler, timeout=1):
ThreadingTCPServer.__init__(self, addr, LogRecordStreamHandler)
BaseServer.__init__(self, handler, timeout)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
def __init__(self, host, port, handler=RecordStreamHandler):
ThreadingTCPServer.__init__(self, (host, port), handler)
self.stop = 0
self.timeout = 3
def __init__(self,
host="",
port=COBRA_PORT,
sslcrt=None,
sslkey=None,
sslca=None,
msgpack=False,
json=False):
'''
Construct a cobra daemon object.
Parameters:
host - Optional hostname/ip to bind the service to (default: inaddr_any)
port - The port to bind (Default: COBRA_PORT)
msgpack - Use msgpack serialization
# SSL Options
sslcrt / sslkey - Specify sslcrt and sslkey to enable SSL server side
sslca - Specify an SSL CA key to use validating client certs
'''
self.thr = None
self.run = True
self.shared = {}
self.dowith = {}
self.host = host
self.port = port
self.reflock = RLock()
self.refcnts = {}
self.authmod = None
self.sflags = 0
if msgpack and json:
raise Exception('CobraDaemon can not use both msgpack *and* json!')
if msgpack:
requireMsgpack()
self.sflags |= SFLAG_MSGPACK
if json:
self.sflags |= SFLAG_JSON
# SSL Options
self.sslca = sslca
self.sslcrt = sslcrt
self.sslkey = sslkey
self.cansetattr = True
self.cangetattr = True
if sslcrt and not os.path.isfile(sslcrt):
raise Exception('CobraDaemon: sslcrt param must be a file!')
if sslkey and not os.path.isfile(sslkey):
raise Exception('CobraDaemon: sslkey param must be a file!')
if sslca and not os.path.isfile(sslca):
raise Exception('CobraDaemon: sslca param must be a file!')
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, (host, port), CobraRequestHandler)
if port == 0:
self.port = self.socket.getsockname()[1]
self.daemon_threads = True
self.recvtimeout = None
def __init__(self, proxy, target, server_address):
self.proxy = ParentProxy('', proxy)
self.target = target
self.addr = server_address
logger.info('starting tcp forward from %s(local) to %s(remote) via %s' % (server_address, target, self.proxy))
ThreadingTCPServer.__init__(self, server_address, tcp_tunnel_handler)
def __init__(self, addr, handler, timeout=1):
ThreadingTCPServer.__init__(self, addr, LogRecordStreamHandler)
BaseServer.__init__(self, handler, timeout)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
def __init__(self):
self.load_config()
ThreadingTCPServer.__init__(self, ('0.0.0.0', self.PORT), TCP_handler)
def __init__(self, http_address, binding):
self.http_address = http_address
ThreadingTCPServer.__init__(self, binding, SocksHandler)
def __init__(self, addr):
host, port = addr.split(':')
self.addr = (host, int(port))
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, self.addr, MixedSocketHandler)
self.port = self.socket.getsockname()[1]
def __init__(self, addr, handler, timeout=1):
ThreadingTCPServer.__init__(self, addr, LogRecordStreamHandler)
BaseServer.__init__(self, handler, timeout)
def __init__(self,listen,prefix): self.allow_reuse_address=True ThreadingTCPServer.__init__(self,listen, TCPChaliceRequestHandler) ChaliceServer.__init__(self, prefix)
def __init__(self, server_address, instance=None):
ThreadingTCPServer.__init__(self, server_address,
StreamRPCRequestHandler)
RPCDispatcher.__init__(self, instance)
def __init__(
self, host=LOG_SERVER_HOST, port=LOG_SERVER_PORT,
handler=LogRecordStreamHandler):
ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
