Changeset 759:928f43458f43 in hatta-dev


Ignore:
Timestamp:
02/20/10 21:22:03 (2 years ago)
Author:
sheep@…
Branch:
default
Message:

use custom classes for errors

File:
1 edited

Legend:

Unmodified
Added
Removed

  • hatta.py

    r758 r759  
    125125        mime = 'text/x-wiki' 
    126126    return mime 
     127 
     128 
     129class WikiError(werkzeug.exceptions.HTTPException): 
     130    """Base class for all error pages.""" 
     131 
     132 
     133class ForbiddenErrErr(WikiError): 
     134    code = 403 
     135 
     136 
     137class NotFoundErrErr(WikiError): 
     138    code = 404 
     139 
     140 
     141class UnsupportedMediaTypeErr(WikiError): 
     142    code = 415 
     143 
     144 
     145class NotImplementedErr(WikiError): 
     146    code = 501 
     147 
     148 
     149class ServiceUnavailableErr(WikiError): 
     150    code = 503 
    127151 
    128152 
    … …  
    390414        abspath = os.path.abspath(path) 
    391415        if os.path.islink(path) or os.path.isdir(path): 
    392             raise werkzeug.exceptions.Forbidden( 
     416            raise ForbiddenErr( 
    393417                _(u"Can't use symbolic links or directories as pages")) 
    394418        if not abspath.startswith(self.path): 
    395             raise werkzeug.exceptions.Forbidden( 
     419            raise ForbiddenErr( 
    396420                _(u"Can't read or write outside of the pages repository")) 
    397421 
    … …  
    413437    def _file_to_title(self, filepath): 
    414438        if not filepath.startswith(self.repo_prefix): 
    415             raise werkzeug.exceptions.Forbidden( 
     439            raise ForbiddenErr( 
    416440                _(u"Can't read or write outside of the pages repository")) 
    417441        name = filepath[len(self.repo_prefix):].strip('/') 
    … …  
    549573            return open(file_path, "rb") 
    550574        except IOError: 
    551             raise werkzeug.exceptions.NotFound() 
     575            raise NotFoundErr() 
    552576 
    553577    def page_file_meta(self, title): 
    … …  
    566590        filectx_tip = self._find_filectx(title) 
    567591        if filectx_tip is None: 
    568             raise werkzeug.exceptions.NotFound() 
     592            raise NotFoundErr() 
    569593            #return -1, None, u'', u'' 
    570594        rev = filectx_tip.filerev() 
    … …  
    628652        filectx_tip = self._find_filectx(title) 
    629653        if filectx_tip is None: 
    630             raise werkzeug.exceptions.NotFound() 
     654            raise NotFoundErr() 
    631655        try: 
    632656            data = filectx_tip.filectx(rev).data() 
    633657        except IndexError: 
    634             raise werkzeug.exceptions.NotFound() 
     658            raise NotFoundErr() 
    635659        return data 
    636660 
    … …  
    720744        except OSError, e: 
    721745            if e.errno == 17 and not os.path.isdir(dir_path): 
    722                 raise werkzeug.exceptions.Forbidden( 
     746                raise ForbiddenErr( 
    723747                    _(u"Can't make subpages of existing pages")) 
    724748            elif e.errno != 17: 
    … …  
    14951519            try: 
    14961520                text = get_text() 
    1497             except werkzeug.exceptions.NotFound: 
     1521            except NotFoundErr: 
    14981522                text = u'' 
    14991523        extract_links = getattr(page, 'extract_links', lambda x: []) 
    … …  
    18701894                self.wiki._check_lock(self.title) 
    18711895                edit_url = self.get_url(self.title, self.wiki.edit) 
    1872             except werkzeug.exceptions.Forbidden: 
     1896            except ForbiddenErr: 
    18731897                pass 
    18741898 
    … …  
    19151939            self.wiki._check_lock(title) 
    19161940            read_only = False 
    1917         except werkzeug.exceptions.Forbidden: 
     1941        except ForbiddenErr: 
    19181942            read_only = True 
    19191943        for rev, date, author, comment in self.wiki.storage.page_history(title): 
    … …  
    19922016            if old_author == author: 
    19932017                comment = old_comment 
    1994         except werkzeug.exceptions.NotFound: 
     2018        except NotFoundErr: 
    19952019            comment = _(u'created') 
    19962020            rev = -1 
    1997         except werkzeug.exceptions.Forbidden, e: 
     2021        except ForbiddenErr, e: 
    19982022            yield werkzeug.html.p( 
    19992023                werkzeug.html(_(unicode(e)))) 
    … …  
    21172141            else: 
    21182142                lexer = pygments.lexers.guess_lexer(text) 
    2119         except pygments.util.ClassNotFound: 
     2143        except pygments.util.ClassNotFoundErr: 
    21202144            yield werkzeug.html.pre(werkzeug.html(text)) 
    21212145            return 
    … …  
    21442168            try: 
    21452169                text = self.storage.page_text(self.title) 
    2146             except werkzeug.exceptions.NotFound: 
     2170            except NotFoundErr: 
    21472171                text = u'' 
    21482172        return self.parser.extract_links(text) 
    … …  
    21882212    def view_content(self, lines=None): 
    21892213        if self.title not in self.storage: 
    2190             raise werkzeug.exceptions.NotFound() 
     2214            raise NotFoundErr() 
    21912215        content = ['<p>Download <a href="%s">%s</a> as <i>%s</i>.</p>' % 
    21922216                   (self.request.get_download_url(self.title), 
    … …  
    22292253    def view_content(self, lines=None): 
    22302254        if self.title not in self.storage: 
    2231             raise werkzeug.exceptions.NotFound() 
     2255            raise NotFoundErr() 
    22322256        content = ['<img src="%s" alt="%s">' 
    22332257                   % (self.request.get_url(self.title, self.wiki.render), 
    … …  
    22562280            im.save(cache_file,'PNG') 
    22572281        except IOError: 
    2258             raise werkzeug.exceptions.UnsupportedMediaType('Image corrupted') 
     2282            raise UnsupportedMediaTypeErr('Image corrupted') 
    22592283        cache_file.close() 
    22602284        return cache_path 
    … …  
    22852309    def view_content(self, lines=None): 
    22862310        if self.title not in self.storage: 
    2287             raise werkzeug.exceptions.NotFound() 
     2311            raise NotFoundErr() 
    22882312        return self.content_iter(lines) 
    22892313 
    … …  
    26212645        try: 
    26222646            content = page.view_content() 
    2623         except werkzeug.exceptions.NotFound: 
     2647        except NotFoundErr: 
    26242648            url = request.get_url(title, self.edit, external=True) 
    26252649            return werkzeug.routing.redirect(url, code=303) 
    … …  
    26622686        ] 
    26632687        if self.read_only: 
    2664             raise werkzeug.exceptions.Forbidden(_(u"This site is read-only.")) 
     2688            raise ForbiddenErr(_(u"This site is read-only.")) 
    26652689        if title in restricted_pages: 
    2666             raise werkzeug.exceptions.Forbidden(_(u"""Can't edit this page. 
     2690            raise ForbiddenErr(_(u"""Can't edit this page. 
    26672691It can only be edited by the site admin directly on the disk.""")) 
    26682692        if title in self.index.page_links(self.locked_page): 
    2669             raise werkzeug.exceptions.Forbidden(_(u"This page is locked.")) 
     2693            raise ForbiddenErr(_(u"This page is locked.")) 
    26702694 
    26712695    def save(self, request, title): 
    … …  
    26982722                    for link, label in page.extract_links(text): 
    26992723                        if title == link: 
    2700                             raise werkzeug.exceptions.Forbidden( 
     2724                            raise ForbiddenErr( 
    27012725                                _(u"This page is locked.")) 
    27022726                if u'href="' in comment or u'http:' in comment: 
    2703                     raise werkzeug.exceptions.Forbidden() 
     2727                    raise ForbiddenErr() 
    27042728                if text.strip() == '': 
    27052729                    self.storage.delete_page(title, author, comment) 
    … …  
    31543178            try: 
    31553179                text = self.storage.page_text(title) 
    3156             except werkzeug.exceptions.NotFound: 
     3180            except NotFoundErr: 
    31573181                return u'' 
    31583182            regexp = re.compile(u"|".join(re.escape(w) for w in words), 
    … …  
    32403264 
    32413265        if pygments is None: 
    3242             raise werkzeug.exceptions.NotFound() 
     3266            raise NotImplementedErr(_(u"Code highlighting is not available.")) 
    32433267 
    32443268        pygments_style = self.pygments_style 
    … …  
    32753299 
    32763300        if not self.config.get_bool('hgweb', False): 
    3277             raise werkzeug.exceptions.Forbidden( 
    3278                 _(u'Repository access disabled.')) 
     3301            raise ForbiddenErr(_(u'Repository access disabled.')) 
    32793302        app = mercurial.hgweb.request.wsgiapplication( 
    32803303            lambda: mercurial.hgweb.hgweb(self.storage.repo, self.site_name)) 
    … …  
    32923315 
    32933316        if not request.remote_addr.startswith('127.'): 
    3294             raise werkzeug.exceptions.Forbidden( 
    3295                 _(u'This URL can only be called locally.')) 
     3317            raise ForbiddenErr(_(u'This URL can only be called locally.')) 
    32963318        def agony(): 
    32973319            yield u'Oh dear!' 
Note: See TracChangeset for help on using the changeset viewer.