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
class FileSearchServer(Thread):
""" Thread which answers to file/tag queries sent through unix socket. """
def __init__(self, pname='SET_ME_PLEASE'):
Thread.__init__(self)
self.name = "%s/%s" % (
pname, str(self.__class__).rsplit('.', 1)[1].split("'")[0])
# old socket from a crashed daemon ?
# remove it, the ThreadingUnixStreamServer will create it.
#if os.path.exists(socket_path): os.unlink(socket_path)
self._stop_event = Event()
self.server = ThreadingTCPServer(('127.0.0.1', searcher_port), FileSearchRequestHandler)
self.server.allow_reuse_address = True
# TODO: the socket is set to non-blocking to be able to gracefully terminate the thread,
# but this could lead to CPU hogging problems. VERIFY THIS !!
self.server.socket.setblocking(False)
def run(self):
logging.progress("%s: thread running." % (self.getName()))
#os.chmod(socket_path, stat.S_IRUSR|stat.S_IWUSR|stat.S_IRGRP|stat.S_IWGRP|stat.S_IROTH|stat.S_IWOTH)
while not self._stop_event.isSet():
self.server.handle_request()
time.sleep(0.01)
logging.progress("%s: thread ended." % (self.getName()))
def stop(self):
if not self._stop_event.isSet():
logging.progress("%s: stopping thread." % (self.getName()))
self._stop_event.set()
self.server.socket.close()
self.server.server_close()
if os.path.exists(socket_path):
os.unlink(socket_path)
def shutdown(self):
"""Stop the server."""
# this is the call for shutting down the server
ThreadingTCPServer.shutdown(self)
# wait until all the requests have finished
for h in self.handlers.values():
h.join()
class ConnServer(Thread):
def __init__(self):
Thread.__init__(self)
self.PORT = 1236
self.init = False
self.startrecv = False
global g_p
g_p = ConnProc()
global g_connlist
g_connlist = []
global g_connid
g_connid = []
def run(self):
self.initSock()
def executeCommand(self, cmd):
# not implemented yet
#print
r = g_p.ProcCommand(cmd)
print r
def initSock(self):
try:
self.client = ThreadingTCPServer( ('', self.PORT), RecvServer)
print 'listening on PORT', self.PORT
self.client.serve_forever()
except Exception, e:
print e
self.init = True;
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=DEFAULT_LOGGING_CONFIG_PORT,
handler=None):
ThreadingTCPServer.__init__(self, (host, port), handler)
logging._acquireLock()
self.abort = 0
logging._releaseLock()
self.timeout = 1
def run(self):
"""
"""
s = None
HOST = ''; # Symbolic name meaning the local host.
if sys.platform.startswith("win"):
HOST = socket.gethostbyaddr(socket.gethostname())[2][0]
else:
import commands
temp = commands.getoutput('/sbin/ifconfig')
HOST = re.search('inet addr:(\d+\.\d+\.\d+\.\d+)', temp).group(1)
if USER_PORT:
print "listening on port: %s" % xoom_server_port
PORT = xoom_server_port
print "================="
else:
print "XXXX not port specified, using default port: %s" % default_xoom_server_port
PORT = default_xoom_server_port
print "PORT: %s" % PORT
print "SERVER->HOST: %s, SERVER->PORT: %s" % (HOST, PORT)
srv = ThreadingTCPServer((HOST,int(PORT)), XMLRequestHandler)
self.socket = srv.socket
print "srv socket: %s" % self.socket
srv.serve_forever()
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, 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, 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, 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 run_as_backup_offline():
logging.info("begin run as backup offline")
global backup_ip
global backup_port
server_address = (backup_ip, backup_port)
server = ThreadingTCPServer(server_address, MyStreamRequestHandler)
server.serve_forever()
logging.error(traceback.format_exc())
def process_request_thread(self, request, client_address):
try:
ThreadingTCPServer.process_request_thread(
self, request, client_address)
finally:
# Client is no longer connected, remove the reference
del self.clients[client_address]
print 'self.clients', pformat(self.clients)
def shutdown(self, args):
""" Overloaded method that kills the correlator before shutdown."""
self.logger.debug('shutdown()')
self.logger.info('shutting down the server...')
if self._started:
self.stop_correlator('')
ThreadingTCPServer.shutdown(self)
return SBYTE.pack(0)
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, 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, 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 main():
level = logging.INFO
logging.basicConfig(format='%(asctime)s [%(levelname)s] %(message)s',
datefmt='%m/%d/%Y %I:%M:%S %p',
level=level)
ThreadingTCPServer.allow_reuse_address = True
server = ThreadingTCPServer(('0.0.0.0', 8118), Encoder)
server.serve_forever()
def start(program, options): ThreadingTCPServer.allow_reuse_address = True server = ThreadingTCPServer((host, port), QuasselGrepHandler) server.program = program server.options = options server.serve_forever() print "Finishing."
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 handle_error(self, *args): """make ThreadingTCPServer happy""" exc_info = sys.exc_info() error = exc_info and len(exc_info) and exc_info[1] if isinstance(error, (socket.error)) and len(error.args) > 1 : exc_info = error = None else: del exc_info, error ThreadingTCPServer.handle_error(self, *args)
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 main():
i2t_server = ThreadingTCPServer(('', PORT), I2T_Handler)
i2t_server.allow_reuse_address = True
print "listening on port", PORT
i2t_threads = threading.Thread(target = i2t_server.serve_forever)
i2t_threads.setDaemon(True)
i2t_threads.start()
print "Image2Torrent Machine started..."
raw_input()
def start(port=21567):
"""
this function to start the server, and maintain listening the port.
"""
host = ''
address = (host, port)
tcpServ = ThreadingTCPServer(address, MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
def stop(port=21567):
"""
this function to close the server
"""
host = ''
address = (host, port)
tcpServ = ThreadingTCPServer(address, MyRequestHandler)
print 'closing connection...'
tcpServ.shutdown()
def _server(self):
"""
进程服务入口函数
"""
host= ''
ADDR = (host, self.port)
TCP.allow_reuse_address = True
tcpServ = TCP(ADDR, MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
def serve_forever(self):
try:
ThreadingTCPServer.serve_forever(self)
except Exception, e:
if not self.run:
return
raise
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,
RequestHandlerClass,
dbpath,
bind_and_activate=True):
ThreadingTCPServer.__init__(
self,
server_address,
RequestHandlerClass,
bind_and_activate=True)
self.dbpath = dbpath
class LogServer():
'''由于serve_forever()是阻塞的，所以需要单开一个进程或线程来开启日志服务'''
def __init__(self, addr, requestHandler):
self.bindAddress = addr
self.requestHandler = requestHandler
logging.config.fileConfig(LOGCONFIG)
def start(self):
self.svr = ThreadingTCPServer(self.bindAddress, self.requestHandler)
self.svr.serve_forever()
def stop(self):
self.svr.shutdown()
def __init__(self, host='0.0.0.0', port=8000, HandlerClass=XXEHandler):
Thread.__init__(self)
self._stop = Event()
self.host = host
self.port = port
self.server_address = (self.host, self.port)
self.HandlerClass = HandlerClass
if self.HandlerClass is None:
self.HandlerClass = SimpleHTTPRequestHandler
self.HandlerClass.protocol_version = "HTTP/1.0"
self.httpd = HTTPServer(self.server_address, self.HandlerClass)
else:
self.httpd = ThreadingTCPServer(self.server_address, self.HandlerClass)
def run(self):
sock = None
ThreadingTCPServer.daemon_threads = True
ThreadingTCPServer.request_queue_size = 1024
ThreadingTCPServer.allow_reuse_address = True
try:
sock = ThreadingTCPServer(self._addrs, SOCK2HttpHandler)
logging.warning('-'*50)
logging.warning('sock proxy start on:%s' % repr(self._addrs))
sock.serve_forever()
except Exception, e:
logging.error('fatal error:%s' % e)
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 start_CC_simulator(configname, listenport):
global global_config_file
global global_config_name
global global_payload
global_config_name = configname
print global_config_name
config = __import__(configname)
if (not configcheck(config)):
ErrorPrint("Syntax error in config file")
else:
addr = ("", listenport)
server = ThreadingTCPServer(addr, MyStreamRequestHandler)
server.serve_forever()
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
class PySAPHDBConnectionTest(unittest.TestCase):
test_port = 30017
test_address = "127.0.0.1"
def start_server(self, address, port, handler_cls):
self.server = ThreadingTCPServer((address, port),
handler_cls,
bind_and_activate=False)
self.server.allow_reuse_address = True
self.server.server_bind()
self.server.server_activate()
self.server_thread = Thread(target=self.server.serve_forever)
self.server_thread.daemon = True
self.server_thread.start()
def stop_server(self):
self.server.shutdown()
self.server.server_close()
self.server_thread.join(1)
def test_saphdbconnection_initialize(self):
"""Test HDB Connection initialize"""
self.start_server(self.test_address, self.test_port,
SAPHDBServerTestHandler)
client = SAPHDBConnection(self.test_address, self.test_port)
client.connect()
client.initialize()
self.stop_server()
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 Start_Server(host, port):
try:
print 'server is running....'
httpd_address = (host, int(port))
myhttpd = ThreadingTCPServer(httpd_address, Custom_HTTPRequestHandler)
#myhttpd = HTTPServer(httpd_address, Custom_HTTPRequestHandler)
print 'myhttpd:', myhttpd
myhttpd.serve_forever()
except KeyboardInterrupt:
print 11111111111
print 'myhttpd:', myhttpd
#myhttpd.socket.close()
myhttpd.shutdown
print 22222222222
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
class Server(threading.Thread):
def __init__(self, host=None, port=None):
threading.Thread.__init__(self)
self.__host = host
self.__port = port
addr = (self.__host, self.__port)
self.server = ThreadingTCPServer(addr, Handler)
def run(self):
if self.__host is None or self.__port is None:
log.err('Please specify the host ip and port.')
return
log.i("Start TCP server at %s:%d" % (self.__host, self.__port))
self.server.serve_forever()
def handle_request(self):
print " handle request "
handler = ThreadingTCPServer.handle_request(self)
handler.set_handlers(self.handleWiFlyMessage,
self.handleBrowserMessage)
clients.append(handler)
return handler
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 ext_out(ftun=0):
"""
Create a TCP server and return a TCPServer instance
"""
ThreadingTCPServer.allow_reuse_address = True
ThreadingTCPServer.address_family = socket.AF_INET6
EchoHandler.ftun = ftun
server = ThreadingTCPServer((config.INIP, config.INPORT), EchoHandler)
return server
class ConcurrentHTTPServer(ConcurrentServer):
def __init__(self, host='', port=8000, directory='.'):
super(ConcurrentHTTPServer, self).__init__(host=host, port=port)
class RequestHandler(SimpleHTTPRequestHandler):
def translate_path(self, path):
path = path.split('?', 1)[0]
path = path.split('#', 1)[0]
trailing_slash = path.rstrip().endswith('/')
path = posixpath.normpath(urllib.unquote(path))
words = path.split('/')
words = filter(None, words)
path = directory # patch SimpleHTTPRequestHandler to use different directory than working dir
for word in words:
if os.path.dirname(word) or word in (os.curdir, os.pardir):
continue
path = os.path.join(path, word)
if trailing_slash:
path += '/'
return path
self._request_handler = RequestHandler
self._server = None
def _run_function(self):
self._server = ThreadingTCPServer((self.host, self.port),
self._request_handler)
self._server.daemon_threads = True
self._server.serve_forever()
def _close_function(self):
self._server.shutdown()
self._server.server_close()
self._server = None
def createAndStartServer():
global serv
ThreadingTCPServer.allow_reuse_address = True
serv = ThreadingTCPServer(('', 20000),
SocketHandler,
bind_and_activate=False)
l_onoff = 1
l_linger = 0
serv.socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER,
struct.pack('ii', l_onoff, l_linger))
serv.server_bind()
serv.server_activate()
HP.logger.info('Starting server')
serv.serve_forever() # blocking method
def RunTCPServer(host='127.0.0.1', port=34567):
tcpServ = ThreadingTCPServer((host, port), MyRequestHandler)
try:
tcpServ.serve_forever()
except (KeyboardInterrupt,EOFError):
print('Closing TCPServer ...')
tcpServ.shutdown()
def start(program, options):
ThreadingTCPServer.allow_reuse_address = True
server = ThreadingTCPServer((host, port), QuasselGrepHandler)
server.program = program
server.options = options
server.serve_forever()
print "Finishing."
def sensor_recv_TCPserver_run():
initializationConfigParser = InitializationConfigParser("ServerConfig.ini")
TcpListingConfig = initializationConfigParser.GetAllNodeItems(
"TcpServerListeningSocket")
TcpListingConfig["listening_port"] = int(
TcpListingConfig.get("listening_port"))
TcpAddress = (TcpListingConfig.get("tcpserver_host"),
TcpListingConfig.get("listening_port"))
logging.info(TcpAddress)
server = ThreadingTCPServer(TcpAddress, SensorRecvTCPServerHandler)
logging.info('request_tcpserver_thread start')
serve_forever_thread = threading.Thread(target=server.serve_forever)
serve_forever_thread.start()
logging.info('request_tcpserver_thread running')
def start_ip(self, port):
"""Create a TCP server and start listening for data. Put any input data
on the inq for listen to read, and send and data on the outq. The
drvAsynIPPortConfigure should connect to localhost:port if the
simulation is on the same machine as the IOC."""
if self.started:
self.diagnostic("Server already started")
else:
self.inq, self.outq = Queue.Queue(), Queue.Queue()
self.started = True
# store the request to respond to
self.outreq = None
def MakeHandler(device):
# make a basic tcp handler that puts messages on a queue
class ProxyHandler(BaseRequestHandler):
def setup(self):
BaseRequestHandler.setup(self)
device.onHandlerSetup(self)
def finish(self):
BaseRequestHandler.finish(self)
device.onHandlerFinish(self)
def handle(self):
if self.request != None:
data = "nothing yet"
device.outreq = self.request
while data:
data = self.request.recv(1024)
for char in data:
device.inq.put(char)
return ProxyHandler
ThreadingTCPServer.allow_reuse_address = True
self.server = ThreadingTCPServer(("", port), MakeHandler(self))
# start to listen on the master port
self.__daemon(self.server.serve_forever)
# start to respond to any messages put on the outq
self.__daemon(self.__ip_out)
# start the worker thread
self.__daemon(self.__process)
def main():
global world
world = World()
z = ThreadingTCPServer(('', 4000), MudHandler)
try:
z.serve_forever()
except KeyboardInterrupt:
world.global_message('World is shutting down')
for plr in world.players_at_location(None):
try:
plr.parse('quit')
except:
print 'ERROR: %s could not quit gracefully' % plr.name
z.server_close()
world.save()
class ConnWebServer(Thread):
def __init__(self):
Thread.__init__(self)
self.WSPORT = 1240
self.init = False
self.startrecv = False
global g_p
g_p = ConnProc()
global g_connlist
g_connlist = []
global g_connid
g_connid = []
global g_conntype
g_conntype = []
def run(self):
self.initSock()
def executeCommand(self, cmd):
# not implemented yet
#print
r = g_p.ProcCommand(cmd)
print r
def initSock(self):
try:
self.clientWS = ThreadingTCPServer(('', self.WSPORT),
WebSocketServer, False)
print 'listening on PORT(WS)', self.WSPORT
self.clientWS.allow_reuse_address = True
self.clientWS.server_bind()
self.clientWS.server_activate()
self.clientWS.serve_forever()
except Exception, e:
print e
self.init = True
}))
elif not authed:
self.json_headers()
if not globals()['run_already']:
open_new_tab(liw.authentication.authorization_url)
globals()['run_already'] = True
self.wfile.write(
dumps({
'path': self.path,
'authed': type(liw.authentication.token) is NoneType
}))
elif authed and len(parsedurl.path) and parsedurl.path[1:] in dir(
liw.application):
self.json_headers()
self.wfile.write(
dumps(getattr(liw.application, parsedurl.path[1:])()))
else:
self.json_headers(501)
self.wfile.write(dumps({'error': 'NotImplemented'}))
if __name__ == '__main__':
ThreadingTCPServer.allow_reuse_address = True
httpd = ThreadingTCPServer(('localhost', PORT), CustomHandler)
print 'Server started on port:', PORT
httpd.serve_forever()
#coding:utf8
from SocketServer import ThreadingTCPServer, StreamRequestHandler
import traceback
class MyStreamRequestHandlerr(StreamRequestHandler):
def handle(self):
while True:
try:
data = self.rfile.readline().strip()
print "receive from (%r):%r" % (self.client_address, data)
self.wfile.write(data.upper())
except:
traceback.print_exc()
break
if __name__ == "__main__":
host = "127.0.0.1" #主机名，可以是ip,像localhost的主机名,或""
port = 9990 #端口
addr = (host, port)
#ThreadingTCPServer从ThreadingMixIn和TCPServer继承
#class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass
server = ThreadingTCPServer(addr, MyStreamRequestHandlerr)
server.serve_forever()
def create_server(addr, port, handler):
server = ThreadingTCPServer((addr, port), handler, bind_and_activate=False)
server.allow_reuse_address = True
server.server_bind()
server.server_activate()
server.serve_forever()
self.send_header('Access-Control-Allow-Origin', '*')
self.send_header('Access-Control-Allow-Methods', 'GET, OPTIONS')
self.send_header("Access-Control-Allow-Headers",
"X-Requested-With")
self.send_header("Access-Control-Allow-Headers", "Content-Type")
self.end_headers()
return
else:
self.send_error(405) # Method not allowed
return
# def list_directory(self, path): # Patches the list_directory method so that files an be served but directories not listed.
# if True:
# SimpleHTTPRequestHandler.list_directory(self, path) # If listing is allowed, then do what the original method does
# else:
# self.send_error(403) #No permission to list directory
# return None # Effectively, all directory listing is blocked
print "Starting WebServer..."
httpd = ThreadingTCPServer(('', 8080), CustomHandler) # Start the HTTP Server
try:
print "Ready"
httpd.serve_forever()
except KeyboardInterrupt: # Allow Ctrl+C locally to close it gracefully
print "Shutting down..."
httpd.shutdown()
print "Done"
httpd.server_close() # Finally close everything off
raise SystemExit # Ensure explicit termination at this point
row[3],
row[4],
))
# STA ACTION
for row in sta_action_list:
cur.execute(
"INSERT INTO sta_action values(NULL, %s, %s, %s"
", %s, %s, %s)", (
device,
row[1],
row[2],
row[3],
row[4],
row[5],
))
print 'Succ:', str(self.client_address[0]), time.strftime(
'%Y-%m-%d %X', time.localtime())
except:
traceback.print_exc()
print 'MySQL Err:', str(self.client_address[0])
pass
if __name__ == "__main__":
initDB()
server = ThreadingTCPServer(listen_addr, TCPHandler)
server.serve_forever()
class ServerThread(threading.Thread):
def __init__(self):
super(type(self), self).__init__()
self.setDaemon(True)
self.start()
class Handler(StreamRequestHandler):
req_num = 0
lock = threading.Lock()
def get_page_link_list(self, url):
#mc = MyCurl(proxy_ip='192.168.200.253:3128', accept_encoding='gzip, deflate')
#mc = MyCurl(proxy_ip='127.0.0.1:8888', accept_encoding='gzip, deflate')
mc = MyCurl(accept_encoding='gzip, deflate')
pic_regex = re.compile(
r'.+\.(jpg|jpeg|gif|png|bmp|xml|json|swf|zip)$')
_a_list = []
scheme, netloc = urlparse.urlparse(url)[:2]
if scheme not in ('http', 'https'):
return []
try:
count = 0
while True:
h, page = mc.get_page(url)
#对于q=xxx site:domain.xxx之类的搜索 搜索结果如果有100条 频繁的访问domain.xxx 会导致503 尤其是这个网站用了cf之类的
if h['http-code'] == 503:
if count > 2:
return []
else:
time.sleep(3)
count += 1
continue
else:
break
page = gzdecode(page)
content_type = h['content-type']
if 'text/html' not in content_type:
print 'content_type: %s' % content_type
return []
r = re.search(r'charset=(.+)', content_type)
if not r:
charset = 'utf-8'
else:
charset = r.group(1)
page = page.decode(charset, 'ignore')
d = pq(page)
a_list = d('a, iframe')
for l in a_list.items():
if l[0].tag == 'iframe':
href = l.attr('src')
if not href:
continue
else:
href = l.attr('href')
if not href:
continue
if 'javascript' in href:
continue
if pic_regex.search(href.lower()):
continue
href = 'http:' + href if href[:2] == '//' else href
_scheme, _netloc = urlparse.urlparse(href)[:2]
if _scheme and (_scheme not in ('http', 'https')):
continue
if not _scheme and not _netloc:
href = scheme + '://' + netloc + ('' if href[0] == '/'
else '/') + href
_a_list.append(href)
except Exception as e:
logger.error('get_page_link_list %s %s' % (url, str(e)))
logger.exception(e)
else:
pass
# try:
# if not _a_list:
# _uuid = uuid.uuid1().get_hex()
# localtime = time.localtime()
# tmp_name = str(localtime[0]) + str(localtime[1]) + str(localtime[2]) + _uuid[0:8] + _uuid[16:20]
# with open(tmp_name + '.html', 'w+') as f:
# f.write(url + '\n')
# f.write(page)
# with open(tmp_name + '2.html', 'w+') as f2:
# f2.write(url + '\n')
# f2.write(str(d))
# except Exception as e:
# logger.error('if not _a_list %s %s' % (url, str(e)))
# logger.exception(e)
return [(l, url) for l in list(set(_a_list))]
# def func(self, link_url):
# pool = self.server.pool
# link_url = link_url.strip()
# if not link_url:
# logger.debug('google search url null')
# return ''
# list_url = self.get_page_link_list(link_url)
# logger.debug('req_num: %d, link_url: %s, has %d url[begin]' % (self.req_num, link_url, len(list_url)))
# r = reduce(lambda _list, elem: _list.extend(elem) or _list, pool.map(self.get_page_link_list, [l[0] for l in list_url]), list())
# for l in list_url:
# r.append((l[0], link_url))
# logger.debug('req_num: %d, link_url: %s, has %d url[end]' % (self.req_num, link_url, len(list_url)))
# return r
def get_num(self):
self.lock.acquire()
self.__class__.req_num += 1
req_num = self.__class__.req_num
self.lock.release()
return req_num
def handle(self):
pool = self.server.pool
data = self.request.recv(1024)
if not data:
logger.debug('self.request.recv null')
return
try:
data = json.loads(data)
search_url = data['url']
except:
logger.debug('data error')
return
try:
self.req_num = self.get_num()
logger.debug('[begin]req_num: %d, search url: %s' %
(self.req_num, search_url))
except Exception as e:
logger.debug('search url: %s, error %s' % (search_url, str(e)))
logger.exception(e)
try:
#extraInfo = data['extraInfo']
if not search_url:
logger.debug('search_url null')
logger.debug('[end]req_num: %d, search url: %s' %
(self.req_num, search_url))
self.request.send('')
else:
link_url_list = Search().search(search_url)
logger.debug('req_num: %d, google搜索返回的记录数 %d' %
(self.req_num, len(link_url_list)))
link_url_list = [
'http:' + l if l[:2] == '//' else l
for l in link_url_list
]
#link_url_list = [(l, req_num) for l in link_url_list]
_results = []
for l in link_url_list:
list_url = self.get_page_link_list(l)
if config.crawl_level == 2:
result = reduce(
lambda _list, elem: _list.extend(elem) or
_list,
pool.map(self.get_page_link_list,
[l[0] for l in list_url]), list())
for j in list_url:
result.append((j[0], l))
_results.extend(result)
else:
for j in list_url:
_results.append((j[0], l))
d = {}
d['request'] = data
d['response'] = _results
#with open('out.json', 'w+') as f:
for l in link_url_list:
d['response'].append((l, search_url))
logger.debug(
'[end]req_num: %d, search url: %s, 搜索到的记录数 %d' %
(self.req_num, search_url, len(d['response'])))
out_str = json.dumps(d)
self.request.send(out_str)
except Exception as e:
logger.debug('[end]req_num: %d, search url: %s, error %s' %
(self.req_num, search_url, str(e)))
logger.exception(e)
# def send_response(self, res):
# logger.debug('send_response: %d' % len(res))
# try:
# connection = pika.BlockingConnection(pika.ConnectionParameters('localhost'))
# channel = connection.channel()
# channel.queue_declare(queue='google_search')
# channel.basic_publish(exchange='', routing_key='google_search', body=res)
# connection.close()
# except Exception as e:
# logger.error(str(e))
# logger.exception(e)
class DebugThread(threading.Thread):
def __init__(self, pool):
super(type(self), self).__init__()
self.pool = pool
self.setDaemon(True)
self.start()
def run(self):
logger.info('debug thread start!!!')
while True:
logger.info('pool state %d' % self.pool._state)
for l in self.pool._pool:
print l.is_alive(), l.name
print len(self.pool._pool)
time.sleep(5)
def run(self):
logger.info('server thread start!!!')
try:
self.server = ThreadingTCPServer(('127.0.0.1', 50005),
self.Handler)
self.server.pool = ThreadPool(config.thread_num)
#self.DebugThread(self.server.pool)
self.server.serve_forever()
except Exception as e:
logger.error(str(e) + ' 具体栈回溯信息查看crit.log ')
logger.exception(e)
def shut_down(self):
self.server.shutdown()
#!/usr/bin/env python
from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH,
ThreadingTCPServer as TTCP)
from time import ctime
HOST = ''
PORT = 21567
ADDR = (HOST, PORT)
class MyRequestHandler(SRH):
def handle(self):
print '...connected from:', self.client_address
while (True):
self.wfile.write('[%s] %s' % (ctime(), self.rfile.readline()))
tcpServ = TTCP(ADDR, MyRequestHandler)
print 'waiting for connection...'
tcpServ.serve_forever()
