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 nullid
  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 ospath(self):
  65         return self._ospath
  66
  67     @property
  68     def main_cabinet(self):
  69         return self._maincab
  70
  71     def document(self, docid, user, part=None, shelve=None):
  72         return self.cabinet(docid, user, create=False).retrieve(part=part, shelve=shelve)
  73
  74     def cabinet(self, docid, user, create=False):
  75         docid = self._sanitize_string(docid)
  76         user = self._sanitize_string(user)
  77
  78         bname = self._bname(user, docid)
  79
  80         lock = self._lock(True)
  81         try:
  82             if self._has_branch(bname):
  83                 return MercurialCabinet(self, doc=docid, user=user)
  84
  85             if not create:
  86                 raise wlrepo.CabinetNotFound(bname)
  87
  88             # check if the docid exists in the main cabinet
  89             needs_touch = not self._maincab.exists(docid)
  90             cab = MercurialCabinet(self, doc=docid, user=user)
  91
  92             name, fileid = cab._filename(None)
  93
  94             def cleanup_action(l):
  95                 if needs_touch:
  96                     l._fileopener()(fileid, "w").write('')
  97                     l._fileadd(fileid)
  98
  99                 garbage = [fid for (fid, did) in l._filelist() if not did.startswith(docid)]
 100                 l._filesrm(garbage)
 101                 print "removed: ", garbage
 102
 103             # create the branch
 104             self._create_branch(bname, before_commit=cleanup_action)
 105             return MercurialCabinet(self, doc=docid, user=user)
 106         finally:
 107             lock.release()
 108
 109     #
 110     # Private methods
 111     #
 112
 113     #
 114     # Locking
 115     #
 116
 117     def _lock(self, write_mode=False):
 118         return self._hgrepo.wlock() # no support for read/write mode yet
 119
 120     def _transaction(self, write_mode, action):
 121         lock = self._lock(write_mode)
 122         try:
 123             return action(self)
 124         finally:
 125             lock.release()
 126
 127     #
 128     # Basic repo manipulation
 129     #
 130
 131     def _checkout(self, rev, force=True):
 132         return MergeStatus(mercurial.merge.update(self._hgrepo, rev, False, force, None))
 133
 134     def _merge(self, rev):
 135         """ Merge the revision into current working directory """
 136         return MergeStatus(mercurial.merge.update(self._hgrepo, rev, True, False, None))
 137
 138     def _common_ancestor(self, revA, revB):
 139         return self._hgrepo[revA].ancestor(self.repo[revB])
 140
 141     def _commit(self, message, user=u"library"):
 142         return self._hgrepo.commit(text=message, user=user)
 143
 144
 145     def _fileexists(self, fileid):
 146         return (fileid in self._hgrepo[None])
 147
 148     def _fileadd(self, fileid):
 149         return self._hgrepo.add([fileid])
 150
 151     def _filesadd(self, fileid_list):
 152         return self._hgrepo.add(fileid_list)
 153
 154     def _filerm(self, fileid):
 155         return self._hgrepo.remove([fileid])
 156
 157     def _filesrm(self, fileid_list):
 158         return self._hgrepo.remove(fileid_list)
 159
 160     def _filelist(self, filter=default_filter):
 161         for name in  self._hgrepo[None]:
 162             result = filter(name)
 163             if result is None: continue
 164
 165             yield result
 166
 167     def _fileopener(self):
 168         return self._hgrepo.wopener
 169
 170     def _filectx(self, fileid, branchid):
 171         return self._hgrepo.filectx(fileid, changeid=branchid)
 172
 173     def _changectx(self, nodeid):
 174         return self._hgrepo.changectx(nodeid)
 175
 176     #
 177     # BASIC BRANCH routines
 178     #
 179
 180     def _bname(self, user, docid):
 181         """Returns a branch name for a given document and user."""
 182         docid = self._sanitize_string(docid)
 183         uname = self._sanitize_string(user)
 184         return "personal_" + uname + "_file_" + docid;
 185
 186     def _has_branch(self, name):
 187         return self._hgrepo.branchmap().has_key(self._sanitize_string(name))
 188
 189     def _branch_tip(self, name):
 190         name = self._sanitize_string(name)
 191         return self._hgrepo.branchtags()[name]
 192
 193     def _create_branch(self, name, parent=None, before_commit=None):
 194         name = self._sanitize_string(name)
 195
 196         if self._has_branch(name): return # just exit
 197
 198         if parent is None:
 199             parent = self._maincab
 200
 201         parentrev = parent._hgtip()
 202
 203         self._checkout(parentrev)
 204         self._hgrepo.dirstate.setbranch(name)
 205
 206         if before_commit: before_commit(self)
 207
 208         self._commit("[AUTO] Initial commit for branch '%s'." % name, user='library')
 209
 210         # revert back to main
 211         self._checkout(self._maincab._hgtip())
 212         return self._branch_tip(name)
 213
 214     def _switch_to_branch(self, branchname):
 215         current = self._hgrepo[None].branch()
 216
 217         if current == branchname:
 218             return current # quick exit
 219
 220         self._checkout(self._branch_tip(branchname))
 221         return branchname
 222
 223     def shelf(self, nodeid=None):
 224         if nodeid is None:
 225             nodeid = self._maincab._name
 226         return MercurialShelf(self, self._changectx(nodeid))
 227
 228
 229     #
 230     # Utils
 231     #
 232
 233     @staticmethod
 234     def _sanitize_string(s):
 235         if isinstance(s, unicode):
 236             s = s.encode('utf-8')
 237         return s
 238
 239 class MercurialCabinet(wlrepo.Cabinet):
 240
 241     def __init__(self, library, branchname=None, doc=None, user=None):
 242         if doc and user:
 243             super(MercurialCabinet, self).__init__(library, doc=doc, user=user)
 244             self._branchname = library._bname(user=user, docid=doc)
 245         elif branchname:
 246             super(MercurialCabinet, self).__init__(library, name=branchname)
 247             self._branchname = branchname
 248         else:
 249             raise ValueError("Provide either doc/user or branchname")
 250
 251     def shelf(self):
 252         return self._library.shelf(self._branchname)
 253
 254     def parts(self):
 255         return self._execute_in_branch(action=lambda l, c: (e[1] for e in l._filelist()))
 256
 257     def retrieve(self, part=None, shelf=None):
 258         name, fileid = self._filename(part)
 259
 260         print "Retrieving document %s from cab %s" % (name, self._name)
 261
 262         if fileid is None:
 263             raise wlrepo.LibraryException("Can't retrieve main document from main cabinet.")
 264
 265         def retrieve_action(l,c):
 266             if l._fileexists(fileid):
 267                 return MercurialDocument(c, name=name, fileid=fileid)
 268             print "File %s not found " % fileid
 269             return None
 270
 271         return self._execute_in_branch(retrieve_action)
 272
 273     def create(self, name, initial_data):
 274         name, fileid = self._filename(name)
 275
 276         if name is None:
 277             raise ValueError("Can't create main doc for maincabinet.")
 278
 279         def create_action(l, c):
 280             if l._fileexists(fileid):
 281                 raise wlrepo.LibraryException("Can't create document '%s' in cabinet '%s' - it already exists" % (fileid, c.name))
 282
 283             fd = l._fileopener()(fileid, "w")
 284             fd.write(initial_data)
 285             fd.close()
 286             l._fileadd(fileid)
 287             l._commit("File '%s' created." % fileid)
 288             return MercurialDocument(c, fileid=fileid, name=name)
 289
 290         return self._execute_in_branch(create_action)
 291
 292     def exists(self, part=None, shelf=None):
 293         name, filepath = self._filename(part)
 294
 295         if filepath is None: return False
 296         return self._execute_in_branch(lambda l, c: l._fileexists(filepath))
 297
 298     def _execute_in_branch(self, action, write=False):
 299         def switch_action(library):
 300             old = library._switch_to_branch(self._branchname)
 301             try:
 302                 return action(library, self)
 303             finally:
 304                 library._switch_to_branch(old)
 305
 306         return self._library._transaction(write_mode=write, action=switch_action)
 307
 308
 309     def _filename(self, docid):
 310         return self._partname(docid, 'xml')
 311
 312     def _partname(self, docid, part):
 313         docid = self._library._sanitize_string(part)
 314         part = self._library._sanitize_string(part)
 315
 316         if part is None:
 317             part = 'xml'
 318
 319         if self._maindoc == '' and docid is None:
 320             return None
 321
 322         return 'pub_' + docid + '.' + part
 323
 324     def _fileopener(self):
 325         return self._library._fileopener()
 326
 327     def _hgtip(self):
 328         return self._library._branch_tip(self._branchname)
 329
 330     def _filectx(self, fileid):
 331         return self._library._filectx(fileid, self._branchname)
 332
 333     def ismain(self):
 334         return (self._library.main_cabinet == self)
 335
 336 class MercurialDocument(wlrepo.Document):
 337
 338     def __init__(self, cabinet, docid):
 339         super(MercurialDocument, self).__init__(cabinet, name=docid)
 340         self._opener = self._cabinet._fileopener()
 341         self._docid = docid
 342         self._ctxs = {}
 343
 344     def _ctx(self, part):
 345         if not self._ctxs.has_key(part):
 346             self._ctxs[part] = self._cabinet._filectx(self._fileid())
 347         return self._ctxs[part]
 348
 349     def _fileid(self, part='xml'):
 350         return self._cabinet._partname(self._docid, part)
 351
 352     def read(self, part='xml'):
 353         return self._opener(self._ctx(part).path(), "r").read()
 354
 355     def write(self, data, part='xml'):
 356         return self._opener(self._ctx(part).path(), "w").write(data)
 357
 358     def commit(self, message, user):
 359         """Commit all parts of the document."""
 360         self.library._fileadd(self._fileid)
 361         self.library._commit(self._fileid, message, user)
 362
 363     def update(self):
 364         """Update parts of the document."""
 365         lock = self.library._lock()
 366         try:
 367             if self._cabinet.ismain():
 368                 return True # always up-to-date
 369
 370             user = self._cabinet.username or 'library'
 371             mdoc = self.library.document(self._fileid)
 372
 373             mshelf = mdoc.shelf()
 374             shelf = self.shelf()
 375
 376             if not mshelf.ancestorof(shelf) and not shelf.parentof(mshelf):
 377                 shelf.merge_with(mshelf, user=user)
 378
 379             return True
 380         finally:
 381             lock.release()
 382
 383     def share(self, message):
 384         lock = self.library._lock()
 385         try:
 386             print "sharing from", self._cabinet, self._cabinet.username
 387
 388             if self._cabinet.ismain():
 389                 return True # always shared
 390
 391             if self._cabinet.username is None:
 392                 raise ValueError("Can only share documents from personal cabinets.")
 393
 394             user = self._cabinet.username
 395
 396             main = self.library.shelf()
 397             local = self.shelf()
 398
 399             no_changes = True
 400
 401             # Case 1:
 402             #         * local
 403             #         |
 404             #         * <- can also be here!
 405             #        /|
 406             #       / |
 407             # main *  *
 408             #      |  |
 409             # The local branch has been recently updated,
 410             # so we don't need to update yet again, but we need to
 411             # merge down to default branch, even if there was
 412             # no commit's since last update
 413
 414             if main.ancestorof(local):
 415                 print "case 1"
 416                 main.merge_with(local, user=user, message=message)
 417                 no_changes = False
 418             # Case 2:
 419             #
 420             # main *  * local
 421             #      |\ |
 422             #      | \|
 423             #      |  *
 424             #      |  |
 425             #
 426             # Default has no changes, to update from this branch
 427             # since the last merge of local to default.
 428             elif local.has_common_ancestor(main):
 429                 print "case 2"
 430                 if not local.parentof(main):
 431                     main.merge_with(local, user=user, message=message)
 432                     no_changes = False
 433
 434             # Case 3:
 435             # main *
 436             #      |
 437             #      * <- this case overlaps with previos one
 438             #      |\
 439             #      | \
 440             #      |  * local
 441             #      |  |
 442             #
 443             # There was a recent merge to the defaul branch and
 444             # no changes to local branch recently.
 445             #
 446             # Use the fact, that user is prepared to see changes, to
 447             # update his branch if there are any
 448             elif local.ancestorof(main):
 449                 print "case 3"
 450                 if not local.parentof(main):
 451                     local.merge_with(main, user=user, message='Local branch update.')
 452                     no_changes = False
 453             else:
 454                 print "case 4"
 455                 local.merge_with(main, user=user, message='Local branch update.')
 456                 local = self.shelf()
 457                 main.merge_with(local, user=user, message=message)
 458
 459             print "no_changes: ", no_changes
 460             return no_changes
 461         finally:
 462             lock.release()
 463
 464     def shared(self):
 465         return self.library.main_cabinet.retrieve(self._name)
 466
 467     def exists(self, part='xml'):
 468         return self._cabinet.exists(self._fileid(part))
 469
 470     @property
 471     def size(self):
 472         return self._filectx.size()
 473
 474     def shelf(self):
 475         return self._cabinet.shelf()
 476
 477     @property
 478     def last_modified(self):
 479         return self._filectx.date()
 480
 481     def __str__(self):
 482         return u"Document(%s->%s)" % (self._cabinet.name, self._name)
 483
 484     def __eq__(self, other):
 485         return self._filectx == other._filectx
 486
 487
 488
 489 class MercurialShelf(wlrepo.Shelf):
 490
 491     def __init__(self, lib, changectx):
 492         super(MercurialShelf, self).__init__(lib)
 493
 494         if isinstance(changectx, str):
 495             self._changectx = lib._changectx(changectx)
 496         else:
 497             self._changectx = changectx
 498
 499     @property
 500     def _rev(self):
 501         return self._changectx.node()
 502
 503     def __str__(self):
 504         return self._changectx.hex()
 505
 506     def __repr__(self):
 507         return "MercurialShelf(%s)" % self._changectx.hex()
 508
 509     def ancestorof(self, other):
 510         nodes = list(other._changectx._parents)
 511         while nodes[0].node() != nullid:
 512             v = nodes.pop(0)
 513             if v == self._changectx:
 514                 return True
 515             nodes.extend( v._parents )
 516         return False
 517
 518     def parentof(self, other):
 519         return self._changectx in other._changectx._parents
 520
 521     def has_common_ancestor(self, other):
 522         a = self._changectx.ancestor(other._changectx)
 523         # print a, self._changectx.branch(), a.branch()
 524
 525         return (a.branch() == self._changectx.branch())
 526
 527     def merge_with(self, other, user, message):
 528         lock = self._library._lock(True)
 529         try:
 530             self._library._checkout(self._changectx.node())
 531             self._library._merge(other._changectx.node())
 532             self._library._commit(user=user, message=message)
 533         finally:
 534             lock.release()
 535
 536     def __eq__(self, other):
 537         return self._changectx.node() == other._changectx.node()
 538
 539
 540 class MergeStatus(object):
 541     def __init__(self, mstatus):
 542         self.updated = mstatus[0]
 543         self.merged = mstatus[1]
 544         self.removed = mstatus[2]
 545         self.unresolved = mstatus[3]
 546
 547     def isclean(self):
 548         return self.unresolved == 0
 549
 550 class UpdateStatus(object):
 551
 552     def __init__(self, mstatus):
 553         self.modified = mstatus[0]
 554         self.added = mstatus[1]
 555         self.removed = mstatus[2]
 556         self.deleted = mstatus[3]
 557         self.untracked = mstatus[4]
 558         self.ignored = mstatus[5]
 559         self.clean = mstatus[6]
 560
 561     def has_changes(self):
 562         return bool(len(self.modified) + len(self.added) + \
 563                     len(self.removed) + len(self.deleted))
 564
 565 __all__ = ["MercurialLibrary"]