Mercurial Repository: p/roundup/code: roundup/cgi/client.py comparison

comparison roundup/cgi/client.py @ 4362:74476eaac38a

more modernisation

author	Richard Jones <richard@users.sourceforge.net>
date	Fri, 26 Feb 2010 00:38:53 +0000
parents	85b00a3820b3
children	fa5587802af9

comparison

equal deleted inserted replaced

-:661466ba19cd
+:74476eaac38a
 """WWW request handler (also used in the stand-alone server).
 """
 __docformat__ = 'restructuredtext'
-import base64, binascii, cgi, codecs, httplib, mimetypes, os
+import base64, binascii, cgi, codecs, mimetypes, os
-import quopri, random, re, rfc822, stat, sys, time, urllib, urlparse
+import quopri, random, re, rfc822, stat, sys, time
-import Cookie, socket, errno
+import socket, errno
-from Cookie import CookieError, BaseCookie, SimpleCookie
-from cStringIO import StringIO
 from roundup import roundupdb, date, hyperdb, password
 from roundup.cgi import templating, cgitb, TranslationService
 from roundup.cgi.actions import *
 from roundup.exceptions import *
 from roundup.cgi.form_parser import FormParser
 from roundup.mailer import Mailer, MessageSendError, encode_quopri
 from roundup.cgi import accept_language
 from roundup import xmlrpc
+from roundup.anypy.cookie_ import CookieError, BaseCookie, SimpleCookie, \
+get_cookie_date
+from roundup.anypy.io_ import StringIO
+from roundup.anypy import http_
+from roundup.anypy import urllib_
 def initialiseSecurity(security):
 '''Create some Permissions and Roles on the security object
 This function is directly invoked by security.Security.__init__()
 as a part of the Security object instantiation.
 def clean_message(message, mc=re.compile(CLEAN_MESSAGE_RE, re.I)):
 return mc.sub(clean_message_callback, message)
 def clean_message_callback(match, ok={'a':1,'i':1,'b':1,'br':1}):
 """ Strip all non <a>,<i>,<b> and <br> tags from a string
 """
-if ok.has_key(match.group(3).lower()):
+if match.group(3).lower() in ok:
 return match.group(1)
 return '&lt;%s&gt;'%match.group(2)
 error_message = ''"""<html><head><title>An error has occurred</title></head>
 if not self.base.endswith('/'):
 self.base = self.base + '/'
 # this is the "cookie path" for this tracker (ie. the path part of
 # the "base" url)
-self.cookie_path = urlparse.urlparse(self.base)[2]
+self.cookie_path = urllib_.urlparse(self.base)[2]
 # cookies to set in http responce
 # {(path, name): (value, expire)}
 self._cookies = {}
 # see if we need to re-parse the environment for the form (eg Zope)
 # The user tried to log in, but did not provide a valid
 # username and password.  If we support HTTP
 # authorization, send back a response that will cause the
 # browser to prompt the user again.
 if self.instance.config.WEB_HTTP_AUTH:
-self.response_code = httplib.UNAUTHORIZED
+self.response_code = http_.client.UNAUTHORIZED
 realm = self.instance.config.TRACKER_NAME
 self.setHeader("WWW-Authenticate",
 "Basic realm=\"%s\"" % realm)
 else:
-self.response_code = httplib.FORBIDDEN
+self.response_code = http_.client.FORBIDDEN
 self.renderFrontPage(message)
 except Unauthorised, message:
 # users may always see the front page
 self.response_code = 403
 self.renderFrontPage(message)
 self.write_html(self.renderContext())
 except KeyError:
 # we can't map the URL to a class we know about
 # reraise the NotFound and let roundup_server
 # handle it
-raise NotFound, e
+raise NotFound(e)
 except FormError, e:
 self.error_message.append(self._('Form Error: ') + str(e))
 self.write_html(self.renderContext())
 except:
 # Something has gone badly wrong.  Therefore, we should
 # make sure that the response code indicates failure.
-if self.response_code == httplib.OK:
+if self.response_code == http_.client.OK:
-self.response_code = httplib.INTERNAL_SERVER_ERROR
+self.response_code = http_.client.INTERNAL_SERVER_ERROR
 # Help the administrator work out what went wrong.
 html = ("<h1>Traceback</h1>"
 + cgitb.html(i18n=self.translator)
 + ("<h1>Environment Variables</h1><table>%s</table>"
 % cgitb.niceDict("", self.env)))
 If the charset is found, and differs from the storage charset,
 recode all form fields of type 'text/plain'
 """
 # look for client charset
 charset_parameter = 0
-if self.form.has_key('@charset'):
+if '@charset' in self.form:
 charset = self.form['@charset'].value
 if charset.lower() == "none":
 charset = ""
 charset_parameter = 1
-elif self.cookie.has_key('roundup_charset'):
+elif 'roundup_charset' in self.cookie:
 charset = self.cookie['roundup_charset'].value
 else:
 charset = None
 if charset:
 # make sure the charset is recognized
 uc = int(num[1:], 16)
 else:
 uc = int(num)
 return unichr(uc)
-for field_name in self.form.keys():
+for field_name in self.form:
 field = self.form[field_name]
 if (field.type == 'text/plain') and not field.filename:
 try:
 value = decoder(field.value)[0]
 except UnicodeError:
 def determine_language(self):
 """Determine the language"""
 # look for language parameter
 # then for language cookie
 # last for the Accept-Language header
-if self.form.has_key("@language"):
+if "@language" in self.form:
 language = self.form["@language"].value
 if language.lower() == "none":
 language = ""
 self.add_cookie("roundup_language", language)
-elif self.cookie.has_key("roundup_language"):
+elif "roundup_language" in self.cookie:
 language = self.cookie["roundup_language"].value
 elif self.instance.config["WEB_USE_BROWSER_LANGUAGE"]:
 hal = self.env.get('HTTP_ACCEPT_LANGUAGE')
 language = accept_language.parse(hal)
 else:
 self.clean_up()
 user = None
 # first up, try http authorization if enabled
 if self.instance.config['WEB_HTTP_AUTH']:
-if self.env.has_key('REMOTE_USER'):
+if 'REMOTE_USER' in self.env:
 # we have external auth (e.g. by Apache)
 user = self.env['REMOTE_USER']
 elif self.env.get('HTTP_AUTHORIZATION', ''):
 # try handling Basic Auth ourselves
 auth = self.env['HTTP_AUTHORIZATION']
 """Check that the Anonymous user is actually allowed to use the web
 interface and short-circuit all further processing if they're not.
 """
 # allow Anonymous to use the "login" and "register" actions (noting
 # that "register" has its own "Register" permission check)
-if self.form.has_key(':action'):
+if ':action' in self.form:
 action = self.form[':action'].value.lower()
-elif self.form.has_key('@action'):
+elif '@action' in self.form:
 action = self.form['@action'].value.lower()
 else:
 action = None
 if action in ('login', 'register'):
 return
 return
 # otherwise for everything else
 if self.user == 'anonymous':
 if not self.db.security.hasPermission('Web Access', self.userid):
-raise Unauthorised, self._("Anonymous users are not "
+raise Unauthorised(self._("Anonymous users are not "
-"allowed to use the web interface")
+"allowed to use the web interface"))
 def opendb(self, username):
 """Open the database and set the current user.
 Opens a database once. On subsequent calls only the user is set on
 self.classname = None
 self.nodeid = None
 # see if a template or messages are specified
 template_override = ok_message = error_message = None
-for key in self.form.keys():
+for key in self.form:
 if self.FV_TEMPLATE.match(key):
 template_override = self.form[key].value
 elif self.FV_OK_MESSAGE.match(key):
 ok_message = self.form[key].value
 ok_message = clean_message(ok_message)
 self.template = template_override
 else:
 self.template = ''
 return
 elif path[0] in ('_file', '@@file'):
-raise SendStaticFile, os.path.join(*path[1:])
+raise SendStaticFile(os.path.join(*path[1:]))
 else:
 self.classname = path[0]
 if len(path) > 1:
 # send the file identified by the designator in path[0]
-raise SendFile, path[0]
+raise SendFile(path[0])
 # see if we got a designator
 m = dre.match(self.classname)
 if m:
 self.classname = m.group(1)
 self.nodeid = m.group(2)
 try:
 klass = self.db.getclass(self.classname)
 except KeyError:
-raise NotFound, '%s/%s'%(self.classname, self.nodeid)
+raise NotFound('%s/%s'%(self.classname, self.nodeid))
 if not klass.hasnode(self.nodeid):
-raise NotFound, '%s/%s'%(self.classname, self.nodeid)
+raise NotFound('%s/%s'%(self.classname, self.nodeid))
 # with a designator, we default to item view
 self.template = 'item'
 else:
 # with only a class, we default to index view
 self.template = 'index'
 # make sure the classname is valid
 try:
 self.db.getclass(self.classname)
 except KeyError:
-raise NotFound, self.classname
+raise NotFound(self.classname)
 # see if we have a template override
 if template_override is not None:
 self.template = template_override
 def serve_file(self, designator, dre=re.compile(r'([^\d]+)(\d+)')):
 """ Serve the file from the content property of the designated item.
 """
 m = dre.match(str(designator))
 if not m:
-raise NotFound, str(designator)
+raise NotFound(str(designator))
 classname, nodeid = m.group(1), m.group(2)
 try:
 klass = self.db.getclass(classname)
 except KeyError:
 # The classname was not valid.
-raise NotFound, str(designator)
+raise NotFound(str(designator))
 # perform the Anonymous user access check
 self.check_anonymous_access()
 # make sure we have the appropriate properties
 props = klass.getprops()
-if not props.has_key('type'):
+if 'type' not in props:
-raise NotFound, designator
+raise NotFound(designator)
-if not props.has_key('content'):
+if 'content' not in props:
-raise NotFound, designator
+raise NotFound(designator)
 # make sure we have permission
 if not self.db.security.hasPermission('View', self.userid,
 classname, 'content', nodeid):
-raise Unauthorised, self._("You are not allowed to view "
+raise Unauthorised(self._("You are not allowed to view "
-"this file.")
+"this file."))
 mime_type = klass.get(nodeid, 'type')
 # Can happen for msg class:
 if not mime_type:
 mime_type = 'text/plain'
 prefix = os.path.normpath(prefix)
 filename = os.path.normpath(os.path.join(prefix, file))
 if os.path.isfile(filename) and filename.startswith(prefix):
 break
 else:
-raise NotFound, file
+raise NotFound(file)
 # last-modified time
 lmt = os.stat(filename)[stat.ST_MTIME]
 # detemine meta-type
 ims = None
 # see if there's an if-modified-since...
 # XXX see which interfaces set this
 #if hasattr(self.request, 'headers'):
 #ims = self.request.headers.getheader('if-modified-since')
-if self.env.has_key('HTTP_IF_MODIFIED_SINCE'):
+if 'HTTP_IF_MODIFIED_SINCE' in self.env:
 # cgi will put the header in the env var
 ims = self.env['HTTP_IF_MODIFIED_SINCE']
 if ims:
 ims = rfc822.parsedate(ims)[:6]
 lmtt = time.gmtime(lmt)[:6]
 result = result.replace('</body>', s)
 return result
 except templating.NoTemplate, message:
 return '<strong>%s</strong>'%message
 except templating.Unauthorised, message:
-raise Unauthorised, str(message)
+raise Unauthorised(str(message))
 except:
 # everything else
 if self.instance.config.WEB_DEBUG:
 return cgitb.pt_html(i18n=self.translator)
 exc_info = sys.exc_info()
 except:
 # Reraise the original exception.  The user will
 # receive an error message, and the adminstrator will
 # receive a traceback, albeit with less information
 # than the one we tried to generate above.
-raise exc_info[0], exc_info[1], exc_info[2]
+raise exc_info[0](exc_info[1]).with_traceback(exc_info[2])
 # these are the actions that are available
 actions = (
 ('edit',        EditItemAction),
 ('editcsv',     EditCSVAction),
 user, bypassing the usual template rendering.
 We explicitly catch Reject and ValueError exceptions and
 present their messages to the user.
 """
-if self.form.has_key(':action'):
+if ':action' in self.form:
 action = self.form[':action'].value.lower()
-elif self.form.has_key('@action'):
+elif '@action' in self.form:
 action = self.form['@action'].value.lower()
 else:
 return None
 try:
 except (ValueError, Reject), err:
 self.error_message.append(str(err))
 def get_action_class(self, action_name):
 if (hasattr(self.instance, 'cgi_actions') and
-self.instance.cgi_actions.has_key(action_name)):
+action_name in self.instance.cgi_actions):
 # tracker-defined action
 action_klass = self.instance.cgi_actions[action_name]
 else:
 # go with a default
 for name, action_klass in self.actions:
 if name == action_name:
 break
 else:
-raise ValueError, 'No such action "%s"'%action_name
+raise ValueError('No such action "%s"'%action_name)
 return action_klass
 def _socket_op(self, call, *args, **kwargs):
 """Execute socket-related operation, catch common network errors
 self._socket_op(self.request.wfile.write, content)
 def write_html(self, content):
 if not self.headers_done:
 # at this point, we are sure about Content-Type
-if not self.additional_headers.has_key('Content-Type'):
+if 'Content-Type' not in self.additional_headers:
 self.additional_headers['Content-Type'] = \
 'text/html; charset=%s' % self.charset
 self.header()
 if self.env['REQUEST_METHOD'] == 'HEAD':
 # should just ignore the invalid Range header.
 if if_range:
 return None
 # Return code 416 with a Content-Range header giving the
 # allowable range.
-self.response_code = httplib.REQUESTED_RANGE_NOT_SATISFIABLE
+self.response_code = http_.client.REQUESTED_RANGE_NOT_SATISFIABLE
 self.setHeader("Content-Range", "bytes */%d" % length)
 return None
 # RFC 2616 10.2.7: 206 Partial Content
 #
 # Tell the client that we are honoring the Range request by
 # indicating that we are providing partial content.
-self.response_code = httplib.PARTIAL_CONTENT
+self.response_code = http_.client.PARTIAL_CONTENT
 # RFC 2616 14.16: Content-Range
 #
 # Tell the client what data we are providing.
 #
 #   content-range-spec = byte-content-range-spec
 # Send the HTTP header.
 self.header()
 # If the client doesn't actually want the body, or if we are
 # indicating an invalid range.
 if (self.env['REQUEST_METHOD'] == 'HEAD'
-or self.response_code == httplib.REQUESTED_RANGE_NOT_SATISFIABLE):
+or self.response_code == http_.client.REQUESTED_RANGE_NOT_SATISFIABLE):
 return
 # Use the optimized "sendfile" operation, if possible.
 if hasattr(self.request, "sendfile"):
 self._socket_op(self.request.sendfile, filename, offset, length)
 return
 headers.update(self.additional_headers)
 if headers.get('Content-Type', 'text/html') == 'text/html':
 headers['Content-Type'] = 'text/html; charset=utf-8'
-headers = headers.items()
+headers = list(headers.items())
-for ((path, name), (value, expire)) in self._cookies.items():
+for ((path, name), (value, expire)) in self._cookies.iteritems():
 cookie = "%s=%s; Path=%s;"%(name, value, path)
 if expire is not None:
-cookie += " expires=%s;"%Cookie._getdate(expire)
+cookie += " expires=%s;"%get_cookie_date(expire)
 headers.append(('Set-Cookie', cookie))
 self._socket_op(self.request.start_response, headers, response)
 self.headers_done = 1

Mercurial > p > roundup > code

comparison roundup/cgi/client.py @ 4362:74476eaac38a