def __init__ (self, ip, port, resolver=None, logger_object=None):
self.ip = ip
self.port = port
asyncore.dispatcher.__init__ (self)
self.create_socket (socket.AF_INET, socket.SOCK_STREAM)
self.handlers = []
if not logger_object:
logger_object = logger.file_logger (sys.stdout)
self.set_reuse_addr()
self.bind ((ip, port))
# lower this to 5 if your OS complains
self.listen (1024)
host, port = self.socket.getsockname()
if not ip:
self.log_info('Computing default hostname', 'warning')
ip = socket.gethostbyname (socket.gethostname())
try:
self.server_name = socket.gethostbyaddr (ip)[0]
except socket.error:
self.log_info('Cannot do reverse lookup', 'warning')
self.server_name = ip # use the IP address as the "hostname"
self.server_port = port
self.total_clients = counter()
self.total_requests = counter()
self.exceptions = counter()
self.bytes_out = counter()
self.bytes_in = counter()
if not logger_object:
logger_object = logger.file_logger (sys.stdout)
if resolver:
self.logger = logger.resolving_logger (resolver, logger_object)
else:
self.logger = logger.unresolving_logger (logger_object)
self.log_info (
'Medusa (V%s) started at %s'
'\n\tHostname: %s'
'\n\tPort:%d'
'\n' % (
VERSION_STRING,
time.ctime(time.time()),
self.server_name,
port,
)
)
def __init__ (
self,
authorizer,
hostname =None,
ip ='',
port =21,
resolver =None,
logger_object=logger.file_logger (sys.stdout)
):
self.ip = ip
self.port = port
self.authorizer = authorizer
if hostname is None:
self.hostname = socket.gethostname()
else:
self.hostname = hostname
# statistics
self.total_sessions = counter()
self.closed_sessions = counter()
self.total_files_out = counter()
self.total_files_in = counter()
self.total_bytes_out = counter()
self.total_bytes_in = counter()
self.total_exceptions = counter()
#
asyncore.dispatcher.__init__ (self)
self.create_socket (socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind ((self.ip, self.port))
self.listen (5)
if not logger_object:
logger_object = sys.stdout
if resolver:
self.logger = logger.resolving_logger (resolver, logger_object)
else:
self.logger = logger.unresolving_logger (logger_object)
self.log_info('FTP server started at %s\n\tAuthorizer:%s\n\tHostname: %s\n\tPort: %d' % (
time.ctime(time.time()),
repr (self.authorizer),
self.hostname,
self.port)
)
def prebind(self, sock, logger_object):
""" Override __init__ to do logger setup earlier so it can
go to our logger object instead of stdout """
from supervisor.medusa import logger
if not logger_object:
logger_object = logger.file_logger(sys.stdout)
logger_object = logger.unresolving_logger(logger_object)
self.logger = logger_object
self.set_socket(sock)
self.handlers = []
sock.setblocking(0)
self.set_reuse_addr()
def prebind(self, sock, logger_object):
""" Override __init__ to do logger setup earlier so it can
go to our logger object instead of stdout """
from supervisor.medusa import logger
if not logger_object:
logger_object = logger.file_logger(sys.stdout)
logger_object = logger.unresolving_logger(logger_object)
self.logger = logger_object
asyncore.dispatcher.__init__ (self)
self.set_socket(sock)
self.handlers = []
sock.setblocking(0)
self.set_reuse_addr()
def prebind(self, sock, logger_object):
""" Override __init__ to do logger setup earlier so it can
go to our logger object instead of stdout """
from supervisor.medusa import logger
if not logger_object:
logger_object = logger.file_logger(sys.stdout)
logger_object = logger.unresolving_logger(logger_object)
self.logger = logger_object
asyncore.dispatcher.__init__(self)
# set_socket 设置了set_socket
self.set_socket(sock)
# print(asyncore.socket_map)
self.handlers = []
# 为非阻塞
sock.setblocking(0)
# print(asyncore.socket_map)
self.set_reuse_addr()
# The resolver is used to resolve incoming IP address (for logging),
# and also to resolve hostnames for HTTP Proxy requests. I recommend
# using a nameserver running on the local machine, but you can also
# use a remote nameserver.
rs = resolver.caching_resolver ('127.0.0.1')
# ===========================================================================
# Logging.
# ===========================================================================
# There are several types of logging objects. Multiple loggers may be combined,
# See 'logger.py' for more details.
# This will log to stdout:
lg = logger.file_logger (sys.stdout)
# This will log to syslog:
#lg = logger.syslog_logger ('/dev/log')
# This will wrap the logger so that it will
# 1) keep track of the last 500 entries
# 2) display an entry in the status report with a hyperlink
# to view these log entries.
#
# If you decide to comment this out, be sure to remove the
# logger object from the list of status objects below.
#
lg = status_handler.logger_for_status (lg)
else:
return None, None, None
if __name__ == '__main__':
if len(sys.argv) < 2:
print('usage: %s <root> <port>' % (sys.argv[0]))
else:
import supervisor.medusa.monitor as monitor
import supervisor.medusa.filesys as filesys
import supervisor.medusa.default_handler as default_handler
import supervisor.medusa.ftp_server as ftp_server
import supervisor.medusa.chat_server as chat_server
import supervisor.medusa.resolver as resolver
rs = resolver.caching_resolver('127.0.0.1')
lg = logger.file_logger(sys.stdout)
ms = monitor.secure_monitor_server('fnord', '127.0.0.1', 9999)
fs = filesys.os_filesystem(sys.argv[1])
dh = default_handler.default_handler(fs)
hs = http_server('', int(sys.argv[2]), rs, lg)
hs.install_handler(dh)
ftp = ftp_server.ftp_server(ftp_server.dummy_authorizer(sys.argv[1]),
port=8021,
resolver=rs,
logger_object=lg)
cs = chat_server.chat_server('', 7777)
if '-p' in sys.argv:
def profile_loop():
try:
asyncore.loop()
