def __init__(self, addr):
self.allow_reuse_address = 1
self.hostname, self.port = addr
TCPServer.__init__(self, addr, ServerRequestHandler)
# shared state
self.data = dict()
# set server defaults
self.data = {
u'started_at' : datetime.now(),
u'port' : self.port,
u'hostname' : Config.hostname,
u'running' : True
}
# create a shared Data object
self.manager = DataManager(address=('', self.port + 1),
authkey=Config.authkey)
# "Private" methods ('__'-prefixed) are *not* exported out of
# the manager by default. This includes stuff to make dict work
# minimally. See
# http://docs.python.org/library/multiprocessing.html
#
# Upshot is we need to explicitly name the exposed functions:
DataManager.register('get_data', callable=lambda: self.data,
exposed=('__str__', '__delitem__', '__getitem__',
'__setitem__'))
self.manager.start()
self.manager.connect()
self.data = self.manager.get_data()
def __init__(self, address, handler, max_proc = 4, bitstream_directory="/boffiles/", offline = False):
"""
@max_proc (DON'T CHANGE): number of fpgas, or maximum number of bitstreams that can be run simultaneously on the machine
@bitstream_directory : directory containing bitstreams(.bof files) that should be run on the machine
"""
self._logger = logging.getLogger('BORPHControl')
if not offline:
TCPServer.__init__(self, address, handler)
self._logger.debug('__init__')
self._command_set = { 8 : self.get_resource,
9 : self.set_resource,
10 : self.kill_resource,
32 : self.get_values,
33 : self.set_values,
34 : self.get_values_binary,
35 : self.set_values_binary,
}
else:
self._logger.info('BORPHControl was initialized in offline mode!!!!')
self.max_proc = max_proc ##Maximum number of bitstreams that can be run simultaneously.
self.processes = {} # a dictionary mapping bitstreams to PIDs
## self.proc_dir = "/proc/"
## self.registers_subfolder = "/hw/ioreg/"
self.bitstream_directory = bitstream_directory
def __init__(self, code):
self.allow_reuse_address = True
TCPServer.__init__(self, ('localhost', 0), _RequestHandler)
self.log = io.StringIO()
self.requests = []
self.main_thread = None
self.code = code
def __init__(self, server_address, RequestHandlerClass, container,
thread_class = Thread):
self.allow_reuse_address = True
TCPServer.__init__(self, server_address, RequestHandlerClass)
CustomThreadingMixIn.__init__(self, thread_class)
self.container = container
self.daemon_threads = True
def __init__(
self,
server_address,
q_recv,
q_send,
client_poll=0.001
):
# thread super
Thread.__init__(self, name='SimIOServer')
self.daemon = True
# members
self.q_recv = q_recv # singleton receive queue
self.q_send = q_send # incomming send queue
self.send_queues = {}
self.send_queues_lock = Lock()
self.client_poll = client_poll
self._status = None
self._serving = False
self._is_shutdown = Event()
self._is_shutdown.set()
# TCPerver super
TCPServer.__init__(self, server_address, SimIOProtocol, False)
def __init__(self, server_address, RequestHandlerClass,
secret, dirname):
TCPServer.__init__(self, server_address, RequestHandlerClass)
self.secret = secret
self.dirname = dirname
self.block_size = int(config().get('global',
'block_size'))
def __init__(self, server_address, client):
self._client = client
if 1:
address6 = server_address[0].split("|")[1]
server_address6= (address6,server_address[1] )
TCPServer.__init__(self, ("",server_address6[1]), Uploader)
def __init__(self, addr, request_handler):
# hmm, TCPServer is not sub-classed from object!
if issubclass(TCPServer, object):
super(TCPServerWrapper, self).__init__(addr, request_handler)
else:
TCPServer.__init__(self, addr, request_handler)
self.running = False
def __init__(self, server_address, RequestHandlerClass, controller):
"""Constructor. May be extended, do not override."""
TCPServer.__init__(self, server_address, RequestHandlerClass)
# XXX - controller = MudMaster?
self.controller = controller
self.active = True
self.souls = []
self.greeting_msg = GREETING
def __init__(self, west):
self.west = west
self.jc_mine = west.jc['wsts']
TCPServer.__init__(self, (self.jc_mine['addr'], self.jc_mine['port']),
ExtendedWebSocketHandler)
self.set_fn_new_client(self.new_client)
self.set_fn_client_left(self.client_left)
self.set_fn_message_received(self.message_received)
def __init__(self, server_address=('', 8080)):
TCPServer.__init__(self,
server_address,
RequestHandler
)
self.sinks = [ ]
self.is_playing = False
self.lock = threading.Lock()
def __init__(self, server_address, RequestHandlerClass):
TCPServer.__init__(self, server_address, RequestHandlerClass)
self._shutdown_request = False
# watchdog guards against the failure mode when the remote target fails
# to send any packets. If the watchdog reaches the high water mark, the
# server is terminated so as not to leave the server thread unterminated
self.watchdog = 0.0
def start(self, resource_root="../../src/test/resources"):
TCPServer.__init__(self, ('localhost', int(HTTP_PORT)), CustomHandler)
self.RESOURCE_LOCATION = path.abspath(resource_root)
print "Server serving from DocumentRoot:" + self.RESOURCE_LOCATION
chdir(self.RESOURCE_LOCATION)
server_thread = threading.Thread(target=self.serve_forever)
server_thread.daemon = True
server_thread.start()
def start(self):
TCPServer.__init__(self, ('localhost', int(HTTP_PORT)), CustomHandler)
self.RESOURCE_LOCATION = path.abspath(path.dirname(__file__))
print "Server serving from DocumentRoot:" + self.RESOURCE_LOCATION
chdir(self.RESOURCE_LOCATION)
server_thread = threading.Thread(target=self.serve_forever)
server_thread.daemon = True
server_thread.start()
def __init__(self, data_port, start_event, stop_event, disconnect_event, *args, **kwargs):
self.data_port = data_port
self.start_event = start_event
self.stop_event = stop_event
self.disconnect_event = disconnect_event
# self.clients = []
# self.clients_lock = threading.Lock()
# return super(ControlServer, self).__init__(*args, **kwargs)
TCPServer.__init__(self, *args, **kwargs)
def __init__(self, config, params=None):
SpeedChecker.__init__(self)
Receiver.__init__(self, config, params)
TCPServer.__init__(self, (config.config('ip'), int(config.config('port'))), self.handle, bind_and_activate=False)
self.request_queue_size =int(config.config('threads'))
self.server_bind()
self.server_activate()
self.start()
def __init__(self, address, heartbeat_interval = 10000, family = socket.AF_INET):
self.address_family = family
TCPServer.__init__(self, address, BaseRequestHandler, False)
self._clients = dict()
self._lock = threading.RLock()
self._data_items = []
self._running = False
self._heartbeat_interval = heartbeat_interval
self._ping_pat = re.compile('\\* PING')
def __init__(self, *args, **kwargs):
TCPServer.__init__(self, *args, **kwargs)
if isfile(STORE):
print 'Found previous run on disk. Loading + Restoring...'
with open(STORE, 'r') as data:
memories = json.load(data)
for key, value in memories.iteritems():
memories[key] = Memory(**value)
self.data = memories
def __init__(self, server_address, RequestHandlerClass,
bind_and_activate=True, socket_cls=None, keep_alive=True,
base_cls=None):
""" """
self.socket_cls = socket_cls or SAPNIStreamSocket
self.keep_alive = keep_alive
self.base_cls = base_cls
self.clients = {}
TCPServer.__init__(self, server_address, RequestHandlerClass,
bind_and_activate=bind_and_activate)
def __init__( self, address, RequestHandlerClass ): TCPServer.__init__( self, address, RequestHandlerClass ) # SETTING UP CONFIG VALUES config = ConfigParser.RawConfigParser() config.read( self.CONFIG_FILE ) # Parsing SSL section try: # GET SSL try: self.SSL = config.getboolean( "ssl", "ssl" ) except ConfigParser.NoOptionError: self.logger.log_error( "WARNING ssl not found in main.conf. Using default ssl True." ) except ValueError: self.logger.log_error( "WARNING Not valid value %s for ssl. Using default.", config.get( "ssl", "ssl" ) ) try: key_file = config.get( "ssl", "key_file" ) if not os.path.isfile( key_file ): self.logger.log_error( "WARNING key_file %s does not exist. Using default %s.", key_file, self.KEY_FILE ) else: self.KEY_FILE = key_file except ConfigParser.NoOptionError: self.logger.log_error( "WARNING key_file missing in main.conf. Using default %s.", self.KEY_FILE ) try: cert_file = config.get( "ssl", "cert_file" ) if not os.path.isfile( cert_file ): self.logger.log_error( "WARNING cert_file %s does not exist. Using default %s.", cert_file, self.CERT_FILE ) else: self.CERT_FILE = cert_file except ConfigParser.NoOptionError: self.logger.log_error( "WARNING cert_file missing in main.conf. Using default %s.", self.CERT_FILE ) except ConfigParser.NoSectionError: self.logger.log_error( "ERROR No section [ssl] in main.conf." ) try: address_filter = config.get( "server", "address_filter" ) addresses = address_filter.split( ',' ) flag = True for address in addresses: address = address.strip() try: socket.inet_aton( address ) except socket.error: self.logger.log_error( "WARNING Bad address %s in address_filter missing in main.conf. Using default %s.", address, self.ADDRESS_FILTER ) flag = False break if flag: self.ADDRESS_FILTER = addresses except ConfigParser.NoSectionError: self.logger.log_error( "ERROR No section [server] in main.conf." ) except ConfigParser.NoOptionError: self.logger.log_error( "WARNING address_filter missing in main.conf. Using default %s.", self.ADDRESS_FILTER )
def __init__(self,
server_address,
RequestHandlerClass,
certfile,
keyfile,
ssl_version=ssl.PROTOCOL_TLSv1,
bind_and_activate=True):
TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate)
self.certfile = certfile
self.keyfile = keyfile
self.ssl_version = ssl_version
def __init__(self, listen_on):
TCPServer.__init__(self, listen_on, None, bind_and_activate=False)
self.daemon_threads = True
self.allow_reuse_address = True
try:
self.server_bind()
except Exception as ex:
raise Exception('Caught exception while binding to %s: %s' % (listen_on, ex))
self.server_activate()
def __init__(self, server_address, RequestHandlerClass, use_ssl=True, certfile=None, keyfile=None,
ssl_version=ssl.PROTOCOL_TLSv1, cipherlist=None):
bind_and_activate = True
TCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate)
self.certfile = certfile
self.keyfile = keyfile
if certfile is None or keyfile is None:
self.certfile, self.keyfile = generate_ephemeral_certificate()
self.ssl_version = ssl_version
self.cipherlist = cipherlist
self.use_ssl = use_ssl
def __init__(self,
server_address,
request_handler_class,
certfile,
keyfile,
ssl_version=ssl.PROTOCOL_TLSv1,
bind_and_activate=True):
# Inicializamos la clase padre
TCPServer.__init__(self, server_address, request_handler_class, bind_and_activate)
self.certfile = certfile
self.keyfile = keyfile
self.ssl_version = ssl_version
def __init__(
self,
address,
requestHandler=SimpleJSONRPCRequestHandler,
logRequests=True,
encoding=None,
bind_and_activate=True,
address_family=socket.AF_INET,
):
self.logRequests = logRequests
SimpleJSONRPCDispatcher.__init__(self, encoding)
TCPServer.__init__(self, address, requestHandler, bind_and_activate)
def __init__(self, listen_on):
TCPServer.__init__(self, listen_on, None, bind_and_activate=False)
self.daemon_threads = True
# make sure SO_REUSE_ADDR socket option is set
self.allow_reuse_address = True
try:
self.server_bind()
except socket.error as ex:
raise RuntimeError('failed to bind to %s, exception: %s' % (listen_on, ex))
self.server_activate()
def __init__(self, connection_handler, addr):
"""
Arguments:
addr -- (host, port)
connection_handler -- méthode appellée lorsqu'une connexion est
établie, avec comme paramètres le socket et l'adresse du
client.
"""
TCPServer.__init__(self, addr, None)
self.request_queue_size = 1 # max 1 client per session
self.connection_handler = connection_handler
self.running = False
self.threads = []
def __init__(self, inet, request_handler): TCPServer.__init__(self, inet, request_handler) self.clients = [] self.t1 = threading.Thread(target=self.broadcast_message, args=()) self.t1.daemon = True self.t1.start() self.t2 = threading.Thread(target=self.process_usernames, args=()) self.t2.daemon = True self.t2.start() self.t3 = threading.Thread(target=self.broadcast_usernames, args=()) self.t3.daemon = True self.t3.start() self.lock = threading.Lock()
def __init__(self, port=8888, host=socket.gethostbyname(socket.gethostname()), secret_key="12345", default_privacy="private"): print "Initializing..." self.port = port self.host = host self.secret_key = secret_key if default_privacy in ["public", "private"]: self.default_privacy = default_privacy else: self.default_privacy = "private" TCPServer.__init__(self, (host, port), WebSocketHandler) self.ip = self.server_address[0] threading.Timer(60, self.remove_expired_clients) print "Server initialized at "+str(self.ip)+":"+str(self.port) self.serve_forever()
def __init__(self,
ae,
address,
ae_title,
contexts,
ssl_context=None,
evt_handlers=None):
"""Create a new :class:`AssociationServer`, bind a socket and start
listening.
Parameters
----------
ae : ae.ApplicationEntity
The parent AE that's running the server.
address : 2-tuple
The ``(host, port)`` that the server should run on.
ae_title : bytes
The AE title of the SCP.
contexts : list of presentation.PresentationContext
The SCPs supported presentation contexts.
ssl_context : ssl.SSLContext, optional
If TLS is to be used then this should be the
:class:`ssl.SSLContext` used to wrap the client sockets, otherwise
if ``None`` then no TLS will be used (default).
evt_handlers : list of 2-tuple, optional
A list of ``(event, callable)``, the *callable* function to run
when *event* occurs.
"""
self.ae = ae
self.ae_title = ae_title
self.contexts = contexts
self.ssl_context = ssl_context
self.allow_reuse_address = True
TCPServer.__init__(self,
address,
RequestHandler,
bind_and_activate=True)
self.timeout = 60
# Stores all currently bound event handlers so future
# Associations can be bound
self._handlers = {}
self._bind_defaults()
# Bind the functions to their events
for (event, handler) in (evt_handlers or {}):
self.bind(event, handler)
def __init__(self, server_address, RequestHandlerClass=None, authenticator=None, queue_manager=None, topic_manager=None):
"""
Extension to C{TCPServer} constructor to provide mechanism for providing implementation classes.
@keyword authenticator: The configure L{coilmq.auth.Authenticator} object to use.
@keyword queue_manager: The configured L{coilmq.queue.QueueManager} object to use.
@keyword topic_manager: The configured L{coilmq.topic.TopicManager} object to use.
"""
self.log = logging.getLogger('%s.%s' % (self.__module__, self.__class__.__name__))
if not RequestHandlerClass:
RequestHandlerClass = StompRequestHandler
TCPServer.__init__(self, server_address, RequestHandlerClass)
self.authenticator = authenticator
self.queue_manager = queue_manager
self.topic_manager = topic_manager
def __init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=True,
socket_cls=None,
keep_alive=True,
base_cls=None):
""" """
self.socket_cls = socket_cls or SAPNIStreamSocket
self.keep_alive = keep_alive
self.base_cls = base_cls
self.clients = {}
TCPServer.__init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=bind_and_activate)
def __init__(self, port, host, loglevel=logging.INFO):
logger.setLevel(loglevel)
self.port = port
TCPServer.__init__(self, (host, port), WebSocketHandler)
# load app
self.apps = []
self.workpath = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'Apps')
Reflect.setworkpath(self.workpath)
for filename in os.listdir(self.workpath):
codepath = os.path.join(self.workpath, filename)
if os.path.isfile(codepath):
self.apps.append(
App(appid=len(self.apps),
appname=filename,
codepath=codepath))
def __init__(self, addr, level, num_rthreads, dispatch_handlers,
startup_functions):
# inherit TCPServer to init SocketServer-based critical variable
# binding dispatch_handlers, startup functions from parameter
# create threads record and request pool(queue).
listening_addr = ('', addr[1])
TCPServer.__init__(self, addr, RequestDispatchHandler)
self.level = level
self.addr = addr
self.num_rthreads = num_rthreads # How many threads who handle the requests
self.dispatch_handlers = dispatch_handlers # a dictionary with { 'Message Name': Binding Function, ... }
self.startup_functions = startup_functions # a list with { Binding Function, ... }
self.pm_relation = PM_Entry().setAll(level=level, addr=addr)
self.threads = list() # record the threads we use
self.requests = Queue(
self.num_rthreads) # init the requests pool as queue type
def __init__(self,
svr_addr,
svr_port,
event_global,
request_handler=ThreadedTCPRequestHandler,
bind_and_active=True):
threading.Thread.__init__(self)
TCPServer.__init__(self, (svr_addr, svr_port), request_handler,
bind_and_active)
self._worker_cache = {}
self._event_queue = event_global
self._worker_arb = PriorityQueue()
self._server_cert = os.path.join(os.path.dirname(__file__), os.pardir,
'SSLCerts', 'server.crt')
self._server_key = os.path.join(os.path.dirname(__file__), os.pardir,
'SSLCerts', 'server.key')
self._ca_certs = os.path.join(os.path.dirname(__file__), os.pardir,
'SSLCerts', 'ca.crt')
self._condition = threading.Condition(threading.RLock())
def __init__(self, server_address, q_recv, q_send, client_poll=0.001):
# thread super
Thread.__init__(self, name='SimIOServer')
self.daemon = True
# members
self.q_recv = q_recv # singleton receive queue
self.q_send = q_send # incomming send queue
self.send_queues = {}
self.send_queues_lock = Lock()
self.client_poll = client_poll
self._status = None
self._serving = False
self._is_shutdown = Event()
self._is_shutdown.set()
# TCPerver super
TCPServer.__init__(self, server_address, SimIOProtocol, False)
def __init__(self, server_address, RequestHandlerClass=None, timeout=3.0, authenticator=None, queue_manager=None, topic_manager=None):
"""
Extension to C{TCPServer} constructor to provide mechanism for providing implementation classes.
@param server_address: The (address,port) C{tuple}
@param RequestHandlerClass: The class to use for handling requests.
@param timeout: The timeout for the underlying socket.
@keyword authenticator: The configure L{coilmq.auth.Authenticator} object to use.
@keyword queue_manager: The configured L{coilmq.queue.QueueManager} object to use.
@keyword topic_manager: The configured L{coilmq.topic.TopicManager} object to use.
"""
self.log = logging.getLogger('%s.%s' % (self.__module__, self.__class__.__name__))
if not RequestHandlerClass:
RequestHandlerClass = StompRequestHandler
self.timeout = timeout
self.authenticator = authenticator
self.queue_manager = queue_manager
self.topic_manager = topic_manager
self._serving_event = threading.Event()
self._shutdown_request_event = threading.Event()
TCPServer.__init__(self, server_address, RequestHandlerClass)
def __init__(self, port, mailboxes, **opts):
"""Create a new server instance.
port -- TCP port to listen on.
mailboxes -- MailboxFile objects to serve.
debug -- enable debugging output?
allow_delete -- simulate deletion at exit?
allow_apop -- allow APOP authentication?
"""
self._debug = opts.get('debug', False)
self._host = 'localhost'
self._port = port
self._boxes = list(mailboxes)
self._dels = set()
self._users = dict(opts.get('users', ()))
self._apopc = None
self.allow_delete = opts.get('allow_delete', False)
self.allow_apop = opts.get('allow_apop', False)
TCPServer.__init__(self, (self._host, port), POP3Handler)
def __init__(self,
server_address,
RequestHandlerClass=None,
authenticator=None,
queue_manager=None,
topic_manager=None):
"""
Extension to C{TCPServer} constructor to provide mechanism for providing implementation classes.
@keyword authenticator: The configure L{coilmq.auth.Authenticator} object to use.
@keyword queue_manager: The configured L{coilmq.queue.QueueManager} object to use.
@keyword topic_manager: The configured L{coilmq.topic.TopicManager} object to use.
"""
self.log = logging.getLogger(
'%s.%s' % (self.__module__, self.__class__.__name__))
if not RequestHandlerClass:
RequestHandlerClass = StompRequestHandler
TCPServer.__init__(self, server_address, RequestHandlerClass)
self.authenticator = authenticator
self.queue_manager = queue_manager
self.topic_manager = topic_manager
def __init__(self,
server_address,
keyfile,
certfile,
ssl_version=ssl.PROTOCOL_TLSv1,
requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True,
allow_none=False,
encoding=None,
bind_and_activate=True):
self.logRequests = logRequests
self.keyfile = keyfile
self.certfile = certfile
self.ssl_version = ssl_version
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
TCPServer.__init__(self, server_address, requestHandler,
bind_and_activate)
if fcntl is not None and hasattr(fcntl, 'FD_CLOEXEC'):
flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD)
flags |= fcntl.FD_CLOEXEC
fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def __init__(self, address, commands, handler=SteppingParrotRequest):
"""Create a new AssociationServer, bind a socket and start listening.
Parameters
----------
ae : ae.ApplicationEntity
The parent AE that's running the server.
address : 2-tuple
The (host, port) that the server should run on.
ssl_context : ssl.SSLContext, optional
If TLS is to be used then this should be the ssl.SSLContext used
to wrap the client sockets, otherwise if None then no TLS will be
used (default).
"""
self.commands = commands
self.event = threading.Event()
self.event.set()
self.ssl_context = None
self.allow_reuse_address = True
TCPServer.__init__(self, address, handler, bind_and_activate=True)
self.timeout = 60
self.handlers = []
def __init__(self, server_address, nx_common):
"""Initialization of MSLTCPServer"""
nx_common.log(msg='Constructing MSLTCPServer')
self.nx_common = nx_common
self.msl_handler = MSL(nx_common)
TCPServer.__init__(self, server_address, MSLHttpRequestHandler)
def __init__(self, server_address=None,
requestHandlerClass=TelnetRequestHandler):
if not server_address:
server_address = ('', 23)
TCPServer.__init__(self, server_address, requestHandlerClass)
def __init__(self, port, host='127.0.0.1'):
self.port = port
TCPServer.__init__(self, (host, port), WebSocketHandler)
def __init__(self, port=PORT):
TCPServer.__init__(self, ('localhost', int(port )), SimpleHTTPRequestHandler)
class AgamimServer(ForkingMixIn, TCPServer):
def __init__(self, (host, port), request_handler):
self.allow_reuse_address = True
TCPServer.__init__(self, (host, port), request_handler)
def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING, key=None, cert=None):
logger.setLevel(loglevel)
TCPServer.__init__(self, (host, port), WebSocketHandler)
self.port = self.socket.getsockname()[1]
self.key=key
self.cert=cert
def __init__(self, server_address, handler_cls):
# Invoke base but omit bind/listen steps (performed by systemd activation!)
TCPServer.__init__(self, server_address, handler_cls, bind_and_activate=False)
# Override socket
self.socket = socket.fromfd(self.SYSTEMD_FIRST_SOCKET_FD, self.address_family, self.socket_type)
def __init__(self, port, RequestHandlerClass):
self.port = port
TCPServer.__init__(self, ('', port), RequestHandlerClass)
self.inbox = {}
self.outbox = {}
def __init__(self, host, port, handlers, timeout=10):
self.host = host
self.port = port
self.handlers = handlers
self.timeout = timeout
TCPServer.__init__(self, (host, port), _MLLPRequestHandler)
def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING):
logger.setLevel(loglevel)
self.port = port
TCPServer.__init__(self, (host, port), WebSocketHandler)
def __init__(self, port, host='127.0.0.1', loglevel=0):
logger.setLevel(loglevel)
TCPServer.__init__(self, (host, port), WebSocketHandler)
self.port = self.socket.getsockname()[1]
def __init__(self, serving_env, address, port):
handler = _make_handler(serving_env)
HTTPServer.__init__(self, (address, port), handler)
def __init__(self, server_address, nx_common):
nx_common.log(msg='Constructing MSLTCPServer')
self.nx_common = nx_common
self.MslHandler = MSL(nx_common)
TCPServer.__init__(self, server_address, MSLHttpRequestHandler)
def __init__(self, port, host, loglevel=logging.WARNING):
logger.setLevel(loglevel)
TCPServer.__init__(self, (host, port), WebSocketHandler)
self.port = self.socket.getsockname()[1]
def __init__(self, port, host='127.0.0.1', loglevel=logging.WARNING):
logger.setLevel(loglevel)
TCPServer.__init__(self, (host, port), WebSocketHandler)
self.port = self.socket.getsockname()[1]
self.allow_reuse_address = True
def __init__(self, server_address, RequestHandlerClass, secret, dirname):
TCPServer.__init__(self, server_address, RequestHandlerClass)
self.secret = secret
self.dirname = dirname
self.block_size = int(config().get('global', 'block_size'))
def __init__(self, host='127.0.0.1', port=3128, db=None, certstore=None):
TCPServer.__init__(self, (host, port), HttpReplayHandler)
self.hp = (host, port)
self.db = db
self.certstore = certstore
self.certcache = {}
def __init__(self, external_env, address, port):
handler = _make_handler(external_env)
HTTPServer.__init__(self, (address, port), handler)
def __init__(self):
server_address = ('localhost', 0)
TCPServer.__init__(self, server_address, HelloRequestHandler)
