def __init__(self, address, host_key=None, authurl=None, max_children=20, keystone=None): self.log = paramiko.util.get_logger("paramiko") self.log.debug("%s: start server" % self.__class__.__name__) self.fs = ObjectStorageFS(None, None, authurl=authurl, keystone=keystone) # unauthorized self.host_key = host_key self.max_children = max_children ForkingTCPServer.__init__(self, address, ObjectStorageSFTPRequestHandler)
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True): self.logger = logging.getLogger('webkitd.WebKitServer') ForkingTCPServer.__init__(self, server_address, RequestHandlerClass, bind_and_activate) cfg = Configuration() self.logger.info('WebKitServer({0}) versions {1}(Qt:{2}, SIP:{3}, PyQt:{4}) max children={5}'.format( server_address, __version__, QT_VERSION_STR, cfg.sip_version_str, cfg.pyqt_version_str, self.max_children)) def sigCHLD(signum, frame): if signum != signal.SIGCHLD: return while True: try: pid, status = os.waitpid(-1, os.WNOHANG) except os.error: break; if pid <= 0: break try: self.active_children.remove(pid) except ValueError, e: raise ValueError('%s. x=%d and list=%r' % (e.message, pid, self.active_children))
def __init__(self, address, host_key=None, authurl=None, max_children=20): self.log = paramiko.util.get_logger("paramiko") self.log.debug("%s: start server" % self.__class__.__name__) self.fs = CloudFilesFS(None, None, authurl=authurl) # unauthorized self.host_key = host_key self.max_children = max_children ForkingTCPServer.__init__(self, address, CloudFilesSFTPRequestHandler)
def __init__(self, address, host_key=None, authurl=None, max_children=20, keystone=None, no_scp=False, split_size=0, hide_part_dir=False, auth_timeout=None, negotiation_timeout=0): self.log = paramiko.util.get_logger("paramiko") self.log.debug("%s: start server" % self.__class__.__name__) self.fs = ObjectStorageFS(None, None, authurl=authurl, keystone=keystone, hide_part_dir=hide_part_dir) # unauthorized self.host_key = host_key self.max_children = max_children self.no_scp = no_scp ObjectStorageSFTPRequestHandler.auth_timeout = auth_timeout ObjectStorageSFTPRequestHandler.negotiation_timeout = negotiation_timeout ForkingTCPServer.__init__(self, address, ObjectStorageSFTPRequestHandler) ObjectStorageFD.split_size = split_size
def __init__(self, server_address, handler_class, config): ForkingTCPServer.__init__(self, server_address, handler_class) if 'consumers' not in config: raise ValueError('Configuration does not provide any consumer') self.config = config if 'server_string' in self.config: self.server_string = self.config['server_string'] self.auditlog = log.auditlog
def __init__(self, server_address, RequestHandlerClass, btodir, u, r, btoblas='./bin/btoblas'): BTO_Server.__init__(self, btodir, u, r, btoblas) ForkingTCPServer.__init__(self, server_address, RequestHandlerClass)
def process_request(self, request, client_address): # Only the parent (server) will return from this ForkingTCPServer.process_request(self, request, client_address) # Check if we need to shutdown now self.max_connections -= 1 stdout_flush('Client connected! {} remaining\n'.format(self.max_connections)) if self.max_connections <= 0: stdout_flush('No more connections allowed, shutting down!\n') thread.start_new_thread(self.shutdown, ())
def __init__(self, addr, requestHandler, logRequests, allow_none, encoding, bind_and_activate): self.logRequests = logRequests SimpleXMLRPCDispatcher.__init__(self, allow_none, encoding) ForkingTCPServer.__init__(self, addr, requestHandler, bind_and_activate) if fcntl is not None and hasattr(fcntl, 'FD_COLEXEC'): flags = fcntl.fcntl(self.fileno(), fcntl.F_GETFD) flags |= fcntl.FD_COLEXEC fcntl.fcntl(self.fileno(), fcntl.F_SETFD, flags)
def process_request(self, request, client_address): # Only the parent (server) will return from this ForkingTCPServer.process_request(self, request, client_address) # Check if we need to shutdown now self.max_connections -= 1 stdout_flush('Client connected! {} remaining\n'.format( self.max_connections)) if self.max_connections <= 0: stdout_flush('No more connections allowed, shutting down!\n') thread.start_new_thread(self.shutdown, ())
def process_request(self, request, client_address): self.logger.info('new connect') try: ForkingTCPServer.process_request(self, request, client_address) except OSError as e: if e.errno == errno.EAGAIN: self.logger.warning(str(e)) request.sendall(json.dumps({'error': unicode(e.strerror), 'fatal': True, 'disconnect': True }, ensure_ascii=False, encoding=u'UTF-8') + u'\n') request.close() else: raise
def __init__(self, address, host_key=None, authurl=None, max_children=20, keystone=None, no_scp=False, split_size=0, hide_part_dir=False, auth_timeout=None, negotiation_timeout=0, keepalive=0, insecure=False, secopts=None, server_ident=None, storage_policy=None, proxy_protocol=None, rsync_bin=None, large_object_container_suffix=None, fail2ban=None): self.log = paramiko.util.get_logger("paramiko") self.log.debug("%s: start server" % self.__class__.__name__) self.fs = ObjectStorageFS( None, None, authurl=authurl, keystone=keystone, hide_part_dir=hide_part_dir, insecure=insecure, storage_policy=storage_policy) # unauthorized self.host_key = host_key self.max_children = max_children self.no_scp = no_scp self.rsync_bin = rsync_bin self.split_size = split_size self.fail2ban = fail2ban if fail2ban: self.f2b = Fail2ban(fail2ban) ObjectStorageSFTPRequestHandler.auth_timeout = auth_timeout ObjectStorageSFTPRequestHandler.negotiation_timeout = negotiation_timeout ObjectStorageSFTPRequestHandler.keepalive = keepalive ObjectStorageSFTPRequestHandler.secopts = secopts ObjectStorageSFTPRequestHandler.server_ident = server_ident ObjectStorageSFTPRequestHandler.proxy_protocol = proxy_protocol ForkingTCPServer.__init__(self, address, ObjectStorageSFTPRequestHandler) ObjectStorageFD.split_size = split_size ObjectStorageFD.storage_policy = storage_policy ObjectStorageFD.large_object_container_suffix = large_object_container_suffix
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--port', required=True, type=int, help='TCP port used for incoming connections') parser.add_argument('-d', '--directory', required=True, help='Directory containing the challenge binaries') parser.add_argument('challenge_binaries', nargs='+', help='List of challenge binaries to run on the server') args = parser.parse_args(sys.argv[1:]) # Generate the full paths to all binaries in the request handler cdir = os.path.abspath(args.directory) for chal in args.challenge_binaries: ChallengeHandler.challenges.append(os.path.join(cdir, chal)) # Start the challenge server srv = ForkingTCPServer(('localhost', args.port), ChallengeHandler) try: srv.serve_forever() except KeyboardInterrupt: pass srv.server_close()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--port', required=True, type=int, help='TCP port used for incoming connections') parser.add_argument('-d', '--directory', required=True, help='Directory containing the challenge binaries') parser.add_argument( '-t', '--timeout', type=int, help= 'The time in seconds that challenges are allowed to run before quitting' ' (default is {} seconds)'.format(ChallengeHandler.chal_timeout)) parser.add_argument('challenge_binaries', nargs='+', help='List of challenge binaries to run on the server') args = parser.parse_args(sys.argv[1:]) # Generate the full paths to all binaries in the request handler cdir = os.path.abspath(args.directory) for chal in args.challenge_binaries: ChallengeHandler.challenges.append(os.path.join(cdir, chal)) # Set challenge timeout if args.timeout and args.timeout > 0: ChallengeHandler.chal_timeout = args.timeout # Start the challenge server ForkingTCPServer.allow_reuse_address = True srv = ForkingTCPServer(('localhost', args.port), ChallengeHandler) try: print('Starting server at localhost:{}'.format(args.port)) srv.serve_forever() except KeyboardInterrupt: pass finally: srv.server_close()
#!/usr/bin/python from SocketServer import BaseRequestHandler, TCPServer from SocketServer import ForkingTCPServer, ThreadingTCPServer class EchoHandler(BaseRequestHandler): def handle(self): print "got connection from", self.client_address while True: data = self.request.recv(4096) if data: sent = self.request.send(data) # sendall? else: print "disconnect", self.client_address self.request.close() break if __name__ == "__main__": listen_address = ("0.0.0.0", 2007) server = ForkingTCPServer(listen_address, EchoHandler) server.serve_forever()
def __init__(self, server_address, handler, max_connections): self.max_connections = max_connections ForkingTCPServer.__init__(self, server_address, handler)
def __init__(self, server_address, RequestHandlerClass, btodir, u,r, btoblas='./bin/btoblas'): BTO_Server.__init__(self, btodir, u,r,btoblas) ForkingTCPServer.__init__(self,server_address, RequestHandlerClass)
from SocketServer import BaseRequestHandler from SocketServer import ForkingTCPServer class EchoHandler(BaseRequestHandler): def handle(self): print "got connenction from", self.client_address while True: data = self.request.recv(4096) if data: sent = self.request.send(data) else: print "disconnect", self.client_address self.request.close() break if __name__ == "__main__": listen_address = ("0.0.0.0", 2007) server = ForkingTCPServer(listen_address, EchoHandler) server.serve_forever()
make_torrent() blocking ''' elif data == "download": print(" server download") ''' libtorrent add param .... add_handle() no block ''' elif data == "seeding": ''' start seeding .. no block ''' print("start seeding") print("recv from client:", data) self.request.sendall(data.upper()) except Exception as e: print(e) break if __name__ == "__main__": TCPServer.allow_reuse_address = True # tcpSerSock = ThreadingTCPServer(ADDR, MsgTransfer) tcpSerSock = ForkingTCPServer(ADDR, MsgTransfer) print 'waiting for connection...' tcpSerSock.serve_forever()
# mail: [email protected] ######################################################################### #!/usr/bin/env python from SocketServer import (TCPServer as TCP,StreamRequestHandler as SRH) from SocketServer import ForkingTCPServer from time import ctime HOST = '127.0.0.1' PORT = 6666 ADDR = (HOST,PORT) class MyRequsetHandler(SRH): def handle(self): while True: #print '...connected from:',self.client_address theline = self.rfile.readline() res = theline.strip() if res != 'quit': if theline: self.wfile.write('[%s] %s' % (ctime(),theline)) else: break tcpServ = ForkingTCPServer(ADDR,MyRequsetHandler) print 'waiting for connection...' tcpServ.serve_forever()
# -*- coding: UTF-8 -*- ''' /*********************************************************** FileName: listing14-4.ForkingTCPServer2.py Desc: 原生ForkingTCPServer Author: Jie Yin Email: [email protected] HomePage: https://github.com/mumingv Version: 0.0.1 LastChange: 2017-05-30 12:55:07 History: ***********************************************************/ ''' from SocketServer import ForkingTCPServer, StreamRequestHandler import time class Handler(StreamRequestHandler): def handle(self): addr = self.request.getpeername() print 'Got connection from', addr # 延迟5秒 time.sleep(5) self.wfile.write('Thank you for connecting') print 'Send data to', addr, 'ok' # Server是一个ForkingTCPServer,所以对于每个客户端请求都会自动创建一个Handler实例 # ForkingTCPServer是异步的,对于每个请求,服务端都会fork一个子进程来处理客户端请求,所以同时会有多个Handler实例在跑 server = ForkingTCPServer(('', 1234), Handler) server.serve_forever()
break if __name__ == "__main__": #telnet 127.0.0.1 9999 host = "" #主机名,可以是ip,像localhost的主机名,或"" port = 12580 #端口 addr = (host, port) flag = raw_input("请选择运行模式:") if flag == '1': #socket server 1:TCPServer+BaseRequestHandler,单客户端连接,单字符接收 #构造TCPServer对象 server = TCPServer(addr, MyBaseRequestHandlerr) #启动服务监听 server.serve_forever() elif flag == '2': #socket server 2:单客户端连接,多字符接收 server = TCPServer(addr, MyStreamRequestHandlerr) server.serve_forever() elif flag == '3': #socket server 3:用多线程实现多客户端连接,多字符接收 server = ThreadingTCPServer(addr, MyStreamRequestHandlerr) server.serve_forever() elif flag == '4': #socket server 4:用多进程实现多客户端连接,多字符接收 server = ForkingTCPServer(addr, MyStreamRequestHandlerr) server.serve_forever() else: print "请输入1-4序号:"
return True def do_GET(self): """ Process the HTTP GET Request """ logging.debug('Processing %s', self.path) if not self.do_netlist(): self.copyfile(urllib.urlopen(self.path, proxies={}), self.wfile) if __name__ == '__main__': parser = OptionParser() parser.add_option('-p', '--port', type='int', help='Listening port number', default=8080) parser.add_option('-v', '--verbose', type='choice', action='store', choices=[k.lower() for k in logging._levelNames.keys() if isinstance(k, basestring)], default=logging.getLevelName(logging.INFO).lower(), help='Set the verbosity of the log level') options, args = parser.parse_args() logging.basicConfig( level=logging.getLevelName(options.verbose.upper()), handlers=[logging.StreamHandler()]) httpd = ForkingTCPServer(('', options.port), Proxy) logging.info('Listening at port: %d', options.port) httpd.serve_forever()
def main(): parser = argparse.ArgumentParser() parser.add_argument('-p', '--port', required=True, type=int, help='TCP port used for incoming connections') parser.add_argument('-d', '--directory', required=True, help='Directory containing the challenge binaries') parser.add_argument( '-m', '--max-connections', required=False, type=int, default=0, help= 'The number of connections this server will handle before shutting down' ) parser.add_argument( '-t', '--timeout', type=int, help= 'The time in seconds that challenges are allowed to run before quitting' ' (default is {} seconds)'.format(ChallengeHandler.chal_timeout)) parser.add_argument( '--use-signals', action='store_true', help= 'Use signals to coordinate starting the challenges with another process' ) parser.add_argument('challenge_binaries', nargs='+', help='List of challenge binaries to run on the server') args = parser.parse_args(sys.argv[1:]) # Generate the full paths to all binaries in the request handler cdir = os.path.abspath(args.directory) for chal in args.challenge_binaries: ChallengeHandler.challenges.append(os.path.join(cdir, chal)) # Set challenge timeout if args.timeout and args.timeout > 0: ChallengeHandler.chal_timeout = args.timeout # Set how the handler will start challenges ChallengeHandler.use_signals = args.use_signals # Start the challenge server ForkingTCPServer.allow_reuse_address = True if args.max_connections > 0: srv = LimitedForkServer(('localhost', args.port), ChallengeHandler, args.max_connections) else: srv = ForkingTCPServer(('localhost', args.port), ChallengeHandler) try: stdout_flush('Starting server at localhost:{}\n'.format(args.port)) srv.serve_forever() except KeyboardInterrupt: pass finally: srv.server_close()
def test_echoserver_fork(): server = ForkingTCPServer(listen_address, EchoHandlerFork) server.serve_forever()
def __init__( self, address, host_key=None, authurl=None, max_children=20, keystone=None, no_scp=False, split_size=0, hide_part_dir=False, auth_timeout=None, negotiation_timeout=0, keepalive=0, insecure=False, secopts=None, server_ident=None, ): self.log = paramiko.util.get_logger("paramiko") self.log.debug("%s: start server" % self.__class__.__name__) self.fs = ObjectStorageFS( None, None, authurl=authurl, keystone=keystone, hide_part_dir=hide_part_dir, insecure=insecure ) # unauthorized self.host_key = host_key self.max_children = max_children self.no_scp = no_scp ObjectStorageSFTPRequestHandler.auth_timeout = auth_timeout ObjectStorageSFTPRequestHandler.negotiation_timeout = negotiation_timeout ObjectStorageSFTPRequestHandler.keepalive = keepalive ObjectStorageSFTPRequestHandler.secopts = secopts ObjectStorageSFTPRequestHandler.server_ident = server_ident ForkingTCPServer.__init__(self, address, ObjectStorageSFTPRequestHandler) ObjectStorageFD.split_size = split_size