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,
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))
def __init__ (self, ip, port, resolver=None, logger_object=None, certfile=None, ssl_version=None):
self.certfile = certfile
# we set this here, because http_server writes to it before binding it!
self.logger = logger.unresolving_logger(logger_object)
# note(0, "http_server logging to %s (around %s)", self.logger, logger_object)
http_server.http_server.__init__(self, ip, port, resolver=resolver, logger_object=logger_object)
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 manipulate_server_internal (repo, params, response=None, ipaddr=None, lgr=None):
# regular UpLib action
conf = params.get("configurator")
if not conf:
conf = configurator()
imap_ssl_port = conf.get_int("imap-server-ssl-port", -1)
imap_localhost_port = conf.get_int("imap-server-localhost-port", 8143)
stunnel = conf.get("stunnel")
expunge_deletes_docs = conf.get_bool("imap-expunge-deletes-documents", False)
global CHECKPOINT_PERIOD
CHECKPOINT_PERIOD = conf.get_int("imap-server-checkpoint-interval", 600)
allow_anonymous_readers = ((not repo.has_password) and
conf.get_bool("imap-server-allow-anonymous-readers", True))
use_for_email = conf.get_bool("imap-server-use-for-email", False)
imap_dir = os.path.join(repo.overhead_folder(), "imap")
if not os.path.isdir(imap_dir):
os.mkdir(imap_dir)
stunnel_pid_filepath = os.path.join(imap_dir, "stunnel.pid")
if os.path.exists(stunnel_pid_filepath):
stunnel_pid = int(open(stunnel_pid_filepath, 'r').read().strip())
else:
stunnel_pid = None
# we cache the reference to the existing server in another
# module so that we can reload this one with impunity
current_server = emailParser.__dict__.get("IMAP_SERVER")
note("current server is %s", current_server)
action = params.get('action')
newcontext = params.get('newcontext', False)
if response:
fp = response.open()
else:
fp = StringIO()
fp.write('<body bgcolor="%s">\n' % STANDARD_BACKGROUND_COLOR)
if current_server:
s = current_server.status()
m = s.more()
while m:
fp.write(m)
m = s.more()
fp.write('\n<hr>\n')
else:
fp.write('<h2>UpLib IMAP Server control panel</h2>\n')
current_context = None
if current_server and ((action == 'Stop') or (action == 'Restart')):
if stunnel_pid:
try:
os.kill(stunnel_pid, signal.SIGKILL)
time.sleep(4)
except:
pass
stunnel_pid = None
current_context = current_server.mailcontext
current_server.close()
current_server = None
del emailParser.__dict__["IMAP_SERVER"]
fp.write("<p>Closed current server.\n")
if os.path.exists(stunnel_pid_filepath):
os.unlink(stunnel_pid_filepath)
if (action == 'Start') or (action == 'Restart'):
cert_filepath = os.path.join(repo.overhead_folder(), repo.certfilename())
try:
port = params.get("port")
if port:
port = int(port)
else:
port = imap_localhost_port
if stunnel and ((not ssl) or (imap_ssl_port > 0)):
# start stunnel
stunnel_conf_filepath = os.path.join(imap_dir, "stunnel.conf")
f = open(stunnel_conf_filepath, 'w')
f.write("debug = 7\n\ncert = %s\noutput = %s\npid = %s\n\n[imapuplib]\naccept = %s\nconnect = 127.0.0.1:%s\n" %
(cert_filepath, os.path.join(imap_dir, "stunnel.log"), stunnel_pid_filepath,
str(imap_ssl_port), str(port)))
f.close()
status, tsignal, output = subproc("%s %s" % (stunnel, stunnel_conf_filepath))
note("status from '%s %s' (on %s) is %s, output is <%s>", stunnel, stunnel_conf_filepath, imap_ssl_port, status, output)
if status != 0:
raise RuntimeError("Can't start stunnel with '%s %s'; status is %s, output is %s" % (stunnel, stunnel_conf_filepath, status, output))
stunnel_pid = int(open(stunnel_pid_filepath, 'r').read().strip())
note("stunnel_pid is %s", stunnel_pid)
else:
stunnel_pid = None
if newcontext or (not current_context):
current_context = uplib_mailcontext(repo,
expunge_deletes_docs=expunge_deletes_docs,
allow_readers=allow_anonymous_readers,
use_for_email=use_for_email,
ip=get_fqdn(),
server_certificate_file=cert_filepath)
if current_context.inbox:
current_context.inbox.rescan()
if stunnel_pid is not None:
ipaddr = '127.0.0.1'
else:
ipaddr = '0.0.0.0'
if not lgr:
lgr = logger.rotating_file_logger (os.path.join(imap_dir, "imap.log"), "weekly", None, True)
lgr = logger.unresolving_logger(lgr)
imaps = imap_server (current_context, ipaddr, port, logger=lgr, stunnel_pid=stunnel_pid)
emailParser.__dict__["IMAP_SERVER"] = imaps
current_server = imaps
hooked = emailParser.__dict__.get("IMAP_SERVER_SHUTDOWN_HOOK")
if not hooked:
repo.add_shutdown_hook(lambda x=repo: shutdown_server(x))
emailParser.__dict__["IMAP_SERVER_SHUTDOWN_HOOK"] = True
if stunnel_pid:
fp.write("<p>Started new IMAP4 server for %s on ports %s/%s."
% (repr(repo), str(imap_ssl_port), str(port)))
else:
fp.write("<p>Started new IMAP4 server for %s on port %s."
% (repr(repo), str(port)))
if current_context.inbox:
fp.write("<p>Inbox: %d messages, %d recent, %d unseen."
% (len(current_context.inbox.msgs),
len(current_context.inbox.recent()),
current_context.inbox.min_unseen()))
except:
type, value, tb = sys.exc_info()
s = string.join(traceback.format_exception(type, value, tb))
note("Can't establish IMAP server: exception: " + s)
fp.write(s)
fp.write('<form method=GET action="/action/IMAPServer/manipulate_server">\n')
fp.write('<input type=submit name=action value="Start" %s>\n' % ((current_server and "disabled") or ""))
fp.write('<input type=submit name=action value="Stop" %s>\n' % (((current_server == None) and "disabled") or ""))
fp.write('<input type=submit name=action value="Restart" %s>\n' % (((current_server == None) and "disabled") or ""))
fp.write('<input type=checkbox name="newcontext" %s> Use fresh mail context\n' % (newcontext and "checked") or "")
fp.write('</form>\n')
fp.write('</body>\n')
