def __init__(
self, host="localhost", port=logging.handlers.DEFAULT_TCP_LOGGING_PORT, handler=LogRecordStreamHandler
):
ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
self.logname = None
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=21, banner='', debug=False, logfile=None,
append=False):
ThreadingTCPServer.__init__(self, (host, port), FTPLoginHandler)
self.banner = banner
self.debug = debug
mode = (append and 'a' or 'w')
self.logfile = (logfile and open(logfile, mode) or stdout)
def __init__(self, port, deviceFd, deviceLock, debug = False, aexServer = None):
'''
Constructor
'''
self.running = False
self.__dataQueue = Queue(0)
self.__clients = []
self.debug = debug
self.__deviceFd = deviceFd
self.deviceLock = deviceLock
self.aexServer=aexServer
self.runningTime = 0
self.receivingTime = 0
self.packetsReceived = 0
self.sleepingTimes = 0
ThreadingTCPServer.__init__(self, ("", port), StimNetCom, False)
ThreadingTCPServer.allow_reuse_address = True
self.server_bind()
self.server_activate()
Thread.__init__(self)
def __init__(self,
port,
deviceFd,
deviceLock,
debug=False,
aexServer=None):
'''
Constructor
'''
self.running = False
self.__dataQueue = Queue(0)
self.__clients = []
self.debug = debug
self.__deviceFd = deviceFd
self.deviceLock = deviceLock
self.aexServer = aexServer
self.runningTime = 0
self.receivingTime = 0
self.packetsReceived = 0
self.sleepingTimes = 0
ThreadingTCPServer.__init__(self, ("", port), StimNetCom, False)
ThreadingTCPServer.allow_reuse_address = True
self.server_bind()
self.server_activate()
Thread.__init__(self)
def __init__(self,
db,
udp=None,
host=None,
port=2152,
admin=None,
debug=False):
"""Create a new server instance.
db -- NoticeDB instance for sticky notifications.
udp -- UDP server object (or None).
host -- hostname or IP to listen on.
port -- TCP port to listen on.
admin -- ID of privileged user.
debug -- enable debugging output?
"""
if host is None:
host = '0.0.0.0' # Whatever's available locally
self.db = db # Database of sticky notices
self.udp = udp # UDP server
self.auth = None # Currently authenticated user, if any
self.run = False # Currently running?
self.adm = admin # Privileged user ID, if any
self.debug = debug
ThreadingTCPServer.__init__(self, (host, port), NotifyTCPHandler)
def __init__(self,
port,
monServer,
stimServer,
debug=False,
aexServer=None):
'''
Constructor
'''
self.running = False
self.__commandQueue = Queue(0)
self.__clients = []
self.debug = debug
self.aexServer = aexServer
self.monServer = monServer
self.stimServer = stimServer
ThreadingTCPServer.__init__(self, ("", port), CtrlNetCom, False)
ThreadingTCPServer.allow_reuse_address = True
self.server_bind()
self.server_activate()
Thread.__init__(self)
def __init__(self, address, handler):
self._logger = logging.getLogger('GlobalTCPServer')
self._logger.debug('__init__')
self._command_set = { 0 : self.subscribe,
1 : self.unsubscribe,
8 : self.start_correlator,
9 : self.stop_correlator,
10 : self.get_integration_time,
11 : self.set_integration_time,
32 : self.get_phase_offsets,
33 : self.set_phase_offsets,
34 : self.get_delay_offsets,
35 : self.set_delay_offsets,
##TODO
36 : self.get_algorithm,
37 : self.set_algorithm,
255 : self.shutdown,
}
self._started = False
self._n_antennas = 8
self._integration_time = 16 #sec
self.antennas_remaping = {0:6, 1:1, 2:2, 3:3, 4:4, 5:5, 6:7, 7:8}
self._correlator = None #TODO-2
self._delay_control = SingleBlockmappingDelayControl({"/dev/ttyS4" : (6,1,2,3), "/dev/ttyS5" : (4,5,7,8)})
self._stop_spread_event = Event()
ThreadingTCPServer.__init__(self, address, handler)
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):
log(Log.INFO,"init racelist server on %s:%d" % (config.servername,config.racelistport))
StopableThread.__init__(self)
self._racelist = RaceList(self)
self._serverlist = RLServerList(self)
self._broadcastserver = BroadCastServer(self)
self._requesthandlers = {}
self._addRequestHandler(request.HandlerLogin(self))
self._addRequestHandler(request.HandlerDistributedLogin(self))
self._addRequestHandler(request.HandlerReqFull(self))
self._addRequestHandler(request.HandlerHost(self))
self._addRequestHandler(request.HandlerDistributedHost(self))
self._addRequestHandler(request.HandlerJoin(self))
self._addRequestHandler(request.HandlerLeave(self))
self._addRequestHandler(request.HandlerEndHost(self))
self._addRequestHandler(request.HandlerBroadcast(self))
self._addRequestHandler(request.HandlerReport(self))
self._addRequestHandler(request.HandlerRLSRegister(self))
self._addRequestHandler(request.HandlerRLSUnRegister(self))
self._addRequestHandler(request.HandlerRLSUpdate(self))
self._addRequestHandler(request.HandlerRLSFullUpdate(self))
self._addRequestHandler(request.HandlerCopyright(self))
if __debug__:
self._addRequestHandler(request.HandlerHelp(self))
self._request_count = 0
self._lastloadsampletimestamp = time()
self.register()
self.allow_reuse_address = 1
ThreadingTCPServer.__init__(self,("",config.racelistport),RaceListServerRequestHandler)
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 = 'localhost', port = DEFAULT_LOGGING_CONFIG_PORT, handler = None, ready = None):
ThreadingTCPServer.__init__(self, (host, port), handler)
logging._acquireLock()
self.abort = 0
logging._releaseLock()
self.timeout = 1
self.ready = ready
def __init__(self,
port,
deviceFd,
deviceLock,
debug=False,
aexServer=None):
'''
Constructor
'''
self.running = False
self.__clients = {}
self.debug = debug
self.aexServer = aexServer
self.__deviceFd = deviceFd
self.deviceLock = deviceLock
ThreadingTCPServer.__init__(self, ("", port), MonNetCom, False)
ThreadingTCPServer.allow_reuse_address = True
self.server_bind()
self.server_activate()
Thread.__init__(self)
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, server_address, RequestHandlerClass, key, opts):
ThreadingTCPServer.__init__(self, server_address,
RequestHandlerClass)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR,
1)
self.key = key
self.opts = opts
self.initSecurity()
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
def __init__(self, handler):
#
# We assume the server to be listening on local socket only, as we want
# to have an easy and fast access to the recorded by Asterisk files,
# easily pass own prompt files, etc
#
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, ("127.0.0.1", 4573), handler)
def __init__(self):
self.log = logging.getLogger();
self.log.setLevel(logging.DEBUG);
log_hdl = logging.StreamHandler();
log_hdl.setFormatter(logging.Formatter( '%(asctime)s %(levelname)s %(message)s' ))
self.log.addHandler(log_hdl);
self.allow_reuse_address = True;
ThreadingTCPServer.__init__(self, ('', 21), self.BackConnectHandler);
def __init__(self,
host='localhost',
port=logging.handlers.DEFAULT_TCP_LOGGING_PORT,
handler=LogRecordStreamHandler):
ThreadingTCPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
self.logname = None
def __init__(self, server_address, HandlerClass):
"""Constructor
@param server_address: tuple of server IP and port to listen on.
@param HandlerClass: the RequestHandler class to instantiate per req.
"""
self._hits = 0
ThreadingTCPServer.__init__(self, server_address, HandlerClass)
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
def __init__(self, clientHost, clientPort):
SimpleXMLRPCDispatcher.__init__(self)
ThreadingTCPServer.__init__(self,
(clientHost, clientPort),
SimpleXMLRPCRequestHandler)
self.logRequests = 1
self.client = AdminControlInterface()
self.register_introspection_functions()
self.register_instance(self.client)
def __init__(self, server_address, HandlerClass):
"""Constructor.
@param server_address: tuple of server IP and port to listen on.
@param HandlerClass: the RequestHandler class to instantiate per req.
"""
self.requests_received = []
ThreadingTCPServer.allow_reuse_address = True
ThreadingTCPServer.__init__(self, server_address, HandlerClass)
def __init__(self,
server_address,
RequestHandlerClass,
service,
data=None):
self.data = data
self.service = service
#HTTPServer.__init__(self, server_address, RequestHandlerClass)
ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass)
def __init__(self, serverInfo, EchoHandler, log):
'''
Constructor
'''
self.name = "address-" + serverInfo[0] + "-port-" + str(serverInfo[1])
self.log = log
self.flood('DistributedStorageBenchmarkServer is being instantiated and initialized: ' + self.name)
ThreadingTCPServer.__init__(self, serverInfo, EchoHandler)
self.flood(self.name + ' is done initializing.')
def __init__(self, log_level=log.INFO, ip='0.0.0.0', port=5000, prune_inactive=PRUNE_IDLE_SECS):
log.basicConfig(level=log_level)
self.games = {}
self.lock = RLock()
self.allow_reuse_address = True
self.prune_inactive = prune_inactive
ThreadingTCPServer.__init__(self, (ip, port), RequestHandler)
self.host, self.port = self.server_address
log.info('started server on %s:%s', self.host, self.port)
def __init__(self):
self.log = logging.getLogger()
self.log.setLevel(logging.DEBUG)
log_hdl = logging.StreamHandler()
log_hdl.setFormatter(
logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
self.log.addHandler(log_hdl)
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, ('', 21), self.BackConnectHandler)
def __init__(self,
server_address,
RequestHandlerClass,
dbpath,
bind_and_activate=True):
ThreadingTCPServer.__init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=True)
self.dbpath = dbpath
def __init__(self,
host='',
port=21,
debug=False,
save_to_file=False,
verbose=True):
ThreadingTCPServer.__init__(self, (host, port), FTPHandler)
self.debug = debug
self.verbose = verbose
self.save_to_file = save_to_file
def __init__(self, addr, requestHandler=DroidPresRequestHandler, logRequests=False, allow_none=False, encoding=None, bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ThreadingTCPServer.__init__(self, addr, 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, server_address, default_sem, spinlock_time):
self.allow_reuse_address = True
self.sems = {}
self.sems['default'] = BoundedSemaphore(default_sem)
self.locks = {}
self.locks['default'] = Lock()
self.barriers = {}
self.spinlock_time = spinlock_time
self.logger = logging.getLogger('LockServer')
ThreadingTCPServer.__init__(self, server_address, LockServerHandler)
def __init__(self,
server_address,
RequestHandlerClass,
dbpath,
bind_and_activate=True):
ThreadingTCPServer.__init__(
self,
server_address,
RequestHandlerClass,
bind_and_activate=True)
self.dbpath = dbpath
def __init__(
self,
server_address,
RequestHandlerClass,
allowed_exceptions=(),
allowed_errnos=(errno.EPIPE, ),
):
# We can't use super since the superclass isn't a new style class
ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass)
self._allowed_exceptions = allowed_exceptions
self._allowed_errnos = allowed_errnos
def __init__(self,
host,
port,
handlers,
timeout=10,
request_handler_class=MLLPRequestHandler):
self.host = host
self.port = port
self.handlers = handlers
self.timeout = timeout
ThreadingTCPServer.__init__(self, (host, port), request_handler_class)
def __init__(self,
server_address=(DEFAULT_SERVER_ADDRESS, DEFAULT_SERVER_PORT),
RequestHandlerClass=RCMPPacketHandler,
dispatcher=None):
ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass)
# keep track of the handlers used to process the requests
self.handlers = {}
self.dispatcher = dispatcher
# we set the ros_ip at this level because in case of more than one ip
# address this is the one we use for the platform and we want to use
# for ros too
os.environ[self.ROS_IP_ENV] = server_address[0]
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, *args, **kwargs):
"""Initializes Volt HTTP server.
In addition to performing BaseServer initialization, this method
also polls the timestamp of all directories inside the Volt project
directory except the site output directory. This is set as a self
atttribute and will be used later to generate the site everytime
a file inside these directories are modified.
"""
self.last_mtime = self.check_dirs_mtime()
ThreadingTCPServer.__init__(self, *args, **kwargs)
self.logger.debug('created: %s' % type(self).__name__)
def __init__(self, addr, requestHandler=SimpleXMLRPCRequestHandler,
logRequests=True, allow_none=False, encoding=None, bind_and_activate=True):
self.logRequests = logRequests
SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding)
ThreadingTCPServer.__init__(self, addr, requestHandler, bind_and_activate)
# [Bug #1222790] If possible, set close-on-exec flag; if a
# method spawns a subprocess, the subprocess shouldn't have
# the listening socket open.
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, host="", port=COBRA_PORT):
self.shared = {}
self.host = host
self.port = port
self.reflock = RLock()
self.refcnts = {}
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, (host, port), CobraConnectionHandler)
if port == 0:
self.port = self.socket.getsockname()[1]
self.daemon_threads = True
def __init__(
self,
server_address=(DEFAULT_SERVER_ADDRESS, DEFAULT_SERVER_PORT),
RequestHandlerClass=RCMPPacketHandler,
dispatcher=None,
):
ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass)
# keep track of the handlers used to process the requests
self.handlers = {}
self.dispatcher = dispatcher
# we set the ros_ip at this level because in case of more than one ip
# address this is the one we use for the platform and we want to use
# for ros too
os.environ[self.ROS_IP_ENV] = server_address[0]
def __init__(self, config):
"""Takes an httpy.Config object.
We stick verbosity in the environment so that httpy.log can use it.
"""
self.config = config
os.environ["HTTPY_VERBOSITY"] = str(self.config['verbosity'])
addr = (self.config['ip'], self.config['port'])
if self.config['mode'] == 'development':
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, addr, Handler)
def __init__(self,
addr,
logger,
allow_none=False,
logRequests=1,
encoding='iso-8859-1'):
class AuthenticatedRequestHandler(SimpleXMLRPCRequestHandler):
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
header = myself.headers.get('Authorization')
if header == None:
username = None
password = None
else:
(basic, encoded) = \
header.split(' ', 2)
assert basic == 'Basic', 'Only basic authentication supported'
(username,
password) = base64.b64decode(encoded).split(':', 2)
if self.authenticate(username, password):
return True
else:
myself.send_response(401, 'Authentication failed')
myself.send_header('WWW-Authenticate',
'Basic realm="XML-RPC"')
myself.end_headers()
myself.wfile.write('Authentication failed.')
return False
self.logRequests = logRequests
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self,
allow_none=allow_none,
encoding=encoding)
ThreadingTCPServer.__init__(self, addr, AuthenticatedRequestHandler)
self.required_username = None
self.required_password = None
self.logger = logger
def __init__(self,
socks_host,
socks_port,
auth=False,
user_manager=UserManager(),
allowed=None,
transport=None):
self.transport = transport
ThreadingTCPServer.__init__(self, (socks_host, socks_port),
Socks5RequestHandler)
self.__port = socks_port
self.__users = {}
self.__auth = auth
self.__user_manager = user_manager
self.__sessions = {}
self.allowed = allowed
def __init__(self, *args):
plugins.Responder.__init__(self, *args)
ThreadingTCPServer.__init__(self, (socket.gethostname(), 0), self.handlerClass())
self.testMap = {}
self.testLocks = {}
self.testClientInfo = {}
self.diag = logging.getLogger("Slave Server")
self.terminate = False
# If a client rings in and then the connectivity is lost, we don't want to hang waiting for it forever
# So we enable keepalive that will check the connection if no data is received for a while
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, True)
# Default is 2 hours here on Linux which is rather a long time to wait for anything to happen.
# We give up after 5 minutes
if hasattr(socket, "TCP_KEEPIDLE"):
self.socket.setsockopt(socket.SOL_TCP, socket.TCP_KEEPIDLE, 300)
def __init__(self, settings):
""" Initialisation of the Proxy TCP server """
self._s = settings # Make settings available to the RequestHandler
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, settings):
""" Initialisation of the Proxy TCP server """
self._s = settings # Make settings available to the RequestHandler
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,
host="",
port=COBRA_PORT,
sslcrt=None,
sslkey=None,
sslca=None):
'''
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)
# 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 = {}
# 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!')
self.allow_reuse_address = True
ThreadingTCPServer.__init__(self, (host, port), CobraRequestHandler)
if port == 0:
self.port = self.socket.getsockname()[1]
self.daemon_threads = True
def __init__(self, addr, logger, allow_none=False, logRequests=1,
encoding='iso-8859-1'):
class AuthenticatedRequestHandler(SimpleXMLRPCRequestHandler):
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
header = myself.headers.get('Authorization')
if header == None:
username = None
password = None
else:
(basic, encoded) = \
header.split(' ', 2)
assert basic == 'Basic', 'Only basic authentication supported'
(username,
password) = base64.b64decode(encoded).split(':', 2)
if self.authenticate(username, password):
return True
else:
myself.send_response(401, 'Authentication failed')
myself.send_header('WWW-Authenticate',
'Basic realm="XML-RPC"')
myself.end_headers()
myself.wfile.write('Authentication failed.')
return False
self.logRequests = logRequests
if sys.version_info[:2] < (2, 5):
SimpleXMLRPCDispatcher.__init__(self)
else:
SimpleXMLRPCDispatcher.__init__(self, allow_none=allow_none,
encoding=encoding)
ThreadingTCPServer.__init__(self, addr, AuthenticatedRequestHandler)
self.required_username = None
self.required_password = None
self.logger = logger
def __init__(self, **kw):
"""
Create the SPIRO server object
Arguments:
- none yet
Keywords:
- host - host to listen on for client conns (default self.host ('127.0.0.1')
- port - port to listen on for client conns (default self.port (7656)
- imports - imports to pre-load into each new client namespace
- logVerbosity - logging verbosity, defaults to global defaultLogVerbosity
- logFile - file to log to, defaults to defaultLogfile
- logDelay - delay between logging messages, default 0
"""
# get a logger, and grab method shortcuts
self.logger = SpiroLogger(**kw)
self.log = self.logger.log
self.logException = self.logger.logException
# get optional host/port for client and i2cp
self.host = kw.get('host', self.host)
self.port = int(kw.get('port', self.port))
self.importslist = kw.get('imports', self.importslist)
self.modules = {}
self.objCache = {}
# sessions by name, allows n clients to share a space
self.sessions = {}
# do the required imports
for importname in self.importslist:
module = myimport(importname)
self.modules[importname] = module
if self.modules.keys():
self.log(4, "Pre-Imported modules: %s" % ", ".join(self.modules.keys()))
# do the base class
ThreadingTCPServer.__init__(
self,
(self.host, self.port),
SpiroSession)
def __init__(self, port, deviceFd, deviceLock, debug = False, aexServer = None):
'''
Constructor
'''
self.running = False
self.__clients = {}
self.debug = debug
self.aexServer=aexServer
self.__deviceFd = deviceFd
self.deviceLock=deviceLock
ThreadingTCPServer.__init__(self, ("", port), MonNetCom, False)
ThreadingTCPServer.allow_reuse_address = True
self.server_bind()
self.server_activate()
Thread.__init__(self)
def __init__(self, port, monServer, stimServer, debug = False, aexServer = None):
'''
Constructor
'''
self.running = False
self.__commandQueue = Queue(0)
self.__clients = []
self.debug = debug
self.aexServer = aexServer
self.monServer = monServer
self.stimServer = stimServer
ThreadingTCPServer.__init__(self, ("", port), CtrlNetCom, False)
ThreadingTCPServer.allow_reuse_address = True
self.server_bind()
self.server_activate()
Thread.__init__(self)
def __init__(self, server_address, RequestHandlerClass) :
ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass)
self.server_name = 'MindWiki'
self.server_port = SERVER_PORT
self.page_head = open(os.path.join(MAIN_DIR, 'index_1.html'), 'r').read()
self.page_tail = open(os.path.join(MAIN_DIR, 'index_2.html'), 'r').read()
self.file_cache = {} # path -> (modify, head-content)
# Entry Index
self.dir2doclist = {}
MindIndex.build_entry_index(self.dir2doclist, DATA_DIR)
print "[%s] built entries' index." % time.strftime(TIME_FMT)
# WORD INDEX
self.ws = MindIndex.Word.WordSeg()
self.doc_profile = [] # profile item: (entry_tuple, ctime, mtime, words)
self.word_docset = {} # word->doc_id_set
self.word_idf = {}
#self.build_word_index()
t = threading.Thread(target=self.build_word_index, args=())
#t.setDaemon(True)
t.start()
def __init__(self, host, handler, path='.'):
ThreadingTCPServer.__init__(self, host, handler)
self.abspath = path
def __init__(self, port, onMsgCallback, fileServer):
self.onMsgCallback = onMsgCallback
self.fileServer = fileServer
ThreadingTCPServer.__init__(self, ('', int(port)), SingleFileUpload)
self.socket.settimeout(0.5)
def __init__(self, server_address, data_cache):
self.data_cache = data_cache
ThreadingTCPServer.__init__(self, server_address, PDCacheRequestHandler)
def __init__(self, server_address, RequestHandlerClass, queue): ThreadingTCPServer.__init__(self, server_address, RequestHandlerClass) self.queue = queue
