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)