4cfd59aa9a238b4e8097e57d4949a08ff98354b8
[redakcja.git] / lib / vstorage.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.ui
22 import mercurial.revlog
23 import mercurial.util
24
25
26 def urlquote(url, safe='/'):
27     """Quotes URL
28
29     >>> urlquote(u'Za\u017c\xf3\u0142\u0107 g\u0119\u015bl\u0105 ja\u017a\u0144')
30     'Za%C5%BC%C3%B3%C5%82%C4%87_g%C4%99%C5%9Bl%C4%85_ja%C5%BA%C5%84'
31     """
32     return urllib.quote(url.replace(' ', '_').encode('utf-8', 'ignore'), safe)
33
34
35 def urlunquote(url):
36     """Unqotes URL
37
38     # >>> urlunquote('Za%C5%BC%C3%B3%C5%82%C4%87_g%C4%99%C5%9Bl%C4%85_ja%C5%BA%C5%84')
39     # u'Za\u017c\xf3\u0142\u0107 g\u0119\u015bl\u0105 ja\u017a\u0144'
40     """
41     return unicode(urllib.unquote(url), 'utf-8', 'ignore').replace('_', ' ')
42
43
44 def find_repo_path(path):
45     """Go up the directory tree looking for a Mercurial repository (a directory containing a .hg subdirectory)."""
46     while not os.path.isdir(os.path.join(path, ".hg")):
47         old_path, path = path, os.path.dirname(path)
48         if path == old_path:
49             return None
50     return path
51
52
53 def with_working_copy_locked(func):
54     """A decorator for locking the repository when calling a method."""
55
56     @functools.wraps(func)
57     def wrapped(self, *args, **kwargs):
58         """Wrap the original function in locks."""
59         wlock = self.repo.wlock()
60         try:
61             return func(self, *args, **kwargs)
62         finally:
63             wlock.release()
64     return wrapped
65
66
67 def with_storage_locked(func):
68     """A decorator for locking the repository when calling a method."""
69
70     @functools.wraps(func)
71     def wrapped(self, *args, **kwargs):
72         """Wrap the original function in locks."""
73         lock = self.repo.lock()
74         try:
75             return func(self, *args, **kwargs)
76         finally:
77             lock.release()
78     return wrapped
79
80
81 def guess_mime(file_name):
82     """
83     Guess file's mime type based on extension.
84     Default of text/x-wiki for files without an extension.
85
86     >>> guess_mime('something.txt')
87     'text/plain'
88     >>> guess_mime('SomePage')
89     'text/x-wiki'
90     >>> guess_mime(u'ąęśUnicodePage')
91     'text/x-wiki'
92     >>> guess_mime('image.png')
93     'image/png'
94     >>> guess_mime('style.css')
95     'text/css'
96     >>> guess_mime('archive.tar.gz')
97     'archive/gzip'
98     """
99
100     mime, encoding = mimetypes.guess_type(file_name, strict=False)
101     if encoding:
102         mime = 'archive/%s' % encoding
103     if mime is None:
104         mime = 'text/x-wiki'
105     return mime
106
107
108 class DocumentNotFound(Exception):
109     pass
110
111
112 class VersionedStorage(object):
113     """
114     Provides means of storing text pages and keeping track of their
115     change history, using Mercurial repository as the storage method.
116     """
117
118     def __init__(self, path, charset=None):
119         """
120         Takes the path to the directory where the pages are to be kept.
121         If the directory doen't exist, it will be created. If it's inside
122         a Mercurial repository, that repository will be used, otherwise
123         a new repository will be created in it.
124         """
125
126         self.charset = charset or 'utf-8'
127         self.path = path
128         if not os.path.exists(self.path):
129             os.makedirs(self.path)
130         self.repo_path = find_repo_path(self.path)
131
132         self.ui = mercurial.ui.ui()
133         self.ui.quiet = True
134         self.ui._report_untrusted = False
135         self.ui.setconfig('ui', 'interactive', False)
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):
152         return os.path.join(self.path, urlquote(title, safe=''))
153
154     def _title_to_file(self, title):
155         return os.path.join(self.repo_prefix, urlquote(title, safe=''))
156
157     def _file_to_title(self, filename):
158         assert filename.startswith(self.repo_prefix)
159         name = filename[len(self.repo_prefix):].strip('/')
160         return urlunquote(name)
161
162     def __contains__(self, title):
163         return urlquote(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.filerev()
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         self._commit([repo_file], comment, author)
225
226     def save_data(self, title, data, **kwargs):
227         """Save data as specified page."""
228         try:
229             temp_path = tempfile.mkdtemp(dir=self.path)
230             file_path = os.path.join(temp_path, 'saved')
231             f = open(file_path, "wb")
232             f.write(data)
233             f.close()
234
235             return self.save_file(title=title, file_name=file_path, **kwargs)
236         finally:
237             try:
238                 os.unlink(file_path)
239             except OSError:
240                 pass
241             try:
242                 os.rmdir(temp_path)
243             except OSError:
244                 pass
245
246     def save_text(self, **kwargs):
247         """Save text as specified page, encoded to charset."""
248         text = kwargs.pop('text')
249         return self.save_data(data=text.encode(self.charset), **kwargs)
250
251     def _commit(self, files, comment, user):
252         match = mercurial.match.exact(self.repo_path, '', list(files))
253         return self.repo.commit(match=match, text=comment, user=user, force=True)
254
255     @with_working_copy_locked
256     @with_storage_locked
257     def delete_page(self, title, author=u'', comment=u''):
258         user = author.encode('utf-8') or 'anon'
259         text = comment.encode('utf-8') or 'deleted'
260         repo_file = self._title_to_file(title)
261         file_path = self._file_path(title)
262         try:
263             os.unlink(file_path)
264         except OSError:
265             pass
266         self.repo.remove([repo_file])
267         self._commit([repo_file], text, user)
268
269 #    @with_working_copy_locked
270 #    def _open_page(self, title):
271 #        if title not in self:
272 #            raise DocumentNotFound()
273 #
274 #        path = self._title_to_file(title)
275 #        logger.debug("Opening page %s", path)
276 #        try:
277 #            return self.repo.wfile(path, 'rb')
278 #        except IOError:
279 #            logger.exception("Failed to open page %s", title)
280 #            raise DocumentNotFound()
281
282     def page_text(self, title, revision=None):
283         """Read unicode text of a page."""
284         ctx = self._find_filectx(title, revision)
285         return ctx.data().decode(self.charset, 'replace'), ctx.filerev()
286
287     def page_text_by_tag(self, title, tag):
288         """Read unicode text of a taged page."""
289         tag = u"{title}#{tag}".format(**locals()).encode('utf-8')
290         fname = self._title_to_file(title)
291
292         try:
293             ctx = self.repo[tag][fname]
294             return ctx.data().decode(self.charset, 'replace'), ctx.filerev()
295         except IndexError:
296             raise DocumentNotFound()
297
298     @with_working_copy_locked
299     def page_file_meta(self, title):
300         """Get page's inode number, size and last modification time."""
301         try:
302             (_st_mode, st_ino, _st_dev, _st_nlink, _st_uid, _st_gid, st_size,
303              _st_atime, st_mtime, _st_ctime) = os.stat(self._file_path(title))
304         except OSError:
305             return 0, 0, 0
306         return st_ino, st_size, st_mtime
307
308     @with_working_copy_locked
309     def page_meta(self, title):
310         """Get page's revision, date, last editor and his edit comment."""
311         if not title in self:
312             raise DocumentNotFound()
313
314         filectx_tip = self._find_filectx(title)
315         if filectx_tip is None:
316             raise DocumentNotFound()
317         rev = filectx_tip.filerev()
318         filectx = filectx_tip.filectx(rev)
319         date = datetime.datetime.fromtimestamp(filectx.date()[0])
320         author = filectx.user().decode("utf-8", 'replace')
321         comment = filectx.description().decode("utf-8", 'replace')
322         return rev, date, author, comment
323
324     def repo_revision(self):
325         return self.repo['tip'].rev()
326
327     def _changectx(self):
328         return self.repo['tip']
329
330     def page_mime(self, title):
331         """
332         Guess page's mime type based on corresponding file name.
333         Default ot text/x-wiki for files without an extension.
334         """
335         return guess_mime(self._file_path(title))
336
337     def _find_filectx(self, title, rev=None):
338         """Find the last revision in which the file existed."""
339
340         repo_file = self._title_to_file(title)
341
342         changectx = self._changectx()  # start with tip
343         stack = [changectx]
344
345         while repo_file not in changectx:
346             if not stack:
347                 return None
348
349             changectx = stack.pop()
350             for parent in changectx.parents():
351                 if parent != changectx:
352                     stack.append(parent)
353
354         try:
355             fctx = changectx[repo_file]
356
357             if rev is not None:
358                 fctx = fctx.filectx(rev)
359                 fctx.filerev()
360
361             return fctx
362         except (IndexError, LookupError) as e:
363             raise DocumentNotFound()
364
365     def page_history(self, title):
366         """Iterate over the page's history."""
367
368         filectx_tip = self._find_filectx(title)
369
370         maxrev = filectx_tip.filerev()
371         minrev = 0
372         for rev in range(maxrev, minrev - 1, -1):
373             filectx = filectx_tip.filectx(rev)
374             date = datetime.datetime.fromtimestamp(filectx.date()[0])
375             author = filectx.user().decode('utf-8', 'replace')
376             comment = filectx.description().decode("utf-8", 'replace')
377             tags = [t.rsplit('#', 1)[-1] for t in filectx.changectx().tags() if '#' in t]
378
379             yield {
380                 "version": rev,
381                 "date": date,
382                 "author": author,
383                 "description": comment,
384                 "tag": tags,
385             }
386
387     @with_working_copy_locked
388     def add_page_tag(self, title, rev, tag, user, doctag=True):
389         if doctag:
390             tag = u"{title}#{tag}".format(**locals()).encode('utf-8')
391
392         message = u"Assigned tag {tag!r} to version {rev!r} of {title!r}".format(**locals()).encode('utf-8')
393
394         fctx = self._find_filectx(title, rev)
395         self.repo.tag(
396             names=tag, node=fctx.node(), local=False,
397             user=user, message=message, date=None,
398         )
399
400     def history(self):
401         """Iterate over the history of entire wiki."""
402
403         changectx = self._changectx()
404         maxrev = changectx.rev()
405         minrev = 0
406         for wiki_rev in range(maxrev, minrev - 1, -1):
407             change = self.repo.changectx(wiki_rev)
408             date = datetime.datetime.fromtimestamp(change.date()[0])
409             author = change.user().decode('utf-8', 'replace')
410             comment = change.description().decode("utf-8", 'replace')
411             for repo_file in change.files():
412                 if repo_file.startswith(self.repo_prefix):
413                     title = self._file_to_title(repo_file)
414                     try:
415                         rev = change[repo_file].filerev()
416                     except mercurial.revlog.LookupError:
417                         rev = -1
418                     yield title, rev, date, author, comment
419
420     def all_pages(self):
421         tip = self.repo['tip']
422         """Iterate over the titles of all pages in the wiki."""
423         return [urlunquote(filename) for filename in tip]
424
425     def changed_since(self, rev):
426         """Return all pages that changed since specified repository revision."""
427
428         try:
429             last = self.repo.lookup(int(rev))
430         except IndexError:
431             for page in self.all_pages():
432                 yield page
433                 return
434         current = self.repo.lookup('tip')
435         status = self.repo.status(current, last)
436         modified, added, removed, deleted, unknown, ignored, clean = status
437         for filename in modified + added + removed + deleted:
438             if filename.startswith(self.repo_prefix):
439                 yield self._file_to_title(filename)