lib/vstorage/__init__.py

   1 # -*- coding: utf-8 -*-
   2 #
   3 # This file is part of FNP-Redakcja, licensed under GNU Affero GPLv3 or later.
   4 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   5 #
   6 import os
   7 import tempfile
   8 import datetime
   9 import mimetypes
  10 import urllib
  11 import functools
  12
  13 import logging
  14 logger = logging.getLogger('fnp.hazlenut.vstorage')
  15
  16 # Note: we have to set these before importing Mercurial
  17 os.environ['HGENCODING'] = 'utf-8'
  18 os.environ['HGMERGE'] = "internal:merge"
  19
  20 import mercurial.hg
  21 import mercurial.revlog
  22 import mercurial.util
  23 from mercurial.match import exact as hg_exact_match
  24 from mercurial.cmdutil import walkchangerevs
  25
  26 from vstorage.hgui import SilentUI
  27
  28
  29 def urlquote(url, safe='/'):
  30     """Quotes URL
  31
  32     >>> urlquote(u'Za\u017c\xf3\u0142\u0107 g\u0119\u015bl\u0105 ja\u017a\u0144')
  33     'Za%C5%BC%C3%B3%C5%82%C4%87%20g%C4%99%C5%9Bl%C4%85%20ja%C5%BA%C5%84'
  34     """
  35     return urllib.quote(url.encode('utf-8', 'ignore'), safe)
  36
  37
  38 def urlunquote(url):
  39     """Unqotes URL
  40
  41     # >>> urlunquote('Za%C5%BC%C3%B3%C5%82%C4%87_g%C4%99%C5%9Bl%C4%85_ja%C5%BA%C5%84')
  42     # u'Za\u017c\xf3\u0142\u0107_g\u0119\u015bl\u0105 ja\u017a\u0144'
  43     """
  44     return unicode(urllib.unquote(url), 'utf-8', 'ignore')
  45
  46
  47 def find_repo_path(path):
  48     """Go up the directory tree looking for a Mercurial repository (a directory containing a .hg subdirectory)."""
  49     while not os.path.isdir(os.path.join(path, ".hg")):
  50         old_path, path = path, os.path.dirname(path)
  51         if path == old_path:
  52             return None
  53     return path
  54
  55
  56 def with_working_copy_locked(func):
  57     """A decorator for locking the repository when calling a method."""
  58
  59     @functools.wraps(func)
  60     def wrapped(self, *args, **kwargs):
  61         """Wrap the original function in locks."""
  62         wlock = self.repo.wlock()
  63         try:
  64             return func(self, *args, **kwargs)
  65         finally:
  66             wlock.release()
  67     return wrapped
  68
  69
  70 def with_storage_locked(func):
  71     """A decorator for locking the repository when calling a method."""
  72
  73     @functools.wraps(func)
  74     def wrapped(self, *args, **kwargs):
  75         """Wrap the original function in locks."""
  76         lock = self.repo.lock()
  77         try:
  78             return func(self, *args, **kwargs)
  79         finally:
  80             lock.release()
  81     return wrapped
  82
  83
  84 def guess_mime(file_name):
  85     """
  86     Guess file's mime type based on extension.
  87     Default of text/x-wiki for files without an extension.
  88
  89     >>> guess_mime('something.txt')
  90     'text/plain'
  91     >>> guess_mime('SomePage')
  92     'text/x-wiki'
  93     >>> guess_mime(u'ąęśUnicodePage')
  94     'text/x-wiki'
  95     >>> guess_mime('image.png')
  96     'image/png'
  97     >>> guess_mime('style.css')
  98     'text/css'
  99     >>> guess_mime('archive.tar.gz')
 100     'archive/gzip'
 101     """
 102
 103     mime, encoding = mimetypes.guess_type(file_name, strict=False)
 104     if encoding:
 105         mime = 'archive/%s' % encoding
 106     if mime is None:
 107         mime = 'text/x-wiki'
 108     return mime
 109
 110
 111 class DocumentNotFound(Exception):
 112     pass
 113
 114
 115 class VersionedStorage(object):
 116     """
 117     Provides means of storing text pages and keeping track of their
 118     change history, using Mercurial repository as the storage method.
 119     """
 120
 121     def __init__(self, path, charset=None):
 122         """
 123         Takes the path to the directory where the pages are to be kept.
 124         If the directory doen't exist, it will be created. If it's inside
 125         a Mercurial repository, that repository will be used, otherwise
 126         a new repository will be created in it.
 127         """
 128
 129         self.charset = charset or 'utf-8'
 130         self.path = path
 131         if not os.path.exists(self.path):
 132             os.makedirs(self.path)
 133         self.repo_path = find_repo_path(self.path)
 134
 135         self.ui = SilentUI()
 136
 137         if self.repo_path is None:
 138             self.repo_path = self.path
 139             create = True
 140         else:
 141             create = False
 142
 143         self.repo_prefix = self.path[len(self.repo_path):].strip('/')
 144         self.repo = mercurial.hg.repository(self.ui, self.repo_path,
 145                                             create=create)
 146
 147     def reopen(self):
 148         """Close and reopen the repo, to make sure we are up to date."""
 149         self.repo = mercurial.hg.repository(self.ui, self.repo_path)
 150
 151     def _file_path(self, title, type='.xml'):
 152         return os.path.join(self.path, urlquote(title, safe='')) + type
 153
 154     def _title_to_file(self, title, type=".xml"):
 155         return os.path.join(self.repo_prefix, urlquote(title, safe='')) + type
 156
 157     def _file_to_title(self, filename):
 158         assert filename.startswith(self.repo_prefix)
 159         name = filename[len(self.repo_prefix):].strip('/').split('.', 1)[0]
 160         return urlunquote(name)
 161
 162     def __contains__(self, title):
 163         return self._title_to_file(title) in self.repo['tip']
 164
 165     def __iter__(self):
 166         return self.all_pages()
 167
 168     def merge_changes(self, changectx, repo_file, text, user, parent):
 169         """Commits and merges conflicting changes in the repository."""
 170         tip_node = changectx.node()
 171         filectx = changectx[repo_file].filectx(parent)
 172         parent_node = filectx.changectx().node()
 173
 174         self.repo.dirstate.setparents(parent_node)
 175         node = self._commit([repo_file], text, user)
 176
 177         partial = lambda filename: repo_file == filename
 178
 179         # If p1 is equal to p2, there is no work to do. Even the dirstate is correct.
 180         p1, p2 = self.repo[None].parents()[0], self.repo[tip_node]
 181         if p1 == p2:
 182             return text
 183
 184         try:
 185             mercurial.merge.update(self.repo, tip_node, True, False, partial)
 186             msg = 'merge of edit conflict'
 187         except mercurial.util.Abort:
 188             msg = 'failed merge of edit conflict'
 189
 190         self.repo.dirstate.setparents(tip_node, node)
 191         # Mercurial 1.1 and later need updating the merge state
 192         try:
 193             mercurial.merge.mergestate(self.repo).mark(repo_file, "r")
 194         except (AttributeError, KeyError):
 195             pass
 196         return msg
 197
 198     @with_working_copy_locked
 199     @with_storage_locked
 200     def save_file(self, title, file_name, **kwargs):
 201         """Save an existing file as specified page."""
 202
 203         author = kwargs.get('author', u'anonymous').encode('utf-8')
 204         comment = kwargs.get('comment', u'Empty comment.').encode('utf-8')
 205         parent = kwargs.get('parent', None)
 206
 207         repo_file = self._title_to_file(title)
 208         file_path = self._file_path(title)
 209         mercurial.util.rename(file_name, file_path)
 210         changectx = self._changectx()
 211
 212         try:
 213             filectx_tip = changectx[repo_file]
 214             current_page_rev = filectx_tip.rev()
 215         except mercurial.revlog.LookupError:
 216             self.repo.add([repo_file])
 217             current_page_rev = -1
 218
 219         if parent is not None and current_page_rev != parent:
 220             msg = self.merge_changes(changectx, repo_file, comment, author, parent)
 221             author = '<wiki>'
 222             comment = msg.encode('utf-8')
 223
 224         logger.debug("Commiting %r", repo_file)
 225
 226         self._commit([repo_file], comment, author)
 227
 228     def save_data(self, title, data, **kwargs):
 229         """Save data as specified page."""
 230         try:
 231             temp_path = tempfile.mkdtemp(dir=self.path)
 232             file_path = os.path.join(temp_path, 'saved')
 233             f = open(file_path, "wb")
 234             f.write(data)
 235             f.close()
 236
 237             return self.save_file(title=title, file_name=file_path, **kwargs)
 238         finally:
 239             try:
 240                 os.unlink(file_path)
 241             except OSError:
 242                 pass
 243             try:
 244                 os.rmdir(temp_path)
 245             except OSError:
 246                 pass
 247
 248     def save_text(self, **kwargs):
 249         """Save text as specified page, encoded to charset."""
 250         text = kwargs.pop('text')
 251         return self.save_data(data=text.encode(self.charset), **kwargs)
 252
 253     def _commit(self, files, comment, user):
 254         match = mercurial.match.exact(self.repo_path, '', list(files))
 255         return self.repo.commit(match=match, text=comment, user=user, force=True)
 256
 257     @with_working_copy_locked
 258     @with_storage_locked
 259     def delete_page(self, title, author=u'', comment=u''):
 260         user = author.encode('utf-8') or 'anon'
 261         text = comment.encode('utf-8') or 'deleted'
 262         repo_file = self._title_to_file(title)
 263         file_path = self._file_path(title)
 264         try:
 265             os.unlink(file_path)
 266         except OSError:
 267             pass
 268         self.repo.remove([repo_file])
 269         self._commit([repo_file], text, user)
 270
 271     def page_text(self, title, revision=None):
 272         """Read unicode text of a page."""
 273         ctx = self._find_filectx(title, revision)
 274
 275         if ctx is None:
 276             raise DocumentNotFound(title)
 277
 278         return ctx.data().decode(self.charset, 'replace'), ctx.rev()
 279
 280     def page_text_by_tag(self, title, tag):
 281         """Read unicode text of a taged page."""
 282         fname = self._title_to_file(title)
 283         tag = u"{fname}#{tag}".format(**locals()).encode('utf-8')
 284
 285         try:
 286             ctx = self.repo[tag][fname]
 287             return ctx.data().decode(self.charset, 'replace'), ctx.rev()
 288         except IndexError:
 289             raise DocumentNotFound(fname)
 290
 291     @with_working_copy_locked
 292     def page_file_meta(self, title):
 293         """Get page's inode number, size and last modification time."""
 294         try:
 295             (_st_mode, st_ino, _st_dev, _st_nlink, _st_uid, _st_gid, st_size,
 296              _st_atime, st_mtime, _st_ctime) = os.stat(self._file_path(title))
 297         except OSError:
 298             return 0, 0, 0
 299         return st_ino, st_size, st_mtime
 300
 301     @with_working_copy_locked
 302     def page_meta(self, title, revision=None):
 303         """Get page's revision, date, last editor and his edit comment."""
 304         fctx = self._find_filectx(title, revision)
 305
 306         if fctx is None:
 307             raise DocumentNotFound(title)
 308
 309         return {
 310             "revision": fctx.rev(),
 311             "date": datetime.datetime.fromtimestamp(fctx.date()[0]),
 312             "author": fctx.user().decode("utf-8", 'replace'),
 313             "comment": fctx.description().decode("utf-8", 'replace'),
 314         }
 315
 316     def repo_revision(self):
 317         return self.repo['tip'].rev()
 318
 319     def _changectx(self):
 320         return self.repo['tip']
 321
 322     def page_mime(self, title):
 323         """
 324         Guess page's mime type based on corresponding file name.
 325         Default ot text/x-wiki for files without an extension.
 326         """
 327         return guess_mime(self._file_path(title))
 328
 329     def _find_filectx(self, title, rev=None, oldest=0, newest= -1):
 330         """Find the last revision in which the file existed."""
 331         if rev is not None:
 332             oldest, newest = rev, -1
 333         opts = {"follow": True, "rev": ["%s:%s" % (newest, oldest)]}
 334         def prepare(ctx, fns):
 335             pass
 336         xml_file = self._title_to_file(title)
 337         matchfn = hg_exact_match(self.repo.root, self.repo.getcwd(), [xml_file])
 338         generator = walkchangerevs(self.repo, matchfn, opts, prepare)
 339
 340         last = None
 341         current_name = xml_file
 342         for change in generator:
 343             fctx = change[current_name]
 344             renamed = fctx.renamed()
 345             if renamed:
 346                 current_name = renamed[0]
 347             last = change
 348
 349         if last is not None:
 350             return last[current_name]
 351
 352         # not found
 353         raise DocumentNotFound(title)
 354
 355     def page_history(self, title, oldest=0, newest= -1):
 356         """Iterate over the page's history."""
 357         opts = {"follow": True, "rev": ["%s:%s" % (newest, oldest)]}
 358         prepare = lambda * args: True
 359         repo_file = self._title_to_file(title)
 360         matchfn = hg_exact_match(self.repo.root, self.repo.getcwd(), [repo_file])
 361         generator = walkchangerevs(self.repo, matchfn, opts, prepare)
 362
 363         for changeset in generator:
 364             changeset
 365             date = datetime.datetime.fromtimestamp(changeset.date()[0])
 366             author = changeset.user().decode('utf-8', 'replace')
 367             comment = changeset.description().decode("utf-8", 'replace')
 368             tags = [t.rsplit('#', 1)[-1] for t in changeset.tags() if '#' in t]
 369
 370             yield {
 371                 "version": changeset.rev(),
 372                 "date": date,
 373                 "author": author,
 374                 "description": comment,
 375                 "tag": tags,
 376             }
 377
 378     @with_working_copy_locked
 379     def add_page_tag(self, title, rev, tag, user, doctag=True):
 380         ctitle = self._title_to_file(title)
 381
 382         if doctag:
 383             tag = u"{ctitle}#{tag}".format(**locals()).encode('utf-8')
 384
 385         message = u"Assigned tag {tag!r} to version {rev!r} of {ctitle!r}".format(**locals()).encode('utf-8')
 386
 387         fctx = self._find_filectx(title, rev)
 388         self.repo.tag(
 389             names=tag, node=fctx.node(), local=False,
 390             user=user, message=message, date=None,
 391         )
 392
 393     def history(self, newest=None):
 394         """Iterate over the history of entire wiki."""
 395         opts = {"follow": False, "rev": newest}  # follow doesn't make sense
 396         prepare = lambda * args: True
 397         repo_file = self._title_to_file(title)
 398         matchfn = hg_exact_match(self.repo.root, self.repo.getcwd(), [repo_file])
 399         generator = walkchangerevs(self.repo, matchfn, opts, prepare)
 400
 401         for change in generator:
 402             date = datetime.datetime.fromtimestamp(change.date()[0])
 403             author = change.user().decode('utf-8', 'replace')
 404             comment = change.description().decode("utf-8", 'replace')
 405             for repo_file in change.files():
 406                 title = self._file_to_title(repo_file)
 407                 yield title, change.rev(), date, author, comment
 408
 409     def all_pages(self, type=''):
 410         tip = self.repo['tip']
 411         """Iterate over the titles of all pages in the wiki."""
 412         return [self._file_to_title(filename) for filename in tip
 413                   if not filename.startswith('.')
 414                     and filename.endswith(type) ]
 415
 416     def revert(self, pageid, rev, **commit_args):
 417         """ Make the given version of page the current version (reverting changes). """
 418
 419         # Find the old version
 420         fctx = self._find_filectx(pageid, rev)
 421
 422         # Restore the contents
 423         self.save_data(pageid, fctx.data(), **commit_args)