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     def _changectx(self, nodeid):
 166         return self._hgrepo.changectx(nodeid)
 167
 168     #
 169     # BASIC BRANCH routines
 170     #
 171
 172     def _bname(self, user, docid):
 173         """Returns a branch name for a given document and user."""
 174         docid = self._sanitize_string(docid)
 175         uname = self._sanitize_string(user)
 176         return "personal_" + uname + "_file_" + docid;
 177
 178     def _has_branch(self, name):
 179         return self._hgrepo.branchmap().has_key(self._sanitize_string(name))
 180
 181     def _branch_tip(self, name):
 182         name = self._sanitize_string(name)
 183         return self._hgrepo.branchtags()[name]
 184
 185     def _create_branch(self, name, parent=None, before_commit=None):
 186         name = self._sanitize_string(name)
 187
 188         if self._has_branch(name): return # just exit
 189
 190         if parent is None:
 191             parent = self._maincab
 192
 193         parentrev = parent._hgtip()
 194
 195         self._checkout(parentrev)
 196         self._hgrepo.dirstate.setbranch(name)
 197
 198         if before_commit: before_commit(self)
 199
 200         self._commit("[AUTO] Initial commit for branch '%s'." % name, user='library')
 201
 202         # revert back to main
 203         self._checkout(self._maincab._hgtip())
 204         return self._branch_tip(name)
 205
 206     def _switch_to_branch(self, branchname):
 207         current = self._hgrepo[None].branch()
 208
 209         if current == branchname:
 210             return current # quick exit
 211
 212         self._checkout(self._branch_tip(branchname))
 213         return branchname
 214
 215     #
 216     # Merges
 217     #
 218
 219
 220
 221     #
 222     # Utils
 223     #
 224
 225     @staticmethod
 226     def _sanitize_string(s):
 227         if isinstance(s, unicode):
 228             s = s.encode('utf-8')
 229         return s
 230
 231 class MercurialCabinet(wlrepo.Cabinet):
 232
 233     def __init__(self, library, branchname, doc=None, user=None):
 234         if doc and user:
 235             super(MercurialCabinet, self).__init__(library, doc=doc, user=user)
 236         else:
 237             super(MercurialCabinet, self).__init__(library, name=branchname)
 238
 239         self._branchname = branchname
 240
 241     def shelf(self, selector=None):
 242         if selector is not None:
 243             raise NotImplementedException()
 244
 245         return MercurialShelf(self, self._library._changectx(self._branchname))
 246
 247     def documents(self):
 248         return self._execute_in_branch(action=lambda l, c: (e[1] for e in l._filelist()))
 249
 250     def retrieve(self, part=None, shelf=None):
 251         name, fileid = self._filename(part)
 252
 253         if fileid is None:
 254             raise wlrepo.LibraryException("Can't retrieve main document from main cabinet.")
 255
 256         return self._execute_in_branch(lambda l, c: MercurialDocument(c, name, fileid))
 257
 258     def create(self, name, initial_data):
 259         name, fileid = self._filename(name)
 260
 261         if name is None:
 262             raise ValueError("Can't create main doc for maincabinet.")
 263
 264         def create_action(l, c):
 265             if l._fileexists(fileid):
 266                 raise wlrepo.LibraryException("Can't create document '%s' in cabinet '%s' - it already exists" % (fileid, c.name))
 267
 268             fd = l._fileopener()(fileid, "w")
 269             fd.write(initial_data)
 270             fd.close()
 271             l._fileadd(fileid)
 272             l._commit("File '%s' created." % fileid)
 273             return MercurialDocument(c, fileid=fileid, name=name)
 274
 275         return self._execute_in_branch(create_action)
 276
 277     def exists(self, part=None, shelf=None):
 278         name, filepath = self._filename(part)
 279
 280         if filepath is None: return False
 281         return self._execute_in_branch(lambda l, c: l._fileexists(filepath))
 282
 283     def _execute_in_branch(self, action, write=False):
 284         def switch_action(library):
 285             old = library._switch_to_branch(self._branchname)
 286             try:
 287                 return action(library, self)
 288             finally:
 289                 library._switch_to_branch(old)
 290
 291         return self._library._transaction(write_mode=write, action=switch_action)
 292
 293     def _filename(self, part):
 294         part = self._library._sanitize_string(part)
 295         fileid = None
 296
 297         if self._maindoc == '':
 298             if part is None: return [None, None]
 299             fileid = part
 300         else:
 301             fileid = self._maindoc + (('$' + part) if part else '')
 302
 303         return fileid, 'pub_' + fileid + '.xml'
 304
 305     def _fileopener(self):
 306         return self._library._fileopener()
 307
 308     def _hgtip(self):
 309         return self._library._branch_tip(self._branchname)
 310
 311     def _filectx(self, fileid):
 312         return self._library._filectx(fileid, self._branchname)
 313
 314 class MercurialDocument(wlrepo.Document):
 315
 316     def __init__(self, cabinet, name, fileid):
 317         super(MercurialDocument, self).__init__(cabinet, name=name)
 318         self._opener = self._cabinet._fileopener()
 319         self._fileid = fileid
 320         self._refresh()
 321
 322     def _refresh(self):
 323         self._filectx = self._cabinet._filectx(self._fileid)
 324         self._shelf = MercurialShelf(self, self._filectx.node())
 325
 326     def read(self):
 327         return self._opener(self._filectx.path(), "r").read()
 328
 329     def write(self, data):
 330         return self._opener(self._filectx.path(), "w").write(data)
 331
 332     def commit(self, message, user):
 333         self.library._fileadd(self._fileid)
 334         self.library._commit(self._fileid, message, user)
 335
 336     def update(self):
 337         if self._cabinet.is_main():
 338             return True # always up-to-date
 339
 340         mdoc = self.library.document(self._fileid)
 341
 342         mshelf = mdoc.shelf()
 343         shelf = self.shelf()
 344
 345         if not mshelf.ancestorof(shelf) and not shelf.parentof(mshelf):
 346             shelf.merge_with(mshelf)
 347
 348         return rc.ALL_OK
 349
 350     def share(self, message, user):
 351         if self._cabinet.is_main():
 352             return True # always shared
 353
 354         main = self.shared_version()
 355         local = self.shelf()
 356
 357         no_changes = True
 358
 359         # Case 1:
 360         #         * local
 361         #         |
 362         #         * <- can also be here!
 363         #        /|
 364         #       / |
 365         # main *  *
 366         #      |  |
 367         # The local branch has been recently updated,
 368         # so we don't need to update yet again, but we need to
 369         # merge down to default branch, even if there was
 370         # no commit's since last update
 371
 372         if main.ancestorof(local):
 373             main.merge_with(local, user=user, message=message)
 374             no_changes = False
 375
 376         # Case 2:
 377         #
 378         # main *  * local
 379         #      |\ |
 380         #      | \|
 381         #      |  *
 382         #      |  |
 383         #
 384         # Default has no changes, to update from this branch
 385         # since the last merge of local to default.
 386         elif main.has_common_ancestor(local):
 387             if not local.parentof(main):
 388                 main.merge_with(local, user=user, message=message)
 389                 no_changes = False
 390
 391         # Case 3:
 392         # main *
 393         #      |
 394         #      * <- this case overlaps with previos one
 395         #      |\
 396         #      | \
 397         #      |  * local
 398         #      |  |
 399         #
 400         # There was a recent merge to the defaul branch and
 401         # no changes to local branch recently.
 402         #
 403         # Use the fact, that user is prepared to see changes, to
 404         # update his branch if there are any
 405         elif local.ancestorof(main):
 406             if not local.parentof(main):
 407                 local.merge_with(main, user=user, message='Local branch update.')
 408                 no_changes = False
 409         else:
 410             local.merge_with(main, user=user, message='Local branch update.')
 411
 412             self._refresh()
 413             local = self.shelf()
 414
 415             main.merge_with(local, user=user, message=message)
 416
 417     def shared(self):
 418         return self.library.document(self._fileid)
 419
 420     @property
 421     def size(self):
 422         return self._filectx.size()
 423
 424
 425     def shelf(self):
 426         return self._shelf
 427
 428     @property
 429     def last_modified(self):
 430         return self._filectx.date()
 431
 432     def __str__(self):
 433         return u"Document(%s->%s)" % (self._cabinet.name, self._name)
 434
 435
 436 class MercurialShelf(wlrepo.Shelf):
 437
 438     def __init__(self, cabinet, changectx):
 439         super(MercurialShelf, self).__init__(cabinet)
 440         self._changectx = changectx
 441
 442     @property
 443     def _rev(self):
 444         return self._changectx.node()
 445
 446     def __str__(self):
 447         return self._changectx.hex()
 448
 449
 450     def ancestorof(self, other):
 451         pass
 452
 453 class MergeStatus(object):
 454     def __init__(self, mstatus):
 455         self.updated = mstatus[0]
 456         self.merged = mstatus[1]
 457         self.removed = mstatus[2]
 458         self.unresolved = mstatus[3]
 459
 460     def isclean(self):
 461         return self.unresolved == 0
 462
 463 class UpdateStatus(object):
 464
 465     def __init__(self, mstatus):
 466         self.modified = mstatus[0]
 467         self.added = mstatus[1]
 468         self.removed = mstatus[2]
 469         self.deleted = mstatus[3]
 470         self.untracked = mstatus[4]
 471         self.ignored = mstatus[5]
 472         self.clean = mstatus[6]
 473
 474     def has_changes(self):
 475         return bool(len(self.modified) + len(self.added) + \
 476                     len(self.removed) + len(self.deleted))
 477
 478 __all__ = ["MercurialLibrary"]