Attachment 15786 Details for Bug 78305 – Test case

Test case

X.java (text/plain), 43.08 KB, created by Olivier Thomann

on 2004-11-10 17:33:20 EST

(hide)

Description:

Filename:

MIME Type:

Creator: Olivier Thomann

Created: 2004-11-10 17:33:20 EST

Size: 43.08 KB

patch

obsolete

># -*- coding: iso-8859-1 -*-
>"""
>    MoinMoin - Data associated with a single Request
>
>    @copyright: 2001-2003 by Jürgen Hermann <jh@web.de>
>    @copyright: 2003-2004 by Thomas Waldmann
>    @license: GNU GPL, see COPYING for details.
>"""
>
>import os, time, sys
>from MoinMoin import config, wikiutil
>from MoinMoin.util import MoinMoinNoFooter
>
>#############################################################################
>### Timing
>#############################################################################
>
>class Clock:
>    """ Helper class for code profiling
>        we do not use time.clock() as this does not work across threads
>    """
>
>    def __init__(self):
>        self.timings = {'total': time.time()}
>
>    def start(self, timer):
>        self.timings[timer] = time.time() - self.timings.get(timer, 0)
>
>    def stop(self, timer):
>        self.timings[timer] = time.time() - self.timings[timer]
>
>    def value(self, timer):
>        return "%.3f" % (self.timings[timer],)
>
>    def dump(self):
>        outlist = []
>        for timing in self.timings.items():
>            outlist.append("%s = %.3fs" % timing)
>        return outlist
>
>
>#############################################################################
>### Request Data
>#############################################################################
>class RequestBase:
>    """ A collection for all data associated with ONE request. """
>
>    # Header set to force misbehaved proxies and browsers to keep their
>    # hands off a page
>    # Details: http://support.microsoft.com/support/kb/articles/Q234/0/67.ASP
>    nocache = [
>        "Pragma: no-cache",
>        "Cache-Control: no-cache",
>        "Expires: -1",
>    ]
>
>    def __init__(self, properties={}):
>        self.writestack = []
>        self.clock = Clock()
>        # order is important here!
>        from MoinMoin import user
>        self.user = user.User(self)
>        self.dicts = self.initdicts()
>
>        from MoinMoin import i18n
>
>        if config.theme_force:
>            theme_name = config.theme_default
>        else:
>            theme_name = self.user.theme_name
>        try:
>            self.theme = wikiutil.importPlugin('theme', theme_name)(self)
>        except TypeError:
>            theme_name = config.theme_default
>            self.theme = wikiutil.importPlugin('theme', theme_name)(self)
>
>        self.args = None
>        self.form = None
>        self.logger = None
>        self.pragma = {}
>        self.mode_getpagelinks = 0
>        self.no_closing_html_code = 0
>
>        self.sent_headers = 0
>        self.user_headers = []
>
>        self.__dict__.update(properties)
>
>        self.i18n = i18n
>        self.lang = i18n.requestLanguage(self) 
>        self.getText = lambda text, i18n=self.i18n, request=self, lang=self.lang: i18n.getText(text, request, lang)
>
>        # XXX Removed call to i18n.adaptcharset()
>  
>        self.opened_logs = 0 # XXX for what do we need that???
>
>        self.reset()
>
>    def _setup_vars_from_std_env(self, env):
>        """ Sets the common Request members by parsing a standard
>            HTTPD environment (as created as environment by most common
>            webservers. To be used by derived classes.
>
>            @param env: the environment to use
>        """
>        self.http_accept_language = env.get('HTTP_ACCEPT_LANGUAGE', 'en')
>        self.server_name = env.get('SERVER_NAME', 'localhost')
>        self.server_port = env.get('SERVER_PORT', '80')
>        self.http_host = env.get('HTTP_HOST','localhost')
>        self.http_referer = env.get('HTTP_REFERER', '')
>        self.saved_cookie = env.get('HTTP_COOKIE', '')
>        self.script_name = env.get('SCRIPT_NAME', '')
>        self.path_info = env.get('PATH_INFO', '')
>        self.query_string = env.get('QUERY_STRING', '')
>        self.request_method = env.get('REQUEST_METHOD', None)
>        self.remote_addr = env.get('REMOTE_ADDR', '')
>        self.http_user_agent = env.get('HTTP_USER_AGENT', '')
>        self.is_ssl = env.get('SSL_PROTOCOL', '') != '' \
>            or env.get('SSL_PROTOCOL_VERSION', '') != '' \
>            or env.get('HTTPS', 'off') == 'on'
>
>        self.auth_username = None
>        if config.auth_http_enabled and env.get('AUTH_TYPE','') == 'Basic':
>            self.auth_username = env.get('REMOTE_USER','')
>                                    
>##        f=open('/tmp/env.log','a')
>##        f.write('---ENV\n')
>##        f.write('script_name = %s\n'%(self.script_name))
>##        f.write('path_info   = %s\n'%(self.path_info))
>##        f.write('server_name = %s\n'%(self.server_name))
>##        f.write('server_port = %s\n'%(self.server_port))
>##        f.write('http_host   = %s\n'%(self.http_host))
>##        f.write('------\n')
>##        f.write('%s\n'%(repr(env)))
>##        f.write('------\n')
>##        f.close()
>  
>    def reset(self):
>        """ Reset request state.
>
>        Called after saving a page, before serving the updated
>        page. Solves some practical problems with request state
>        modified during saving.
>
>        """
>        # This is the content language and has nothing to do with
>        # The user interface language. The content language can change
>        # during the rendering of a page by lang macros
>        self.current_lang = config.default_lang
>        self._footer_fragments = {}
>        self._all_pages = None
>
>        if hasattr(self, "_fmt_hd_counters"):
>            del self._fmt_hd_counters
>
>
>    def add2footer(self, key, htmlcode):
>        """ Add a named HTML fragment to the footer, after the default links
>        """
>        self._footer_fragments[key] = htmlcode
>
>
>    def getPragma(self, key, defval=None):
>        """ Query a pragma value (#pragma processing instruction)
>
>            Keys are not case-sensitive.
>        """
>        return self.pragma.get(key.lower(), defval)
>
>
>    def setPragma(self, key, value):
>        """ Set a pragma value (#pragma processing instruction)
>
>            Keys are not case-sensitive.
>        """
>        self.pragma[key.lower()] = value
>
>
>    def getPageList(self):
>        """ A cached version of wikiutil.getPageList().
>            Also, this list is always sorted.
>        """
>        if self._all_pages is None:
>            self._all_pages = wikiutil.getPageList(config.text_dir)
>            self._all_pages.sort()
>
>        return self._all_pages
>
>    def redirect(self, file=None):
>        if file: # redirect output to "file"
>            self.writestack.append(self.write)
>            self.write = file.write
>        else: # restore saved output file
>            self.write = self.writestack.pop()
>
>    def reset_output(self):
>        """ restore default output method
>            destroy output stack
>            (useful for error messages)
>        """
>        if self.writestack:
>            self.write = self.writestack[0]
>            self.writestack = []
>
>    def write(self, *data):
>        """ Write to output stream.
>        """
>        raise "NotImplementedError"
>
>    def read(self, n):
>        """ Read n bytes from input stream.
>        """
>        raise "NotImplementedError"
>
>    def flush(self):
>        """ Flush output stream.
>        """
>        raise "NotImplementedError"
>
>    def initdicts(self):
>        from MoinMoin import wikidicts
>        dicts = wikidicts.GroupDict()
>        dicts.scandicts()
>        return dicts
>        
>    def isForbidden(self):
>        """ check for web spiders and refuse anything except viewing """
>        forbidden = 0
>        if ((self.query_string != '' or self.request_method != 'GET')
>            and self.query_string != 'action=rss_rc'):
>            from MoinMoin.util import web
>            forbidden = web.isSpiderAgent(request=self)
>
>        if not forbidden and config.hosts_deny:
>            ip = self.remote_addr
>            for host in config.hosts_deny:
>                if ip == host or host[-1] == '.' and ip.startswith(host):
>                    forbidden = 1
>                    break
>        return forbidden
>
>
>    def setup_args(self, form=None):
>        return {}
>
>    def _setup_args_from_cgi_form(self, form=None):
>        """ A method to create the args from a standart cgi.FieldStorage
>            to be used be derived classes.
>
>            @keyword form: a cgi.FieldStorage list. default is to call
>                           cgi.FieldStorage().
>        """
>        import types, cgi
>        
>        if form is None:
>            form = cgi.FieldStorage()
>
>        args = {}
>        for key in form.keys():
>            values = form[key]
>            if not isinstance(values, types.ListType):
>                values = [values]
>            fixedResult = []
>            for i in values:
>                if isinstance(i, cgi.MiniFieldStorage):
>                    fixedResult.append(i.value)
>                elif isinstance(i, cgi.FieldStorage):
>                    fixedResult.append(i.value)
>                    # multiple uploads to same form field are stupid!
>                    if i.filename:
>                        args[key+'__filename__']=i.filename
>
>            args[key] = fixedResult
>        return args
>
>    def recodePageName(self, pagename):
>        # check for non-URI characters and then handle them according to
>        # http://www.w3.org/TR/REC-html40/appendix/notes.html#h-B.2.1
>        if pagename:
>            try:
>                dummy = unicode(pagename, 'ascii')
>            except UnicodeError:
>                # we have something else than plain ASCII, try
>                # converting from UTF-8 to local charset, or just give
>                # up and use URI value literally and see what happens
>                pagename = self.i18n.recode(pagename, 'utf-8', config.charset) or pagename
>        return pagename
>        # XXX UNICODE - use unicode for pagenames internally?
>
>    def getBaseURL(self):
>        """ Return a fully qualified URL to this script. """
>        return self.getQualifiedURL(self.getScriptname())
>
>
>    def getQualifiedURL(self, uri=None):
>        """ Return a full URL starting with schema, servername and port.
>
>            *uri* -- append this server-rooted uri (must start with a slash)
>        """
>        if uri and uri[:4] == "http":
>            return uri
>
>        schema, stdport = (('http', '80'), ('https', '443'))[self.is_ssl]
>        host = self.http_host
>        if not host:
>            host = self.server_name
>            port = self.server_port
>            if port != stdport:
>                host = "%s:%s" % (host, port)
>
>        result = "%s://%s" % (schema, host)
>        if uri:
>            result = result + uri
>
>        return result
>
>
>    def getUserAgent(self):
>        """ Get the user agent. """
>        return self.http_user_agent
>
>
>    def run(self):
>        _ = self.getText
>        self.clock.start('run')
>        self.open_logs()
>        if self.isForbidden():
>            self.http_headers([
>                'Status: 403 FORBIDDEN',
>                'Content-Type: text/plain'
>            ])
>            self.write('You are not allowed to access this!\n')
>            return self.finish()
>
>        # Imports
>        from MoinMoin.Page import Page
>
>        if self.query_string == 'action=xmlrpc':
>            from MoinMoin.wikirpc import xmlrpc
>            xmlrpc(self)
>            return self.finish()
>        
>        if self.query_string == 'action=xmlrpc2':
>            from MoinMoin.wikirpc import xmlrpc2
>            xmlrpc2(self)
>            return self.finish()
>
>        # parse request data
>        try:
>            self.args = self.setup_args()
>            self.form = self.args 
>            path_info = self.getPathinfo()
>
>            #from pprint import pformat
>            #sys.stderr.write(pformat(self.__dict__))
>    
>            action = self.form.get('action',[None])[0]
>
>            pagename = None
>            if len(path_info) and path_info[0] == '/':
>                pagename = wikiutil.unquoteWikiname(path_info[1:])
>        except: # catch and print any exception
>            self.reset_output()
>            self.http_headers()
>            self.print_exception()
>            return self.finish()
>
>        try:
>            # possibly jump to page where user left off
>            if not pagename and not action and self.user.remember_last_visit:
>                pagetrail = self.user.getTrail()
>                if pagetrail:
>                    self.http_redirect(Page(pagetrail[-1]).url(self))
>                    return self.finish()
>
>            # handle request
>            from MoinMoin import wikiaction
>
>            pagename = self.recodePageName(pagename)
>
>            if self.form.has_key('filepath') and self.form.has_key('noredirect'):
>                # looks like user wants to save a drawing
>                from MoinMoin.action.AttachFile import execute
>                execute(pagename, self)
>                raise MoinMoinNoFooter
>
>            if action:
>                handler = wikiaction.getHandler(action)
>                if handler:
>                    handler(pagename or
>                    wikiutil.getSysPage(self, config.page_front_page).page_name, self)
>                else:
>                    self.http_headers()
>                    self.write("<p>" + _("Unknown action"))
>            else:
>                if self.form.has_key('goto'):
>                    query = self.form['goto'][0].strip()
>                elif pagename:
>                    query = pagename
>                else:
>                    query = wikiutil.unquoteWikiname(self.query_string) or \
>                        wikiutil.getSysPage(self, config.page_front_page).page_name
>
>                if config.allow_extended_names:
>                    Page(query).send_page(self, count_hit=1)
>                else:
>                    from MoinMoin.parser.wiki import Parser
>                    import re
>                    word_match = re.match(Parser.word_rule, query)
>                    if word_match:
>                        word = word_match.group(0)
>                        Page(word).send_page(self, count_hit=1)
>                    else:
>                        self.http_headers()
>                        self.write('<p>' + _("Can't work out query") + ' "<pre>' + query + '</pre>"')
>
>            # generate page footer
>            # (actions that do not want this footer use raise util.MoinMoinNoFooter to break out
>            # of the default execution path, see the "except MoinMoinNoFooter" below)
>
>            self.clock.stop('run')
>            self.clock.stop('total')
>
>            if not self.no_closing_html_code:
>                if (config.show_timings and
>                    self.form.get('action', [None])[0] != 'print'):
>                    self.write('<ul id="timings">\n')
>                    for t in self.clock.dump():
>                        self.write('<li>%s</li>\n' % t)
>                    self.write('</ul>\n')
>
>                if 0: # temporarily disabled - do we need that?
>                    import socket
>                    from MoinMoin import version
>                    self.write('' % (
>                        version.revision, socket.gethostname(), self.clock.value('total')) +
>                               '</body></html>')
>                else:
>                    self.write('</body>\n</html>\n\n')
>            
>        except MoinMoinNoFooter:
>            pass
>
>        except: # catch and print any exception
>            saved_exc = sys.exc_info()
>            self.reset_output()
>            self.http_headers()
>            self.write("\n\n")
>            try:
>                from MoinMoin.support import cgitb
>            except:
>                # no cgitb, for whatever reason
>                self.print_exception(*saved_exc)
>            else:
>                try:
>                    cgitb.Hook(file=self).handle(saved_exc)
>                    # was: cgitb.handler()
>                except:
>                    self.print_exception(*saved_exc)
>                    self.write("\n\n<hr>\n")
>                    self.write("<p><strong>Additionally, cgitb raised this exception:</strong></p>\n")
>                    self.print_exception()
>            del saved_exc
>
>        return self.finish()
>
>
>    def http_redirect(self, url):
>        """ Redirect to a fully qualified, or server-rooted URL """
>        if url.find("://") == -1:
>            url = self.getQualifiedURL(url)
>
>        self.http_headers(["Status: 302", "Location: %s" % url])
>
>
>    def print_exception(self, type=None, value=None, tb=None, limit=None):
>        if type is None:
>            type, value, tb = sys.exc_info()
>        import traceback
>        self.write("<h2>request.print_exception handler</h2>\n")
>        self.write("<h3>Traceback (most recent call last):</h3>\n")
>        list = traceback.format_tb(tb, limit) + \
>               traceback.format_exception_only(type, value)
>        self.write("<pre>%s<strong>%s</strong></pre>\n" % (
>            wikiutil.escape("".join(list[:-1])),
>            wikiutil.escape(list[-1]),))
>        del tb
>
>
>    def open_logs(self):
>        pass
>
># CGI ---------------------------------------------------------------
>
>class RequestCGI(RequestBase):
>    """ specialized on CGI requests """
>
>    def __init__(self, properties={}):
>        self._setup_vars_from_std_env(os.environ)
>        #sys.stderr.write("----\n")
>        #for key in os.environ.keys():    
>        #    sys.stderr.write("    %s = '%s'\n" % (key, os.environ[key]))
>        RequestBase.__init__(self, properties)
>
>        # force input/output to binary
>        if sys.platform == "win32":
>            import msvcrt
>            msvcrt.setmode(sys.stdin.fileno(), os.O_BINARY)
>            msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
>
>    def open_logs(self):
>        # create CGI log file, and one for catching stderr output
>        import cgi 
>        if not self.opened_logs:
>            cgi.logfile = os.path.join(config.data_dir, 'cgi.log')
>            sys.stderr = open(os.path.join(config.data_dir, 'error.log'), 'at')
>            self.opened_logs = 1
>
>    def setup_args(self, form=None):
>        return self._setup_args_from_cgi_form(form)
>        
>    def read(self, n=None):
>        """ Read from input stream.
>        """
>        if n is None:
>            return sys.stdin.read()
>        else:
>            return sys.stdin.read(n)
>
>    def write(self, *data):
>        """ Write to output stream.
>        """
>        for piece in data:
>            sys.stdout.write(piece)
>
>    def flush(self):
>        sys.stdout.flush()
>        
>    def finish(self):
>        # flush the output, ignore errors caused by the user closing the socket
>        try:
>            sys.stdout.flush()
>        except IOError, ex:
>            import errno
>            if ex.errno != errno.EPIPE: raise
>
>    #############################################################################
>    ### Accessors
>    #############################################################################
>
>    def getScriptname(self):
>        """ Return the scriptname part of the URL ("/path/to/my.cgi"). """
>        name = self.script_name
>        if name == '/':
>            return ''
>        return name
>
>
>    def getPathinfo(self):
>        """ Return the remaining part of the URL. """
>        pathinfo = self.path_info
>
>        # Fix for bug in IIS/4.0
>        if os.name == 'nt':
>            scriptname = self.getScriptname()
>            if pathinfo.startswith(scriptname):
>                pathinfo = pathinfo[len(scriptname):]
>
>        return pathinfo
>
>
>    #############################################################################
>    ### Headers
>    #############################################################################
>
>    def setHttpHeader(self, header):
>        self.user_headers.append(header)
>
>
>    def http_headers(self, more_headers=[]):
>        if self.sent_headers:
>            #self.write("Headers already sent!!!\n")
>            return
>        self.sent_headers = 1
>        have_ct = 0
>
>        # send http headers
>        for header in more_headers + self.user_headers:
>            if header.lower().startswith("content-type:"):
>                # don't send content-type multiple times!
>                if have_ct: continue
>                have_ct = 1
>            self.write("%s\r\n" % header)
>
>        if not have_ct:
>            self.write("Content-type: text/html;charset=%s\r\n" % config.charset)
>
>        self.write('\r\n')
>
>        #from pprint import pformat
>        #sys.stderr.write(pformat(more_headers))
>        #sys.stderr.write(pformat(self.user_headers))
>
>
># Twisted -----------------------------------------------------------
>
>class RequestTwisted(RequestBase):
>    """ specialized on Twisted requests """
>
>    def __init__(self, twistedRequest, pagename, reactor, properties={}):
>        self.twistd = twistedRequest
>        self.http_accept_language = self.twistd.getHeader('Accept-Language')
>        self.reactor = reactor
>        self.saved_cookie = self.twistd.getHeader('Cookie')
>        self.server_protocol = self.twistd.clientproto
>        self.server_name = self.twistd.getRequestHostname().split(':')[0]
>        self.server_port = str(self.twistd.getHost()[2])
>        self.is_ssl = self.twistd.isSecure()
>        if self.server_port != ('80', '443')[self.is_ssl]:
>            self.http_host = self.server_name + ':' + self.server_port
>        else:
>            self.http_host = self.server_name
>        self.script_name = "/" + '/'.join(self.twistd.prepath[:-1]) # "" XXX
>        self.path_info = "/" + pagename
>        if self.twistd.postpath:
>            self.path_info += '/' + '/'.join(self.twistd.postpath)
>        self.request_method = self.twistd.method
>        self.remote_host = self.twistd.getClient()
>        self.remote_addr = self.twistd.getClientIP()
>        self.http_user_agent = self.twistd.getHeader('User-Agent')
>        self.request_uri = self.twistd.uri
>       
>        qindex = self.request_uri.find('?')
>        if qindex != -1:
>            self.query_string = self.request_uri[qindex+1:]
>        else:
>            self.query_string = ''
>        self.outputlist = []
>        self.auth_username = None # TODO, see: self.twistd.user / .password (http auth)
>        RequestBase.__init__(self, properties)
>        #print "request.RequestTwisted.__init__: received_headers=\n" + str(self.twistd.received_headers)
>
>    def setup_args(self, form=None):
>        return self.twistd.args
>        
>    def read(self, n=None):
>        """ Read from input stream.
>        """
>        # XXX why is that wrong?:
>        #rd = self.reactor.callFromThread(self.twistd.read)
>        
>        # XXX do we need self.reactor.callFromThread with that?
>        # XXX if yes, why doesnt it work?
>        self.twistd.content.seek(0, 0)
>        if n is None:
>            rd = self.twistd.content.read()
>        else:
>            rd = self.twistd.content.read(n)
>        #print "request.RequestTwisted.read: data=\n" + str(rd)
>        return rd
>    
>    def write(self, *data):
>        """ Write to output stream.
>        """
>        wd = ''.join(data)
>        # XXX UNICODE - encode to config.charset
>        #wd = u''.join(data).encode(config.charset)
>        #print "request.RequestTwisted.write: data=\n" + wd
>        self.reactor.callFromThread(self.twistd.write, wd)
>
>    def flush(self):
>        pass # XXX is there a flush in twisted?
>
>    def finish(self):
>        #print "request.RequestTwisted.finish"
>        self.reactor.callFromThread(self.twistd.finish)
>
>    def open_logs(self):
>        return
>        # create log file for catching stderr output
>        if not self.opened_logs:
>            sys.stderr = open(os.path.join(config.data_dir, 'error.log'), 'at')
>            self.opened_logs = 1
>
>
>    #############################################################################
>    ### Accessors
>    #############################################################################
>
>    def getScriptname(self):
>        """ Return the scriptname part of the URL ("/path/to/my.cgi"). """
>        scriptname = self.script_name
>        if scriptname == '/':
>            scriptname = ''
>        return scriptname
>
>    def getPathinfo(self):
>        """ Return the remaining part of the URL. """
>        return self.path_info
>
>
>    #############################################################################
>    ### Headers
>    #############################################################################
>
>    def setHttpHeader(self, header):
>        self.user_headers.append(header)
>
>    def __setHttpHeader(self, header):
>        key, value = header.split(':',1)
>        value = value.lstrip()
>        self.twistd.setHeader(key, value)
>        #print "request.RequestTwisted.setHttpHeader: %s" % header
>
>    def http_headers(self, more_headers=[]):
>        if self.sent_headers:
>            #self.write("Headers already sent!!!\n")
>            return
>        self.sent_headers = 1
>        have_ct = 0
>
>        # set http headers
>        for header in more_headers + self.user_headers:
>            if header.lower().startswith("content-type:"):
>                # don't send content-type multiple times!
>                if have_ct: continue
>                have_ct = 1
>            self.__setHttpHeader(header)
>
>        if not have_ct:
>            self.__setHttpHeader("Content-type: text/html;charset=%s" % config.charset)
>
>
>    def http_redirect(self, url):
>        """ Redirect to a fully qualified, or server-rooted URL """
>        if url.count("://") == 0:
>            # no https method??
>            url = "http://%s:%s%s" % (self.server_name, self.server_port, url)
>
>        self.twistd.redirect(url)
>        # calling finish here will send the rest of the data to the next
>        # request. leave the finish call to run()
>        #self.twistd.finish()
>        raise MoinMoinNoFooter
>
>
># CLI ------------------------------------------
>class RequestCLI(RequestBase):
>    """ specialized on commandline interface requests """
>
>    def __init__(self, pagename='', properties={}):
>        self.http_accept_language = ''
>        self.saved_cookie = ''
>        self.path_info = '/' + pagename
>        self.query_string = ''
>        self.remote_addr = '127.0.0.127'
>        self.is_ssl = 0
>        self.auth_username = None
>        RequestBase.__init__(self, properties)
>        self.http_user_agent = ''
>        self.outputlist = []
>
>    def read(self, n=None):
>        """ Read from input stream.
>        """
>        if n is None:
>            return sys.stdin.read()
>        else:
>            return sys.stdin.read(n)
>
>    def write(self, *data):
>        """ Write to output stream.
>        """
>        for piece in data:
>            sys.stdout.write(piece)
>
>    def flush(self):
>        sys.stdout.flush()
>        
>    def finish(self):
>        # flush the output, ignore errors caused by the user closing the socket
>        try:
>            sys.stdout.flush()
>        except IOError, ex:
>            import errno
>            if ex.errno != errno.EPIPE: raise
>
>    def isForbidden(self):
>        """ check for web spiders and refuse anything except viewing """
>        return 0
>
>
>    #############################################################################
>    ### Accessors
>    #############################################################################
>
>    def getScriptname(self):
>        """ Return the scriptname part of the URL ("/path/to/my.cgi"). """
>        return '.'
>
>    def getPathinfo(self):
>        """ Return the remaining part of the URL. """
>        return self.path_info
>
>
>    def getQualifiedURL(self, uri = None):
>        """ Return a full URL starting with schema, servername and port.
>
>            *uri* -- append this server-rooted uri (must start with a slash)
>        """
>        return uri
>
>
>    def getBaseURL(self):
>        """ Return a fully qualified URL to this script. """
>        return self.getQualifiedURL(self.getScriptname())
>
>
>
>    #############################################################################
>    ### Headers
>    #############################################################################
>
>    def setHttpHeader(self, header):
>        pass
>
>    def http_headers(self, more_headers=[]):
>        pass
>
>    def http_redirect(self, url):
>        """ Redirect to a fully qualified, or server-rooted URL """
>        raise Exception("Redirect not supported for command line tools!")
>
>
># StandAlone Server -------------------------------------------------
>class RequestStandAlone(RequestBase):
>    """
>    specialized on StandAlone Server (httpdmain.py) requests
>    """
>
>    def __init__(self, sa, properties={}):
>        """
>        @param sa: stand alone server object
>        @param properties: ...
>        """
>        import urllib
>        self.wfile = sa.wfile
>        self.rfile = sa.rfile
>        self.headers = sa.headers
>        self.is_ssl = 0
>        rest = sa.path
>        i = rest.rfind('?')
>        if i >= 0:
>            rest, query = rest[:i], rest[i+1:]
>        else:
>            query = ''
>        uqrest = urllib.unquote(rest)
>        
>        #HTTP headers
>        self.env = {} 
>        for hline in sa.headers.headers:
>            key = sa.headers.isheader(hline)
>            if key:
>                hdr = sa.headers.getheader(key)
>                self.env[key] = hdr
>                
>        #accept = []
>        #for line in sa.headers.getallmatchingheaders('accept'):
>        #    if line[:1] in string.whitespace:
>        #        accept.append(line.strip())
>        #    else:
>        #        accept = accept + line[7:].split(',')
>        #
>        #env['HTTP_ACCEPT'] = ','.join(accept)
>
>        co = filter(None, sa.headers.getheaders('cookie'))
>
>        self.http_accept_language = sa.headers.getheader('Accept-Language')
>        self.server_name = sa.server.server_name
>        self.server_port = str(sa.server.server_port)
>        self.http_host = sa.headers.getheader('host')
>        self.http_referer = sa.headers.getheader('referer')
>        self.saved_cookie = ', '.join(co) or ''
>        self.script_name = ''
>        self.path_info = uqrest 
>        self.query_string = query or ''
>        self.request_method = sa.command
>        self.remote_addr = sa.client_address[0]
>        self.http_user_agent = sa.headers.getheader('user-agent') or ''
>        # from standalone script:
>        # XXX AUTH_TYPE
>        # XXX REMOTE_USER
>        # XXX REMOTE_IDENT
>        self.auth_username = None
>        #env['PATH_TRANSLATED'] = uqrest #self.translate_path(uqrest)
>        #host = self.address_string()
>        #if host != self.client_address[0]:
>        #    env['REMOTE_HOST'] = host
>        # env['SERVER_PROTOCOL'] = self.protocol_version
>        RequestBase.__init__(self, properties)
>
>    def open_logs(self):
>        # create error log file for catching stderr output
>        if not self.opened_logs:
>            sys.stderr = open(os.path.join(config.data_dir, 'error.log'), 'at')
>            self.opened_logs = 1
>
>    def setup_args(self, form=None):
>        self.env['REQUEST_METHOD'] = self.request_method
>        self.env['QUERY_STRING'] = self.query_string
>        ct = self.headers.getheader('content-type')
>        if ct:
>            self.env['CONTENT_TYPE'] = ct
>        cl = self.headers.getheader('content-length')
>        if cl:
>            self.env['CONTENT_LENGTH'] = cl
>        
>        import cgi
>        #print "env = ", self.env
>        #form = cgi.FieldStorage(self, headers=self.env, environ=self.env)
>        if form is None:
>            form = cgi.FieldStorage(self, environ=self.env)
>        return self._setup_args_from_cgi_form(form)
>        
>    def read(self, n=None):
>        """ Read from input stream.
>        """
>        if n is None:
>            return self.rfile.read()
>        else:
>            return self.rfile.read(n)
>
>    def readline (self):
>        L = ""
>        while 1:
>            c = self.read(1)
>            L += c
>            if c == '\n':
>                break
>        return L
>	    
>    def write(self, *data):
>        """ Write to output stream.
>        """
>        for piece in data:
>            self.wfile.write(piece)
>
>    def flush(self):
>        self.wfile.flush()
>        
>    def finish(self):
>        # flush the output, ignore errors caused by the user closing the socket
>        try:
>            self.wfile.flush()
>        except IOError, ex:
>            import errno
>            if ex.errno != errno.EPIPE: raise
>
>    #############################################################################
>    ### Accessors
>    #############################################################################
>
>    def getScriptname(self):
>        """ Return the scriptname part of the URL ("/path/to/my.cgi"). """
>        name = self.script_name
>        if name == '/':
>            return ''
>        return name
>
>
>    def getPathinfo(self):
>        """ Return the remaining part of the URL. """
>        return self.path_info
>
>
>    #############################################################################
>    ### Headers
>    #############################################################################
>
>    def setHttpHeader(self, header):
>        self.user_headers.append(header)
>
>    def http_headers(self, more_headers=[]):
>        if self.sent_headers:
>            #self.write("Headers already sent!!!\n")
>            return
>        self.sent_headers = 1
>        have_ct = 0
>
>        # send http headers
>        for header in more_headers + self.user_headers:
>            if header.lower().startswith("content-type:"):
>                # don't send content-type multiple times!
>                if have_ct: continue
>                have_ct = 1
>            self.write("%s\r\n" % header)
>
>        if not have_ct:
>            self.write("Content-type: text/html;charset=%s\r\n" % config.charset)
>
>        self.write('\r\n')
>
>        #from pprint import pformat
>        #sys.stderr.write(pformat(more_headers))
>        #sys.stderr.write(pformat(self.user_headers))
>
>
># mod_python/Apache -------------------------------------------------
>class RequestModPy(RequestBase):
>    """ specialized on mod_python requests """
>
>    def __init__(self, req):
>        """ Saves mod_pythons request and sets basic variables using
>            the req.subprocess_env, cause this provides a standard
>            way to access the values we need here.
>
>            @param req: the mod_python request instance
>        """
>        req.add_common_vars()
>        self.mpyreq = req
>        # some mod_python 2.7.X has no get method for table objects,
>        # so we make a real dict out of it first.
>        if not hasattr(req.subprocess_env,'get'):
>            env=dict(req.subprocess_env)
>        else:
>            env=req.subprocess_env
>        self._setup_vars_from_std_env(env)
>        # flags if headers sent out contained content-type or status
>        self._have_ct = 0
>        self._have_status = 0
>        RequestBase.__init__(self)
>        
>        
>    def setup_args(self, form=None):
>        """ Sets up args by using mod_python.util.FieldStorage, which
>            is different to cgi.FieldStorage. So we need a seperate
>            method for this.
>        """
>        import types
>        from mod_python import util
>        if form is None:
>            form = util.FieldStorage(self.mpyreq)
>
>        args = {}
>        for key in form.keys():
>            values = form[key]
>            if not isinstance(values, types.ListType):
>                values = [values]
>            fixedResult = []
>            for i in values:
>                ## mod_python 2.7 might return strings instead
>                ## of Field objects
>                if hasattr(i,'value'):
>                    fixedResult.append(i.value)
>                else:
>                    fixedResult.append(i)
>                ## if object has a filename attribute, remember it
>                ## with a name hack
>                if hasattr(i,'filename') and i.filename:
>                    args[key+'__filename__']=i.filename
>            args[key] = fixedResult
>        return args
>
>    def run(self, req):
>        """ mod_python calls this with its request object. We don't
>            need it cause its already passed to __init__. So ignore
>            it and just return RequestBase.run.
>
>            @param req: the mod_python request instance
>        """
>        return RequestBase.run(self)
>
>    def read(self, n=None):
>        """ Read from input stream.
>        """
>        if n is None:
>            return self.mpyreq.read()
>        else:
>            return self.mpyreq.read(n)
>
>    def write(self, *data):
>        """ Write to output stream.
>        """
>        for piece in data:
>            self.mpyreq.write(piece)
>
>    def flush(self):
>        """ We can't flush it, so do nothing.
>        """
>        pass
>        
>    def finish(self):
>        """ Just return apache.OK. Status is set in req.status.
>        """
>        # is it possible that we need to return somethig else here?
>        from mod_python import apache
>        return apache.OK
>        
>    
>    #############################################################################
>    ### Accessors
>    #############################################################################
>
>    def getScriptname(self):
>        """ Return the scriptname part of the URL ('/path/to/my.cgi'). """
>        name = self.script_name
>        if name == '/':
>            return ''
>        return name
>
>
>    def getPathinfo(self):
>        """ Return the remaining part of the URL. """
>        return self.path_info
>
>    #############################################################################
>    ### Headers
>    #############################################################################
>
>    def setHttpHeader(self, header):
>        """ Filters out content-type and status to set them directly
>            in the mod_python request. Rest is put into the headers_out
>            member of the mod_python request.
>
>            @param header: string, containing valid HTTP header.
>        """
>        key, value = header.split(':',1)
>        value = value.lstrip()
>        if key.lower() == 'content-type':
>            # save content-type for http_headers
>            if not self._have_ct:
>                # we only use the first content-type!
>                self.mpyreq.content_type = value
>                self._have_ct = 1
>        elif key.lower() == 'status':
>            # save status for finish
>            try:
>                self.mpyreq.status = int(value.split(' ',1)[0])
>            except:
>                pass
>            else:
>                self._have_status = 1
>        else:
>            # this is a header we sent out
>            self.mpyreq.headers_out[key]=value
>
>
>    def http_headers(self, more_headers=[]):
>        """ Sends out headers and possibly sets default content-type
>            and status.
>
>            @keyword more_headers: list of strings, defaults to []
>        """
>        for header in more_headers:
>            self.setHttpHeader(header)
>        # if we don't had an content-type header, set text/html
>        if self._have_ct == 0:
>            self.mpyreq.content_type = "text/html;charset=%s" % config.charset
>        # if we don't had a status header, set 200
>        if self._have_status == 0:
>            self.mpyreq.status = 200
>        # this is for mod_python 2.7.X, for 3.X it's a NOP
>        self.mpyreq.send_http_header()
>
># FastCGI -----------------------------------------------------------
>
>class RequestFastCGI(RequestBase):
>    """ specialized on FastCGI requests """
>
>    def __init__(self, fcgRequest, env, form, properties={}):
>        """ Initializes variables from FastCGI environment and saves
>            FastCGI request and form for further use.
>
>            @param fcgRequest: the FastCGI request instance.
>            @param env: environment passed by FastCGI.
>            @param form: FieldStorage passed by FastCGI.
>        """
>        self.fcgreq = fcgRequest
>        self.fcgenv = env
>        self.fcgform = form
>        self._setup_vars_from_std_env(env)
>        RequestBase.__init__(self, properties)
>
>    def setup_args(self, form=None):
>        """ Use the FastCGI form to setup arguments. """
>        if form is None:
>            form = self.fcgform
>        return self._setup_args_from_cgi_form(form)
>
>    def read(self, n=None):
>        """ Read from input stream.
>        """
>        if n is None:
>            return self.fcgreq.stdin.read()
>        else:
>            return self.fcgreq.stdin.read(n)
>
>    def write(self, *data):
>        """ Write to output stream.
>        """
>        self.fcgreq.out.write("".join(data))
>
>    def flush(self):
>        """ Flush output stream.
>        """
>        self.fcgreq.flush_out()
>
>    def finish(self):
>        """ Call finish method of FastCGI request to finish handling
>            of this request.
>        """
>        self.fcgreq.finish()
>
>
>    #############################################################################
>    ### Accessors
>    #############################################################################
>
>    def getScriptname(self):
>        """ Return the scriptname part of the URL ('/path/to/my.cgi'). """
>        name = self.script_name
>        if name == '/':
>            return ''
>        return name
>
>
>    def getPathinfo(self):
>        """ Return the remaining part of the URL. """
>        pathinfo = self.path_info
>
>        # Fix for bug in IIS/4.0
>        if os.name == 'nt':
>            scriptname = self.getScriptname()
>            if pathinfo.startswith(scriptname):
>                pathinfo = pathinfo[len(scriptname):]
>
>        return pathinfo
>
>
>    #############################################################################
>    ### Headers
>    #############################################################################
>
>    def setHttpHeader(self, header):
>        """ Save header for later send. """
>        self.user_headers.append(header)
>
>
>    def http_headers(self, more_headers=[]):
>        """ Send out HTTP headers. Possibly set a default content-type.
>        """
>        if self.sent_headers:
>            #self.write("Headers already sent!!!\n")
>            return
>        self.sent_headers = 1
>        have_ct = 0
>
>        # send http headers
>        for header in more_headers + self.user_headers:
>            if header.lower().startswith("content-type:"):
>                # don't send content-type multiple times!
>                if have_ct: continue
>                have_ct = 1
>            self.write("%s\r\n" % header)
>
>        if not have_ct:
>            self.write("Content-type: text/html;charset=%s\r\n" % config.charset)
>
>        self.write('\r\n')
>
>        #from pprint import pformat
>        #sys.stderr.write(pformat(more_headers))
>        #sys.stderr.write(pformat(self.user_headers))
>
>package test0574;
>
>public class X {
>
>	public static void main(String[] args) {
>		
>	}
>}
>

Actions: View

Attachments on bug 78305: 15778 | 15786