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 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()