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):
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, 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 __init__(self, server_address, handler, max_connections):
self.max_connections = max_connections
ForkingTCPServer.__init__(self, server_address, handler)
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
