127112225d9c85b64a7d117c2eaa9d5c581a032d
[redakcja.git] / lib / wlrepo / backend_mercurial.py
1 # -*- encoding: utf-8 -*-
2
3 __author__ = "Ɓukasz Rekucki"
4 __date__ = "$2009-09-18 10:49:24$"
5
6 __doc__ = """RAL implementation over Mercurial"""
7
8 import mercurial
9 from mercurial import localrepo as hglrepo
10 from mercurial import ui as hgui
11 from mercurial.node import hex as to_hex
12 import re
13 import wlrepo
14
15 FILTER = re.compile(r"^pub_(.+)\.xml$", re.UNICODE)
16
17 def default_filter(name):
18     m = FILTER.match(name)    
19     if m is not None:
20         return name, m.group(1)
21     return None
22
23 class MercurialLibrary(wlrepo.Library):
24
25     def __init__(self, path, maincabinet="default", ** kwargs):
26         super(wlrepo.Library, self).__init__( ** kwargs)
27
28         self._hgui = hgui.ui()
29         self._hgui.config('ui', 'quiet', 'true')
30         self._hgui.config('ui', 'interactive', 'false')
31
32         import os.path        
33         self._ospath = self._sanitize_string(os.path.realpath(path))
34         
35         maincabinet = self._sanitize_string(maincabinet)
36
37         if os.path.isdir(path):
38             try:
39                 self._hgrepo = hglrepo.localrepository(self._hgui, path)
40             except mercurial.error.RepoError:
41                 raise wlrepo.LibraryException("[HGLibrary] Not a valid repository at path '%s'." % path)
42         elif kwargs.get('create', False):
43             os.makedirs(path)
44             try:
45                 self._hgrepo = hglrepo.localrepository(self._hgui, path, create=1)
46             except mercurial.error.RepoError:
47                 raise wlrepo.LibraryException("[HGLibrary] Can't create a repository on path '%s'." % path)
48         else:
49             raise wlrepo.LibraryException("[HGLibrary] Can't open a library on path '%s'." % path)
50
51         # fetch the main cabinet
52         lock = self._hgrepo.lock()
53         try:
54             btags = self._hgrepo.branchtags()
55             
56             if not self._has_branch(maincabinet):
57                 raise wlrepo.LibraryException("[HGLibrary] No branch named '%s' to init main cabinet" % maincabinet)
58         
59             self._maincab = MercurialCabinet(self, maincabinet)
60         finally:
61             lock.release()
62
63     @property
64     def main_cabinet(self):
65         return self._maincab
66
67     def document(self, docid, user):
68         return self.cabinet(docid, user, create=False).retrieve()
69
70     def cabinet(self, docid, user, create=False):
71         bname = self._bname(user, docid)
72
73         lock = self._lock(True)
74         try:
75             if self._has_branch(bname):
76                 return MercurialCabinet(self, bname, doc=docid, user=user)
77
78             if not create:
79                 raise wlrepo.CabinetNotFound(bname)
80
81             # check if the docid exists in the main cabinet
82             needs_touch = not self._maincab.exists(docid)            
83             cab = MercurialCabinet(self, bname, doc=docid, user=user)
84
85             name, fileid = cab._filename(None)
86
87             def cleanup_action(l):
88                 if needs_touch:                    
89                     l._fileopener()(fileid, "w").write('')
90                     l._fileadd(fileid)
91                 
92                 garbage = [fid for (fid, did) in l._filelist() if not did.startswith(docid)]                
93                 l._filesrm(garbage)
94
95             # create the branch
96             self._create_branch(bname, before_commit=cleanup_action)
97             return MercurialCabinet(self, bname, doc=docid, user=user)
98         finally:
99             lock.release()
100             
101     #
102     # Private methods
103     #
104
105     #
106     # Locking
107     #
108  
109     def _lock(self, write_mode=False):
110         return self._hgrepo.wlock() # no support for read/write mode yet
111
112     def _transaction(self, write_mode, action):
113         lock = self._lock(write_mode)
114         try:
115             return action(self)
116         finally:
117             lock.release()
118             
119     #
120     # Basic repo manipulation
121     #   
122
123     def _checkout(self, rev, force=True):
124         return MergeStatus(mercurial.merge.update(self._hgrepo, rev, False, force, None))
125
126     def _merge(self, rev):
127         """ Merge the revision into current working directory """
128         return MergeStatus(mercurial.merge.update(self._hgrepo, rev, True, False, None))
129     
130     def _common_ancestor(self, revA, revB):
131         return self._hgrepo[revA].ancestor(self.repo[revB])
132
133     def _commit(self, message, user=u"library"):
134         return self._hgrepo.commit(text=message, user=user)
135
136
137     def _fileexists(self, fileid):
138         return (fileid in self._hgrepo[None])
139
140     def _fileadd(self, fileid):
141         return self._hgrepo.add([fileid])
142     
143     def _filesadd(self, fileid_list):
144         return self._hgrepo.add(fileid_list)
145
146     def _filerm(self, fileid):
147         return self._hgrepo.remove([fileid])
148
149     def _filesrm(self, fileid_list):
150         return self._hgrepo.remove(fileid_list)
151
152     def _filelist(self, filter=default_filter):
153         for name in  self._hgrepo[None]:
154             result = filter(name)
155             if result is None: continue
156             
157             yield result
158
159     def _fileopener(self):
160         return self._hgrepo.wopener
161
162     def _filectx(self, fileid, branchid):
163         return self._hgrepo.filectx(fileid, changeid=branchid)
164     
165     #
166     # BASIC BRANCH routines
167     #
168
169     def _bname(self, user, docid):
170         """Returns a branch name for a given document and user."""
171         docid = self._sanitize_string(docid)
172         uname = self._sanitize_string(user)
173         return "personal_" + uname + "_file_" + docid;
174
175     def _has_branch(self, name):
176         return self._hgrepo.branchmap().has_key(self._sanitize_string(name))
177
178     def _branch_tip(self, name):
179         name = self._sanitize_string(name)
180         return self._hgrepo.branchtags()[name]
181
182     def _create_branch(self, name, parent=None, before_commit=None):        
183         name = self._sanitize_string(name)
184
185         if self._has_branch(name): return # just exit
186
187         if parent is None:
188             parent = self._maincab
189
190         parentrev = parent._hgtip()
191
192         self._checkout(parentrev)
193         self._hgrepo.dirstate.setbranch(name)
194
195         if before_commit: before_commit(self)
196
197         self._commit("[AUTO] Initial commit for branch '%s'." % name, user='library')
198         
199         # revert back to main
200         self._checkout(self._maincab._hgtip())
201         return self._branch_tip(name)
202
203     def _switch_to_branch(self, branchname):
204         current = self._hgrepo[None].branch()
205
206         if current == branchname:
207             return current # quick exit
208         
209         self._checkout(self._branch_tip(branchname))
210         return branchname        
211
212     #
213     # Merges
214     #
215     
216
217
218     #
219     # Utils
220     #
221
222     @staticmethod
223     def _sanitize_string(s):        
224         if isinstance(s, unicode):
225             s = s.encode('utf-8')
226         return s
227
228 class MercurialCabinet(wlrepo.Cabinet):
229     
230     def __init__(self, library, branchname, doc=None, user=None):
231         if doc and user:
232             super(MercurialCabinet, self).__init__(library, doc=doc, user=user)
233         else:
234             super(MercurialCabinet, self).__init__(library, name=branchname)
235             
236         self._branchname = branchname
237
238     def shelf(self, selector=None):
239         if selector is not None:
240             raise NotImplementedException()
241
242         return MercurialShelf(self, self._hgtip())
243
244     def documents(self):        
245         return self._execute_in_branch(action=lambda l, c: (e[1] for e in l._filelist()))
246
247     def retrieve(self, part=None, shelf=None):
248         name, fileid = self._filename(part)
249
250         if fileid is None:
251             raise wlrepo.LibraryException("Can't retrieve main document from main cabinet.")
252                 
253         return self._execute_in_branch(lambda l, c: MercurialDocument(c, name, fileid))
254
255     def create(self, name, initial_data):
256         name, fileid = self._filename(name)
257
258         if name is None:
259             raise ValueError("Can't create main doc for maincabinet.")
260
261         def create_action(l, c):
262             if l._fileexists(fileid):
263                 raise wlrepo.LibraryException("Can't create document '%s' in cabinet '%s' - it already exists" % (fileid, c.name))
264
265             fd = l._fileopener()(fileid, "w")
266             fd.write(initial_data)
267             fd.close()
268             l._fileadd(fileid)            
269             l._commit("File '%s' created." % fileid)            
270             return MercurialDocument(c, fileid=fileid, name=name)           
271
272         return self._execute_in_branch(create_action)
273
274     def exists(self, part=None, shelf=None):
275         name, filepath = self._filename(part)
276
277         if filepath is None: return False
278         return self._execute_in_branch(lambda l, c: l._fileexists(filepath))
279     
280     def _execute_in_branch(self, action, write=False):
281         def switch_action(library):
282             old = library._switch_to_branch(self._branchname)
283             try:
284                 return action(library, self)
285             finally:
286                 library._switch_to_branch(old)
287
288         return self._library._transaction(write_mode=write, action=switch_action)
289
290     def _filename(self, part):
291         part = self._library._sanitize_string(part)
292         fileid = None
293
294         if self._maindoc == '':
295             if part is None: return [None, None]
296             fileid = part
297         else:
298             fileid = self._maindoc + (('$' + part) if part else '')
299
300         return fileid, 'pub_' + fileid + '.xml'
301
302     def _fileopener(self):
303         return self._library._fileopener()
304
305     def _hgtip(self):
306         return self._library._branch_tip(self._branchname)
307
308     def _filectx(self, fileid):
309         return self._library._filectx(fileid, self._branchname)
310
311 class MercurialDocument(wlrepo.Document):
312
313     def __init__(self, cabinet, name, fileid):
314         super(MercurialDocument, self).__init__(cabinet, name=name)
315         self._opener = self._cabinet._fileopener()
316         self._fileid = fileid
317         self._refresh()
318
319     def _refresh(self):
320         self._filectx = self._cabinet._filectx(self._fileid)
321         self._shelf = MercurialShelf(self, self._filectx.node())
322
323     def read(self):
324         return self._opener(self._filectx.path(), "r").read()
325
326     def write(self, data):
327         return self._opener(self._filectx.path(), "w").write(data)
328
329     def commit(self, message, user):
330         self.library._fileadd(self._fileid)
331         self.library._commit(self._fileid, message, user)
332
333     def update(self):
334         if self._cabinet.is_main():
335             return True # always up-to-date
336
337         mdoc = self.library.document(self._fileid)
338
339         mshelf = mdoc.shelf()
340         shelf = self.shelf()
341
342         if not mshelf.ancestorof(shelf) and not shelf.parentof(mshelf):
343             shelf.merge_with(mshelf)
344
345         return rc.ALL_OK
346
347     def share(self, message, user):
348         if self._cabinet.is_main():
349             return True # always shared
350
351         main = self.shared_version()
352         local = self.shelf()
353
354         no_changes = True
355
356         # Case 1:
357         #         * local
358         #         |
359         #         * <- can also be here!
360         #        /|
361         #       / |
362         # main *  *
363         #      |  |
364         # The local branch has been recently updated,
365         # so we don't need to update yet again, but we need to
366         # merge down to default branch, even if there was
367         # no commit's since last update
368
369         if main.ancestorof(local):
370             main.merge_with(local, user=user, message=message)
371             no_changes = False
372             
373         # Case 2:
374         #
375         # main *  * local
376         #      |\ |
377         #      | \|
378         #      |  *
379         #      |  |
380         #
381         # Default has no changes, to update from this branch
382         # since the last merge of local to default.
383         elif main.has_common_ancestor(local):
384             if not local.parentof(main):
385                 main.merge_with(local, user=user, message=message)
386                 no_changes = False
387
388         # Case 3:
389         # main *
390         #      |
391         #      * <- this case overlaps with previos one
392         #      |\
393         #      | \
394         #      |  * local
395         #      |  |
396         #
397         # There was a recent merge to the defaul branch and
398         # no changes to local branch recently.
399         #
400         # Use the fact, that user is prepared to see changes, to
401         # update his branch if there are any
402         elif local.ancestorof(main):
403             if not local.parentof(main):
404                 local.merge_with(main, user=user, message='Local branch update.')
405                 no_changes = False
406         else:
407             local.merge_with(main, user=user, message='Local branch update.')
408
409             self._refresh()
410             local = self.shelf()
411
412             main.merge_with(local, user=user, message=message)
413                
414     def shared(self):
415         return self.library.document(self._fileid)
416
417     @property
418     def size(self):
419         return self._filectx.size()
420
421     
422     def shelf(self):
423         return self._shelf
424
425     @property
426     def last_modified(self):
427         return self._filectx.date()
428
429     def __str__(self):
430         return u"Document(%s->%s)" % (self._cabinet.name, self._name)
431
432
433 class MercurialShelf(wlrepo.Shelf):
434
435     def __init__(self, cabinet, revision):
436         super(MercurialShelf, self).__init__(cabinet)
437         self._revision = revision
438
439     @property
440     def _rev(self):
441         return _revision
442
443     def __str__(self):
444         return to_hex(self._revision)
445
446
447 class MergeStatus(object):
448     def __init__(self, mstatus):
449         self.updated = mstatus[0]
450         self.merged = mstatus[1]
451         self.removed = mstatus[2]
452         self.unresolved = mstatus[3]
453
454     def isclean(self):
455         return self.unresolved == 0
456
457 class UpdateStatus(object):
458
459     def __init__(self, mstatus):
460         self.modified = mstatus[0]
461         self.added = mstatus[1]
462         self.removed = mstatus[2]
463         self.deleted = mstatus[3]
464         self.untracked = mstatus[4]
465         self.ignored = mstatus[5]
466         self.clean = mstatus[6]
467
468     def has_changes(self):
469         return bool(len(self.modified) + len(self.added) + \
470                     len(self.removed) + len(self.deleted))
471
472 __all__ = ["MercurialLibrary"]