527a245d64937f4aaf186c771afd07a69af14fbe
[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 def with_storage_locked(func):
67     """A decorator for locking the repository when calling a method."""
68
69     @functools.wraps(func)
70     def wrapped(self, *args, **kwargs):
71         """Wrap the original function in locks."""
72         lock = self.repo.lock()
73         try:
74             return func(self, *args, **kwargs)
75         finally:            
76             lock.release()
77     return wrapped
78
79 def guess_mime(file_name):
80     """
81     Guess file's mime type based on extension.
82     Default of text/x-wiki for files without an extension.
83
84     >>> guess_mime('something.txt')
85     'text/plain'
86     >>> guess_mime('SomePage')
87     'text/x-wiki'
88     >>> guess_mime(u'ąęśUnicodePage')
89     'text/x-wiki'
90     >>> guess_mime('image.png')
91     'image/png'
92     >>> guess_mime('style.css')
93     'text/css'
94     >>> guess_mime('archive.tar.gz')
95     'archive/gzip'
96     """
97
98     mime, encoding = mimetypes.guess_type(file_name, strict = False)
99     if encoding:
100         mime = 'archive/%s' % encoding
101     if mime is None:
102         mime = 'text/x-wiki'
103     return mime
104
105
106 class DocumentNotFound(Exception):
107     pass
108
109
110 class VersionedStorage(object):
111     """
112     Provides means of storing text pages and keeping track of their
113     change history, using Mercurial repository as the storage method.
114     """
115
116     def __init__(self, path, charset = None):
117         """
118         Takes the path to the directory where the pages are to be kept.
119         If the directory doen't exist, it will be created. If it's inside
120         a Mercurial repository, that repository will be used, otherwise
121         a new repository will be created in it.
122         """
123
124         self.charset = charset or 'utf-8'
125         self.path = path
126         if not os.path.exists(self.path):
127             os.makedirs(self.path)
128         self.repo_path = find_repo_path(self.path)
129         
130         self.ui = mercurial.ui.ui()
131         self.ui.quiet = True
132         self.ui._report_untrusted = False
133         self.ui.setconfig('ui', 'interactive', False)
134         
135         if self.repo_path is None:
136             self.repo_path = self.path
137             create = True
138         else:
139             create = False
140             
141         self.repo_prefix = self.path[len(self.repo_path):].strip('/')
142         self.repo = mercurial.hg.repository(self.ui, self.repo_path,
143                                             create = create)
144
145     def reopen(self):
146         """Close and reopen the repo, to make sure we are up to date."""
147         self.repo = mercurial.hg.repository(self.ui, self.repo_path)
148
149     def _file_path(self, title):
150         return os.path.join(self.path, urlquote(title, safe = ''))
151
152     def _title_to_file(self, title):
153         return os.path.join(self.repo_prefix, urlquote(title, safe = ''))
154
155     def _file_to_title(self, filename):
156         assert filename.startswith(self.repo_prefix)
157         name = filename[len(self.repo_prefix):].strip('/')
158         return urlunquote(name)
159
160     def __contains__(self, title):                        
161         return urlquote(title) in self.repo['tip']
162
163     def __iter__(self):
164         return self.all_pages()
165
166     def merge_changes(self, changectx, repo_file, text, user, parent):
167         """Commits and merges conflicting changes in the repository."""
168         tip_node = changectx.node()
169         filectx = changectx[repo_file].filectx(parent)
170         parent_node = filectx.changectx().node()
171
172         self.repo.dirstate.setparents(parent_node)
173         node = self._commit([repo_file], text, user)
174
175         partial = lambda filename: repo_file == filename
176
177         # If p1 is equal to p2, there is no work to do. Even the dirstate is correct.
178         p1, p2 = self.repo[None].parents()[0], self.repo[tip_node]
179         if p1 == p2:
180             return text
181
182         try:
183             mercurial.merge.update(self.repo, tip_node, True, False, partial)
184             msg = 'merge of edit conflict'
185         except mercurial.util.Abort:
186             msg = 'failed merge of edit conflict'
187
188         self.repo.dirstate.setparents(tip_node, node)
189         # Mercurial 1.1 and later need updating the merge state
190         try:
191             mercurial.merge.mergestate(self.repo).mark(repo_file, "r")
192         except (AttributeError, KeyError):
193             pass
194         return msg
195
196     @with_working_copy_locked
197     @with_storage_locked
198     def save_file(self, title, file_name, author = u'', comment = u'', parent = None):
199         """Save an existing file as specified page."""
200         user = author.encode('utf-8') or u'anonymous'.encode('utf-8')
201         text = comment.encode('utf-8') or u'comment'.encode('utf-8')
202         
203         repo_file = self._title_to_file(title)
204         file_path = self._file_path(title)
205         mercurial.util.rename(file_name, file_path)
206         changectx = self._changectx()
207         
208         try:
209             filectx_tip = changectx[repo_file]
210             current_page_rev = filectx_tip.filerev()
211         except mercurial.revlog.LookupError:
212             self.repo.add([repo_file])
213             current_page_rev = -1
214         
215         if parent is not None and current_page_rev != parent:
216             msg = self.merge_changes(changectx, repo_file, text, user, parent)
217             user = '<wiki>'
218             text = msg.encode('utf-8')
219             
220         self._commit([repo_file], text, user)
221         
222         
223     def save_data(self, title, data, **kwargs):
224         """Save data as specified page."""
225         try:
226             temp_path = tempfile.mkdtemp(dir = self.path)
227             file_path = os.path.join(temp_path, 'saved')
228             f = open(file_path, "wb")
229             f.write(data)
230             f.close()
231             self.save_file(title = title, file_name = file_path, **kwargs)
232         finally:
233             try:
234                 os.unlink(file_path)
235             except OSError:
236                 pass
237             try:
238                 os.rmdir(temp_path)
239             except OSError:
240                 pass
241
242     def save_text(self, text, **kwargs):
243         """Save text as specified page, encoded to charset.""" 
244         self.save_data(data = text.encode(self.charset), **kwargs)
245
246
247     def _commit(self, files, text, user):
248         match = mercurial.match.exact(self.repo_path, '', list(files))
249         return self.repo.commit(match = match, text = text, user = user, force = True)
250  
251     def page_text(self, title):
252         """Read unicode text of a page."""
253         data = self.open_page(title).read()
254         text = unicode(data, self.charset, 'replace')
255         return text
256
257     def page_lines(self, page):
258         for data in page:
259             yield unicode(data, self.charset, 'replace')
260
261     @with_working_copy_locked
262     @with_storage_locked
263     def delete_page(self, title, author = u'', comment = u''):
264         user = author.encode('utf-8') or 'anon'
265         text = comment.encode('utf-8') or 'deleted'
266         repo_file = self._title_to_file(title)
267         file_path = self._file_path(title)
268         try:
269             os.unlink(file_path)
270         except OSError:
271             pass
272         self.repo.remove([repo_file])
273         self._commit([repo_file], text, user)
274
275     @with_working_copy_locked
276     def open_page(self, title):
277         if title not in self:
278             raise DocumentNotFound()
279         
280         path = self._title_to_file(title)
281         logger.debug("Opening page %s", path)      
282         try:
283             return self.repo.wfile(path, 'rb')            
284         except IOError:
285             logger.exception("Failed to open page %s", title)
286             raise DocumentNotFound()
287
288     @with_working_copy_locked
289     def page_file_meta(self, title):
290         """Get page's inode number, size and last modification time."""
291         try:
292             (st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid, st_size,
293              st_atime, st_mtime, st_ctime) = os.stat(self._file_path(title))
294         except OSError:
295             return 0, 0, 0
296         return st_ino, st_size, st_mtime
297     
298     @with_working_copy_locked
299     def page_meta(self, title):
300         """Get page's revision, date, last editor and his edit comment."""
301         if not title in self:
302             raise DocumentNotFound()
303
304         filectx_tip = self._find_filectx(title)
305         if filectx_tip is None:
306             raise DocumentNotFound()
307         rev = filectx_tip.filerev()
308         filectx = filectx_tip.filectx(rev)
309         date = datetime.datetime.fromtimestamp(filectx.date()[0])
310         author = unicode(filectx.user(), "utf-8",
311                          'replace').split('<')[0].strip()
312         comment = unicode(filectx.description(), "utf-8", 'replace')
313         return rev, date, author, comment
314
315     def repo_revision(self):
316         return self.repo['tip'].rev()
317     
318     def _changectx(self):
319         return self.repo['tip']
320
321     def page_mime(self, title):
322         """
323         Guess page's mime type based on corresponding file name.
324         Default ot text/x-wiki for files without an extension.
325         """
326         return guess_mime(self._file_path(title))
327
328     def _find_filectx(self, title):
329         """Find the last revision in which the file existed."""
330
331         repo_file = self._title_to_file(title)
332         changectx = self._changectx()
333         stack = [changectx]
334         while repo_file not in changectx:
335             if not stack:
336                 return None
337             changectx = stack.pop()
338             for parent in changectx.parents():
339                 if parent != changectx:
340                     stack.append(parent)
341         return changectx[repo_file]
342
343     def page_history(self, title):
344         """Iterate over the page's history."""
345
346         filectx_tip = self._find_filectx(title)
347         if filectx_tip is None:
348             return
349         maxrev = filectx_tip.filerev()
350         minrev = 0
351         for rev in range(maxrev, minrev - 1, -1):
352             filectx = filectx_tip.filectx(rev)
353             date = datetime.datetime.fromtimestamp(filectx.date()[0])
354             author = unicode(filectx.user(), "utf-8",
355                              'replace').split('<')[0].strip()
356             comment = unicode(filectx.description(), "utf-8", 'replace')
357             tags = filectx.changectx().tags()
358             yield {
359                 "version": rev, 
360                 "date": date, 
361                 "author": author, 
362                 "description": comment,
363                 "tag": tags[0] if tags else None,
364             }
365
366     def page_revision(self, title, rev):
367         """Get unicode contents of specified revision of the page."""
368
369         filectx_tip = self._find_filectx(title)
370         if filectx_tip is None:
371             raise DocumentNotFound()
372         try:
373             data = filectx_tip.filectx(rev).data()
374         except IndexError:
375             raise DocumentNotFound()
376         return data
377
378     def revision_text(self, title, rev):
379         data = self.page_revision(title, rev)
380         text = unicode(data, self.charset, 'replace')
381         return text
382
383     def history(self):
384         """Iterate over the history of entire wiki."""
385
386         changectx = self._changectx()
387         maxrev = changectx.rev()
388         minrev = 0
389         for wiki_rev in range(maxrev, minrev - 1, -1):
390             change = self.repo.changectx(wiki_rev)
391             date = datetime.datetime.fromtimestamp(change.date()[0])
392             author = unicode(change.user(), "utf-8",
393                              'replace').split('<')[0].strip()
394             comment = unicode(change.description(), "utf-8", 'replace')
395             for repo_file in change.files():
396                 if repo_file.startswith(self.repo_prefix):
397                     title = self._file_to_title(repo_file)
398                     try:
399                         rev = change[repo_file].filerev()
400                     except mercurial.revlog.LookupError:
401                         rev = -1
402                     yield title, rev, date, author, comment
403
404     def all_pages(self):
405         tip = self.repo['tip']
406         """Iterate over the titles of all pages in the wiki."""
407         return [ urlunquote(filename) for filename in tip ]        
408
409     def changed_since(self, rev):
410         """Return all pages that changed since specified repository revision."""
411
412         try:
413             last = self.repo.lookup(int(rev))
414         except IndexError:
415             for page in self.all_pages():
416                 yield page
417                 return
418         current = self.repo.lookup('tip')
419         status = self.repo.status(current, last)
420         modified, added, removed, deleted, unknown, ignored, clean = status
421         for filename in modified + added + removed + deleted:
422             if filename.startswith(self.repo_prefix):
423                 yield self._file_to_title(filename)