Пример #1
0
 def __init__(self, snake, request, response, properties={}):
     self.snake=snake
     self.request=request
     self.response=response
     self.request_uri = request.getRequestURL()
     self.script_name = self.snake.getWebApp().getURLprefix()[:-1] # strip the trailing /
     self.path_info, self.query_string = self.splitURI(request.getRequestURL())
     self.path_info = self.path_info[len(self.script_name):]
     self.saved_cookie = request.getCookie()
     self.request_method = request.getMethod()
     headers = request.getAllHeaders()
     self.remote_addr=request.getRemoteAddr()
     self.http_user_agent=request.getUserAgent()
     self.http_accept_language = headers.getheader('accept-language')
     self.setHttpReferer(headers.getheader('referer'))
     self.setHost(headers.getheader('host'))
     self.setURL(headers)
     self.if_modified_since=headers.getheader('If-modified-since')
     self.if_none_match=headers.getheader('If-none-match')
     self.server_port = str(request.getServerPort())
     self.server_name = request.getServerName()
     if ':' in self.server_name:
         self.server_name=self.server_name.split(':')[0]
     self.headers = headers
     baseurl = request.getBaseURL()
     self.is_ssl = baseurl.startswith("https") or baseurl.startswith("HTTPS")
     RequestBase.__init__(self, properties)
Пример #2
0
    def __init__(self, req, properties={}):
        """ 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
        """
        try:
            # flags if headers sent out contained content-type or status
            self._have_ct = 0
            self._have_status = 0

            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)
            RequestBase.__init__(self, properties)

        except Exception, err:
            self.fail(err)
Пример #3
0
    def finish(self):
        """ Just return apache.OK. Status is set in req.status. """
        RequestBase.finish(self)
        # is it possible that we need to return something else here?
        from mod_python import apache

        return apache.OK
Пример #4
0
 def finish(self):
     RequestBase.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
Пример #5
0
    def __init__(self, properties={}):
        try:
            # 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)

            self._setup_vars_from_std_env(os.environ)
            RequestBase.__init__(self, properties)

        except Exception, err:
            self.fail(err)
Пример #6
0
    def __init__(self, twistedRequest, pagename, reactor, properties={}):
        try:
            self.twistd = twistedRequest
            self.reactor = reactor

            # Copy headers
            self.http_accept_language = self.twistd.getHeader('Accept-Language')
            self.saved_cookie = self.twistd.getHeader('Cookie')
            self.http_user_agent = self.twistd.getHeader('User-Agent')
            try:
                self.content_length = int(self.twistd.getHeader('Content-Length'))
            except (TypeError, ValueError):
                self.content_length = None
            self.if_modified_since = self.twistd.getHeader('If-Modified-Since')
            self.if_none_match = self.twistd.getHeader('If-None-Match')

            # Copy values from twisted request
            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()
            self.path_info = '/' + '/'.join([pagename] + self.twistd.postpath)
            self.request_method = self.twistd.method
            self.remote_addr = self.twistd.getClientIP()
            self.request_uri = self.twistd.uri
            self.script_name = "/" + '/'.join(self.twistd.prepath[:-1])

            # Values that need more work
            self.query_string = self.splitURI(self.twistd.uri)[1]
            self.setHttpReferer(self.twistd.getHeader('Referer'))
            self.setHost()
            self.setURL(self.twistd.getAllHeaders())

            ##self.debugEnvironment(twistedRequest.getAllHeaders())

            RequestBase.__init__(self, properties)

        except MoinMoinFinish: # might be triggered by http_redirect
            self.emit_http_headers() # send headers (important for sending MOIN_ID cookie)
            self.finish()

        except Exception, err:
            # Wrap err inside an internal error if needed
            from MoinMoin import error
            if isinstance(err, error.FatalError):
                self.delayedError = err
            else:
                self.delayedError = error.InternalError(str(err))
Пример #7
0
    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)
Пример #8
0
    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.
        """
        try:
            self.fcgreq = fcgRequest
            self.fcgenv = env
            self.fcgform = form
            self._setup_vars_from_std_env(env)
            RequestBase.__init__(self, properties)

        except Exception, err:
            self.fail(err)
Пример #9
0
    def __init__(self, sa, properties={}):
        """
        @param sa: stand alone server object
        @param properties: ...
        """
        try:
            self.sareq = sa
            self.wfile = sa.wfile
            self.rfile = sa.rfile
            self.headers = sa.headers
            self.is_ssl = 0

            # Copy headers
            self.http_accept_language = (sa.headers.getheader('accept-language')
                                         or self.http_accept_language)
            self.http_user_agent = sa.headers.getheader('user-agent', '')
            try:
                self.content_length = int(sa.headers.getheader('content-length'))
            except (TypeError, ValueError):
                self.content_length = None
            co = [c for c in sa.headers.getheaders('cookie') if c]
            self.saved_cookie = ', '.join(co) or ''
            self.if_modified_since = sa.headers.getheader('if-modified-since')
            self.if_none_match = sa.headers.getheader('if-none-match')

            # Copy rest from standalone request
            self.server_name = sa.server.server_name
            self.server_port = str(sa.server.server_port)
            self.request_method = sa.command
            self.request_uri = sa.path
            self.remote_addr = sa.client_address[0]

            # Values that need more work
            self.path_info, self.query_string = self.splitURI(sa.path)
            self.setHttpReferer(sa.headers.getheader('referer'))
            self.setHost(sa.headers.getheader('host'))
            self.setURL(sa.headers)

            ##self.debugEnvironment(sa.headers)

            RequestBase.__init__(self, properties)

        except Exception, err:
            self.fail(err)
Пример #10
0
 def __init__(self, url='CLI', pagename='', properties={}, given_config=None):
     self.saved_cookie = ''
     self.path_info = '/' + pagename
     self.query_string = ''
     self.remote_addr = '127.0.0.1'
     self.is_ssl = 0
     self.http_user_agent = 'CLI/Script'
     self.url = url
     self.request_method = 'GET'
     self.request_uri = '/' + pagename # TODO check if /pagename works as URI for CLI usage
     self.http_host = 'localhost'
     self.http_referer = ''
     self.script_name = '.'
     self.content_length = None
     self.if_modified_since = None
     self.if_none_match = None
     RequestBase.__init__(self, properties, given_config)
     self.cfg.caching_formats = [] # don't spoil the cache
     self.initTheme() # usually request.run() does this, but we don't use it
Пример #11
0
    def __init__(self, env):
        try:
            self.env = env
            self.hasContentType = False

            self.stdin = env['wsgi.input']
            self.stdout = StringIO.StringIO()

            # used by MoinMoin.server.server_wsgi:
            self.status = '200 OK'
            self.headers = []

            # used by send_file()
            self._send_file = None
            self._send_bufsize = None

            self._setup_vars_from_std_env(env)
            RequestBase.__init__(self, {})

        except Exception, err:
            self.fail(err)
Пример #12
0
    def fixURI(self, env):
        """ Fix problems with script_name and path_info using
        PythonOption directive to rewrite URI.

        This is needed when using Apache 1 or other server which does
        not support adding custom headers per request. With mod_python we
        can use the PythonOption directive:

            <Location /url/to/mywiki/>
                PythonOption X-Moin-Location /url/to/mywiki/
            </location>

        Note that *neither* script_name *nor* path_info can be trusted
        when Moin is invoked as a mod_python handler with apache1, so we
        must build both using request_uri and the provided PythonOption.
        """
        # Be compatible with release 1.3.5 "Location" option
        # TODO: Remove in later release, we should have one option only.
        old_location = "Location"
        options_table = self.mpyreq.get_options()
        if not hasattr(options_table, "get"):
            options = dict(options_table)
        else:
            options = options_table
        location = options.get(self.moin_location) or options.get(old_location)
        if location:
            env[self.moin_location] = location
            # Try to recreate script_name and path_info from request_uri.
            import urlparse

            scriptAndPath = urlparse.urlparse(self.request_uri)[2]
            self.script_name = location.rstrip("/")
            path = scriptAndPath.replace(self.script_name, "", 1)
            self.path_info = wikiutil.url_unquote(path, want_unicode=False)

        RequestBase.fixURI(self, env)
Пример #13
0
 def finish(self):
     RequestBase.finish(self)
     self.flush()
Пример #14
0
 def finish(self):
     """ Call finish method of FastCGI request to finish handling of this request. """
     RequestBase.finish(self)
     self.fcgreq.finish()
Пример #15
0
 def send_file(self, fileobj, bufsize=8192, do_flush=True):
     # as thfcgi buffers everything we write until we do a flush, we use
     # do_flush=True as default here (otherwise the sending of big file
     # attachments would consume lots of memory)
     return RequestBase.send_file(self, fileobj, bufsize, do_flush)
Пример #16
0
 def _setup_args_from_cgi_form(self):
     """ Override to use FastCGI form """
     # thfcgi used keep_blank_values=1 internally for fcgform
     return RequestBase._setup_args_from_cgi_form(self, self.fcgform)
Пример #17
0
 def run(self):
     """ Handle delayed errors then invoke base class run """
     if hasattr(self, 'delayedError'):
         self.fail(self.delayedError)
         return self.finish()
     RequestBase.run(self)
Пример #18
0
 def _setup_args_from_cgi_form(self):
     """ Override to create cgi form """
     form = cgi.FieldStorage(keep_blank_values=1)
     return RequestBase._setup_args_from_cgi_form(self, form)
Пример #19
0
 def _setup_args_from_cgi_form(self):
     """ Override to create standalone form """
     form = cgi.FieldStorage(self.rfile, headers=self.headers, environ={'REQUEST_METHOD': 'POST'},
                             keep_blank_values=1)
     return RequestBase._setup_args_from_cgi_form(self, form)
Пример #20
0
 def finish(self):
     RequestBase.finish(self)
     self.reactor.callFromThread(self.twistd.finish)