def __init__(self,
module='Main',
ip='127.0.0.1',
port=None,
socket_file=None,
pid_file=None,
pcgi_file=None,
resolver=None,
logger_object=None):
self.ip = ip
asyncore.dispatcher.__init__(self)
self.count = 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)
# get configuration
self.module = module
self.port = port
self.pid_file = pid_file
self.socket_file = socket_file
if pcgi_file is not None:
self.read_info(pcgi_file)
# write pid file
try:
f = open(self.pid_file, 'w')
f.write(str(os.getpid()))
f.close()
except IOError:
self.log_info("Cannot write PID file.", 'error')
# setup sockets
if self.port:
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((self.ip, self.port))
self.log_info('PCGI Server started at %s\n'
'\tInet socket port: %s' %
(time.ctime(time.time()), self.port))
else:
try:
os.unlink(self.socket_file)
except os.error:
pass
self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(self.socket_file)
try:
os.chmod(self.socket_file, 0777)
except os.error:
pass
self.log_info('PCGI Server started at %s\n'
'\tUnix socket: %s' %
(time.ctime(time.time()), self.socket_file))
self.listen(256)
def __init__(self, address, port):
rs = None # resolver.caching_resolver ('127.0.0.1')
lg = logger.file_logger (sys.stdout)
self.hs = http_server.http_server (address, port, rs, lg)
if address=='':
address='localhost'
print "Started server at: http://%s:%s/" % (address, port)
sys.stdout.flush()
def __init__(self,
module='Main',
ip='127.0.0.1',
port=None,
socket_file=None,
resolver=None,
logger_object=None):
self.ip = ip
self.count=counter()
asyncore.dispatcher.__init__(self)
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)
# get configuration
self.module = module
self.port = port
self.socket_file = socket_file
# setup sockets
if self.port:
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((self.ip, self.port))
else:
try:
os.unlink(self.socket_file)
except os.error:
pass
self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(self.socket_file)
try:
os.chmod(self.socket_file,0777)
except os.error:
pass
self.listen(256)
self.log_info('FastCGI Server (V%s) started at %s\n'
'\tIP : %s\n'
'\tPort : %s\n'
'\tSocket path : %s\n'
% ('1.0', time.ctime(time.time()), self.ip,
self.port, self.socket_file))
def __init__(self,
module='Main',
ip='127.0.0.1',
port=None,
socket_file=None,
resolver=None,
logger_object=None):
self.ip = ip
self.count=counter()
asyncore.dispatcher.__init__(self)
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)
# get configuration
self.module = module
self.port = port
self.socket_file = socket_file
# setup sockets
if self.port:
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((self.ip, self.port))
else:
try:
os.unlink(self.socket_file)
except os.error:
pass
self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(self.socket_file)
try:
os.chmod(self.socket_file,0777)
except os.error:
pass
self.listen(256)
self.log_info('FastCGI Server (V%s) started at %s\n'
'\tIP : %s\n'
'\tPort : %s\n'
'\tSocket path : %s\n'
% (__version__, time.ctime(time.time()), self.ip,
self.port, self.socket_file))
def __init__(self, context, ip=None, port=143, logger=None, stunnel_pid=None):
if not ip:
self.ip = "0.0.0.0"
else:
self.ip = ip
self.port = port
self.mailcontext = context
self.logger = logger or unresolving_logger(file_logger(sys.stderr))
self.stunnel_pid = stunnel_pid
asyncore.dispatcher.__init__(self)
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.handlers = []
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()
info = (
"UpLib IMAP (V4r1) started at %s"
"\n\tHostname: %s"
"\n\tPort: %d"
"\n" % (time.ctime(time.time()), self.server_name, port)
)
# self.log_info (info, 'info')
self.mailcontext.note(info)
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 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 __init__(self, authz, ssl_ctx, host=None, ip='', port=21, resolver=None, log_obj=None):
"""Initialise the server."""
self.ssl_ctx = ssl_ctx
self.ip = ip
self.port = port
self.authorizer = authz
if host is None:
self.hostname = socket.gethostname()
else:
self.hostname = host
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 log_obj is None:
log_obj = sys.stdout
if resolver:
self.logger = logger.resolving_logger(resolver, log_obj)
else:
self.logger = logger.unresolving_logger(logger.file_logger(sys.stdout))
l = 'M2Crypto (Medusa) FTP/TLS server started at %s\n\tAuthz: %s\n\tHostname: %s\n\tPort: %d'
self.log_info(l % (time.ctime(time.time()), repr(self.authorizer), self.hostname, self.port))
# sometimes we get a None if EWOULDBLOCK is raised, so try again
note(4, "None result on server accept")
continue
else:
return result
############################################################
###
### create the repo and run initializers
###
############################################################
# we use Medusa's logger
if logfilename:
lgr = logger.file_logger (logfilename)
else:
# This will log to an overhead subdirectory of the repository
logfile_directory = os.path.join(directory, "overhead")
if not os.path.exists(logfile_directory):
os.makedirs(logfile_directory)
lgr = thread_safe_rotating_file_logger (os.path.join(logfile_directory, "angel.log"), "weekly", 10*1024*1024, true)
# make sure anything written with note() will go to the logfile
set_note_sink(lgr)
repo, use_ssl, ip_addr, conf = Repository.build_world(directory, portno, logfilename)
note(0, "repo is %s, use_ssl is %s, ip_addr is %s, conf is %s",
repo, use_ssl, ip_addr, conf)
PUBLISHING_ROOT='/home/medusa'
class sample_input_collector:
def __init__ (self, request, length):
self.request = request
self.length = length
def collect_incoming_data (self, data):
print 'data from %s: <%s>' % (self.request, repr(data))
class post_script_handler (script_handler.script_handler):
def handle_request (self, request):
if request.command == 'post':
ic = sample_input_collector (request)
request.collector = ic
print request.header
return script_handler.script_handler.handle_request (self, request)
lg = logger.file_logger (sys.stdout)
fs = filesys.os_filesystem (PUBLISHING_ROOT)
dh = default_handler.default_handler (fs)
ph = post_script_handler (fs)
hs = http_server.http_server ('', 8081, logger_object = lg)
hs.install_handler (dh)
hs.install_handler (ph)
asyncore.loop()
def __init__ (self,
module='Main',
ip='127.0.0.1',
port=None,
socket_file=None,
pid_file=None,
pcgi_file=None,
resolver=None,
logger_object=None):
self.ip = ip
asyncore.dispatcher.__init__(self)
self.count=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)
# get configuration
self.module=module
self.port=port
self.pid_file=pid_file
self.socket_file=socket_file
if pcgi_file is not None:
self.read_info(pcgi_file)
# write pid file
try:
f = open(self.pid_file, 'w')
f.write(str(os.getpid()))
f.close()
except IOError:
self.log_info("Cannot write PID file.", 'error')
# setup sockets
if self.port:
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind((self.ip, self.port))
self.log_info(
'PCGI Server started at %s\n'
'\tInet socket port: %s' % (time.ctime(time.time()), self.port)
)
else:
try:
os.unlink(self.socket_file)
except os.error:
pass
self.create_socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.set_reuse_addr()
self.bind(self.socket_file)
try:
os.chmod(self.socket_file,0777)
except os.error:
pass
self.log_info(
'PCGI Server started at %s\n'
'\tUnix socket: %s' % (time.ctime(time.time()), self.socket_file)
)
self.listen(256)
# 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)