usr/src/tools/onbld/Scm/Backup.py

   1 #
   2 #  This program is free software; you can redistribute it and/or modify
   3 #  it under the terms of the GNU General Public License version 2
   4 #  as published by the Free Software Foundation.
   5 #
   6 #  This program is distributed in the hope that it will be useful,
   7 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
   8 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   9 #  GNU General Public License for more details.
  10 #
  11 #  You should have received a copy of the GNU General Public License
  12 #  along with this program; if not, write to the Free Software
  13 #  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  14 #
  15
  16 #
  17 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  18 # Use is subject to license terms.
  19 #
  20 # Copyright 2008, 2011, Richard Lowe
  21 #
  22
  23
  24 '''
  25 Workspace backup
  26
  27 Backup format is:
  28    backupdir/
  29       wsname/
  30          generation#/
  31             dirstate (handled by CdmUncommittedBackup)
  32                 File containing dirstate nodeid (the changeset we need
  33                 to update the workspace to after applying the bundle).
  34                 This is the node to which the working copy changes
  35                 (see 'diff', below) will be applied if applicable.
  36
  37             bundle (handled by CdmCommittedBackup)
  38                 An Hg bundle containing outgoing committed changes.
  39
  40             nodes (handled by CdmCommittedBackup)
  41                 A text file listing the full (hex) nodeid of all nodes in
  42                 bundle, used by need_backup.
  43
  44             diff (handled by CdmUncommittedBackup)
  45                 A Git-formatted diff containing uncommitted changes.
  46
  47             renames (handled by CdmUncommittedBackup)
  48                 A list of renames in the working copy that have to be
  49                 applied manually, rather than by the diff.
  50
  51             metadata.tar.gz (handled by CdmMetadataBackup)
  52                 $CODEMGR_WS/.hg/hgrc
  53                 $CODEMGR_WS/.hg/localtags
  54                 $CODEMGR_WS/.hg/patches (Mq data)
  55
  56             clear.tar.gz (handled by CdmClearBackup)
  57                 <short node>/
  58                     copies of each modified or added file, as it is in
  59                     this head.
  60
  61                  ... for each outgoing head
  62
  63                 working/
  64                      copies of each modified or added file in the
  65                      working copy if any.
  66
  67          latest -> generation#
  68             Newest backup generation.
  69
  70 All files in a given backup generation, with the exception of
  71 dirstate, are optional.
  72 '''
  73
  74 import grp, os, pwd, shutil, tarfile, time, traceback
  75 from cStringIO import StringIO
  76
  77 from mercurial import changegroup, cmdutil, error, node, patch, util
  78 from onbld.Scm import Version
  79
  80
  81 class CdmNodeMissing(util.Abort):
  82     '''a required node is not present in the destination workspace.
  83
  84     This may occur both in the case where the bundle contains a
  85     changeset which is a child of a node not present in the
  86     destination workspace (because the destination workspace is not as
  87     up-to-date as the source), or because the source and destination
  88     workspace are not related.
  89
  90     It may also happen in cases where the uncommitted changes need to
  91     be applied onto a node that the workspace does not possess even
  92     after application of the bundle (on a branch not present
  93     in the bundle or destination workspace, for instance)'''
  94
  95     def __init__(self, msg, name):
  96         #
  97         # If e.name is a string 20 characters long, it is
  98         # assumed to be a node.  (Mercurial makes this
  99         # same assumption, when creating a LookupError)
 100         #
 101         if isinstance(name, str) and len(name) == 20:
 102             n = node.short(name)
 103         else:
 104             n = name
 105
 106         util.Abort.__init__(self, "%s: changeset '%s' is missing\n"
 107                             "Your workspace is either not "
 108                             "sufficiently up to date,\n"
 109                             "or is unrelated to the workspace from "
 110                             "which the backup was taken.\n" % (msg, n))
 111
 112
 113 class CdmTarFile(tarfile.TarFile):
 114     '''Tar file access + simple comparison to the filesystem, and
 115     creation addition of files from Mercurial filectx objects.'''
 116
 117     def __init__(self, *args, **kwargs):
 118         tarfile.TarFile.__init__(self, *args, **kwargs)
 119         self.errorlevel = 2
 120
 121     def members_match_fs(self, rootpath):
 122         '''Compare the contents of the tar archive to the directory
 123         specified by rootpath.  Return False if they differ.
 124
 125         Every file in the archive must match the equivalent file in
 126         the filesystem.
 127
 128         The existence, modification time, and size of each file are
 129         compared, content is not.'''
 130
 131         def _member_matches_fs(member, rootpath):
 132             '''Compare a single member to its filesystem counterpart'''
 133             fpath = os.path.join(rootpath, member.name)
 134
 135             if not os.path.exists(fpath):
 136                 return False
 137             elif ((os.path.isfile(fpath) != member.isfile()) or
 138                   (os.path.isdir(fpath) != member.isdir()) or
 139                   (os.path.islink(fpath) != member.issym())):
 140                 return False
 141
 142             #
 143             # The filesystem may return a modification time with a
 144             # fractional component (as a float), whereas the tar format
 145             # only stores it to the whole second, perform the comparison
 146             # using integers (truncated, not rounded)
 147             #
 148             elif member.mtime != int(os.path.getmtime(fpath)):
 149                 return False
 150             elif not member.isdir() and member.size != os.path.getsize(fpath):
 151                 return False
 152             else:
 153                 return True
 154
 155         for elt in self:
 156             if not _member_matches_fs(elt, rootpath):
 157                 return False
 158
 159         return True
 160
 161     def addfilectx(self, filectx, path=None):
 162         '''Add a filectx object to the archive.
 163
 164         Use the path specified by the filectx object or, if specified,
 165         the PATH argument.
 166
 167         The size, modification time, type and permissions of the tar
 168         member are taken from the filectx object, user and group id
 169         are those of the invoking user, user and group name are those
 170         of the invoking user if information is available, or "unknown"
 171         if it is not.
 172         '''
 173
 174         t = tarfile.TarInfo(path or filectx.path())
 175         t.size = filectx.size()
 176         t.mtime = filectx.date()[0]
 177         t.uid = os.getuid()
 178         t.gid = os.getgid()
 179
 180         try:
 181             t.uname = pwd.getpwuid(t.uid).pw_name
 182         except KeyError:
 183             t.uname = "unknown"
 184
 185         try:
 186             t.gname = grp.getgrgid(t.gid).gr_name
 187         except KeyError:
 188             t.gname = "unknown"
 189
 190         #
 191         # Mercurial versions symlinks by setting a flag and storing
 192         # the destination path in place of the file content.  The
 193         # actual contents (in the tar), should be empty.
 194         #
 195         if 'l' in filectx.flags():
 196             t.type = tarfile.SYMTYPE
 197             t.mode = 0777
 198             t.linkname = filectx.data()
 199             data = None
 200         else:
 201             t.type = tarfile.REGTYPE
 202             t.mode = 'x' in filectx.flags() and 0755 or 0644
 203             data = StringIO(filectx.data())
 204
 205         self.addfile(t, data)
 206
 207
 208 class CdmCommittedBackup(object):
 209     '''Backup of committed changes'''
 210
 211     def __init__(self, backup, ws):
 212         self.ws = ws
 213         self.bu = backup
 214         self.files = ('bundle', 'nodes')
 215
 216     def _outgoing_nodes(self, parent):
 217         '''Return a list of all outgoing nodes in hex format'''
 218
 219         if parent:
 220             outgoing = self.ws.findoutgoing(parent)
 221             nodes = self.ws.repo.changelog.nodesbetween(outgoing)[0]
 222             return map(node.hex, nodes)
 223         else:
 224             return []
 225
 226     def backup(self):
 227         '''Backup committed changes'''
 228         parent = self.ws.parent()
 229
 230         if not parent:
 231             self.ws.ui.warn('Workspace has no parent, committed changes will '
 232                             'not be backed up\n')
 233             return
 234
 235         out = self.ws.findoutgoing(parent)
 236         if not out:
 237             return
 238
 239         cg = self.ws.repo.changegroup(out, 'bundle')
 240         changegroup.writebundle(cg, self.bu.backupfile('bundle'), 'HG10BZ')
 241
 242         outnodes = self._outgoing_nodes(parent)
 243         if not outnodes:
 244             return
 245
 246         fp = None
 247         try:
 248             try:
 249                 fp = self.bu.open('nodes', 'w')
 250                 fp.write('%s\n' % '\n'.join(outnodes))
 251             except EnvironmentError, e:
 252                 raise util.Abort("couldn't store outgoing nodes: %s" % e)
 253         finally:
 254             if fp and not fp.closed:
 255                 fp.close()
 256
 257     def restore(self):
 258         '''Restore committed changes from backup'''
 259
 260         if not self.bu.exists('bundle'):
 261             return
 262
 263         bpath = self.bu.backupfile('bundle')
 264         f = None
 265         try:
 266             try:
 267                 f = self.bu.open('bundle')
 268                 bundle = changegroup.readbundle(f, bpath)
 269                 self.ws.repo.addchangegroup(bundle, 'strip',
 270                                             'bundle:%s' % bpath)
 271             except EnvironmentError, e:
 272                 raise util.Abort("couldn't restore committed changes: %s\n"
 273                                  "   %s" % (bpath, e))
 274             except error.LookupError, e:
 275                 raise CdmNodeMissing("couldn't restore committed changes",
 276                                                  e.name)
 277         finally:
 278             if f and not f.closed:
 279                 f.close()
 280
 281     def need_backup(self):
 282         '''Compare backup of committed changes to workspace'''
 283
 284         if self.bu.exists('nodes'):
 285             f = None
 286             try:
 287                 try:
 288                     f = self.bu.open('nodes')
 289                     bnodes = set(line.rstrip('\r\n') for line in f.readlines())
 290                     f.close()
 291                 except EnvironmentError, e:
 292                     raise util.Abort("couldn't open backup node list: %s" % e)
 293             finally:
 294                 if f and not f.closed:
 295                     f.close()
 296         else:
 297             bnodes = set()
 298
 299         outnodes = set(self._outgoing_nodes(self.ws.parent()))
 300
 301         #
 302         # If there are outgoing nodes not in the prior backup we need
 303         # to take a new backup; it's fine if there are nodes in the
 304         # old backup which are no longer outgoing, however.
 305         #
 306         if not outnodes <= bnodes:
 307             return True
 308
 309         return False
 310
 311     def cleanup(self):
 312         '''Remove backed up committed changes'''
 313
 314         for f in self.files:
 315             self.bu.unlink(f)
 316
 317
 318 class CdmUncommittedBackup(object):
 319     '''Backup of uncommitted changes'''
 320
 321     def __init__(self, backup, ws):
 322         self.ws = ws
 323         self.bu = backup
 324         self.wctx = self.ws.workingctx(worklist=True)
 325
 326     def _clobbering_renames(self):
 327         '''Return a list of pairs of files representing renames/copies
 328         that clobber already versioned files.  [(old-name new-name)...]
 329         '''
 330
 331         #
 332         # Note that this doesn't handle uncommitted merges
 333         # as CdmUncommittedBackup itself doesn't.
 334         #
 335         parent = self.wctx.parents()[0]
 336
 337         ret = []
 338         for fname in self.wctx.added() + self.wctx.modified():
 339             rn = self.wctx.filectx(fname).renamed()
 340             if rn and fname in parent:
 341                 ret.append((rn[0], fname))
 342         return ret
 343
 344     def backup(self):
 345         '''Backup uncommitted changes'''
 346
 347         if self.ws.merged():
 348             raise util.Abort("Unable to backup an uncommitted merge.\n"
 349                              "Please complete your merge and commit")
 350
 351         dirstate = node.hex(self.wctx.parents()[0].node())
 352
 353         fp = None
 354         try:
 355             try:
 356                 fp = self.bu.open('dirstate', 'w')
 357                 fp.write(dirstate + '\n')
 358                 fp.close()
 359             except EnvironmentError, e:
 360                 raise util.Abort("couldn't save working copy parent: %s" % e)
 361
 362             try:
 363                 fp = self.bu.open('renames', 'w')
 364                 for cons in self._clobbering_renames():
 365                     fp.write("%s %s\n" % cons)
 366                 fp.close()
 367             except EnvironmentError, e:
 368                 raise util.Abort("couldn't save clobbering copies: %s" % e)
 369
 370             try:
 371                 fp = self.bu.open('diff', 'w')
 372                 match = self.ws.matcher(files=self.wctx.files())
 373                 fp.write(self.ws.diff(opts={'git': True}, match=match))
 374             except EnvironmentError, e:
 375                 raise util.Abort("couldn't save working copy diff: %s" % e)
 376         finally:
 377             if fp and not fp.closed:
 378                 fp.close()
 379
 380     def _dirstate(self):
 381         '''Return the desired working copy node from the backup'''
 382         fp = None
 383         try:
 384             try:
 385                 fp = self.bu.open('dirstate')
 386                 dirstate = fp.readline().strip()
 387             except EnvironmentError, e:
 388                 raise util.Abort("couldn't read saved parent: %s" % e)
 389         finally:
 390             if fp and not fp.closed:
 391                 fp.close()
 392
 393         return dirstate
 394
 395     def restore(self):
 396         '''Restore uncommitted changes'''
 397         dirstate = self._dirstate()
 398
 399         #
 400         # Check that the patch's parent changeset exists.
 401         #
 402         try:
 403             n = node.bin(dirstate)
 404             self.ws.repo.changelog.lookup(n)
 405         except error.LookupError, e:
 406             raise CdmNodeMissing("couldn't restore uncommitted changes",
 407                                  e.name)
 408
 409         try:
 410             self.ws.clean(rev=dirstate)
 411         except util.Abort, e:
 412             raise util.Abort("couldn't update to saved node: %s" % e)
 413
 414         if not self.bu.exists('diff'):
 415             return
 416
 417         #
 418         # There's a race here whereby if the patch (or part thereof)
 419         # is applied within the same second as the clean above (such
 420         # that modification time doesn't change) and if the size of
 421         # that file does not change, Hg may not see the change.
 422         #
 423         # We sleep a full second to avoid this, as sleeping merely
 424         # until the next second begins would require very close clock
 425         # synchronization on network filesystems.
 426         #
 427         time.sleep(1)
 428
 429         files = {}
 430         try:
 431             diff = self.bu.backupfile('diff')
 432             try:
 433                 fuzz = patch.patch(diff, self.ws.ui, strip=1,
 434                                    cwd=self.ws.repo.root, files=files)
 435                 if fuzz:
 436                     raise util.Abort('working copy diff applied with fuzz')
 437             except Exception, e:
 438                 raise util.Abort("couldn't apply working copy diff: %s\n"
 439                                  "   %s" % (diff, e))
 440         finally:
 441             if Version.at_least("1.7"):
 442                 cmdutil.updatedir(self.ws.ui, self.ws.repo, files)
 443             else:
 444                 patch.updatedir(self.ws.ui, self.ws.repo, files)
 445
 446         if not self.bu.exists('renames'):
 447             return
 448
 449         #
 450         # We need to re-apply name changes where the new name
 451         # (rename/copy destination) is an already versioned file, as
 452         # Hg would otherwise ignore them.
 453         #
 454         try:
 455             fp = self.bu.open('renames')
 456             for line in fp:
 457                 source, dest = line.strip().split()
 458                 self.ws.copy(source, dest)
 459         except EnvironmentError, e:
 460             raise util.Abort('unable to open renames file: %s' % e)
 461         except ValueError:
 462             raise util.Abort('corrupt renames file: %s' %
 463                              self.bu.backupfile('renames'))
 464
 465     def need_backup(self):
 466         '''Compare backup of uncommitted changes to workspace'''
 467         cnode = self.wctx.parents()[0].node()
 468         if self._dirstate() != node.hex(cnode):
 469             return True
 470
 471         fd = None
 472         match = self.ws.matcher(files=self.wctx.files())
 473         curdiff = self.ws.diff(opts={'git': True}, match=match)
 474
 475         try:
 476             if self.bu.exists('diff'):
 477                 try:
 478                     fd = self.bu.open('diff')
 479                     backdiff = fd.read()
 480                     fd.close()
 481                 except EnvironmentError, e:
 482                     raise util.Abort("couldn't open backup diff %s\n"
 483                                      "   %s" % (self.bu.backupfile('diff'), e))
 484             else:
 485                 backdiff = ''
 486
 487             if backdiff != curdiff:
 488                 return True
 489
 490             currrenamed = self._clobbering_renames()
 491             bakrenamed = None
 492
 493             if self.bu.exists('renames'):
 494                 try:
 495                     fd = self.bu.open('renames')
 496                     bakrenamed = [tuple(line.strip().split(' ')) for line in fd]
 497                     fd.close()
 498                 except EnvironmentError, e:
 499                     raise util.Abort("couldn't open renames file %s: %s\n" %
 500                                      (self.bu.backupfile('renames'), e))
 501
 502             if currrenamed != bakrenamed:
 503                 return True
 504         finally:
 505             if fd and not fd.closed:
 506                 fd.close()
 507
 508         return False
 509
 510     def cleanup(self):
 511         '''Remove backed up uncommitted changes'''
 512
 513         for f in ('dirstate', 'diff', 'renames'):
 514             self.bu.unlink(f)
 515
 516
 517 class CdmMetadataBackup(object):
 518     '''Backup of workspace metadata'''
 519
 520     def __init__(self, backup, ws):
 521         self.bu = backup
 522         self.ws = ws
 523         self.files = ('hgrc', 'localtags', 'patches', 'cdm')
 524
 525     def backup(self):
 526         '''Backup workspace metadata'''
 527
 528         tarpath = self.bu.backupfile('metadata.tar.gz')
 529
 530         #
 531         # Files is a list of tuples (name, path), where name is as in
 532         # self.files, and path is the absolute path.
 533         #
 534         files = filter(lambda (name, path): os.path.exists(path),
 535                        zip(self.files, map(self.ws.repo.join, self.files)))
 536
 537         if not files:
 538             return
 539
 540         try:
 541             tar = CdmTarFile.gzopen(tarpath, 'w')
 542         except (EnvironmentError, tarfile.TarError), e:
 543             raise util.Abort("couldn't open %s for writing: %s" %
 544                              (tarpath, e))
 545
 546         try:
 547             for name, path in files:
 548                 try:
 549                     tar.add(path, name)
 550                 except (EnvironmentError, tarfile.TarError), e:
 551                     #
 552                     # tarfile.TarError doesn't include the tar member or file
 553                     # in question, so we have to do so ourselves.
 554                     #
 555                     if isinstance(e, tarfile.TarError):
 556                         errstr = "%s: %s" % (name, e)
 557                     else:
 558                         errstr = str(e)
 559
 560                     raise util.Abort("couldn't backup metadata to %s:\n"
 561                                      "  %s" % (tarpath, errstr))
 562         finally:
 563             tar.close()
 564
 565     def old_restore(self):
 566         '''Restore workspace metadata from an pre-tar backup'''
 567
 568         for fname in self.files:
 569             if self.bu.exists(fname):
 570                 bfile = self.bu.backupfile(fname)
 571                 wfile = self.ws.repo.join(fname)
 572
 573                 try:
 574                     shutil.copy2(bfile, wfile)
 575                 except EnvironmentError, e:
 576                     raise util.Abort("couldn't restore metadata from %s:\n"
 577                                      "   %s" % (bfile, e))
 578
 579     def tar_restore(self):
 580         '''Restore workspace metadata (from a tar-style backup)'''
 581
 582         if not self.bu.exists('metadata.tar.gz'):
 583             return
 584
 585         tarpath = self.bu.backupfile('metadata.tar.gz')
 586
 587         try:
 588             tar = CdmTarFile.gzopen(tarpath)
 589         except (EnvironmentError, tarfile.TarError), e:
 590             raise util.Abort("couldn't open %s: %s" % (tarpath, e))
 591
 592         try:
 593             for elt in tar:
 594                 try:
 595                     tar.extract(elt, path=self.ws.repo.path)
 596                 except (EnvironmentError, tarfile.TarError), e:
 597                     # Make sure the member name is in the exception message.
 598                     if isinstance(e, tarfile.TarError):
 599                         errstr = "%s: %s" % (elt.name, e)
 600                     else:
 601                         errstr = str(e)
 602
 603                     raise util.Abort("couldn't restore metadata from %s:\n"
 604                                      "   %s" %
 605                                      (tarpath, errstr))
 606         finally:
 607             if tar and not tar.closed:
 608                 tar.close()
 609
 610     def restore(self):
 611         '''Restore workspace metadata'''
 612
 613         if self.bu.exists('hgrc'):
 614             self.old_restore()
 615         else:
 616             self.tar_restore()
 617
 618     def _walk(self):
 619         '''Yield the repo-relative path to each file we operate on,
 620         including each file within any affected directory'''
 621
 622         for elt in self.files:
 623             path = self.ws.repo.join(elt)
 624
 625             if not os.path.exists(path):
 626                 continue
 627
 628             if os.path.isdir(path):
 629                 for root, dirs, files in os.walk(path, topdown=True):
 630                     yield root
 631
 632                     for f in files:
 633                         yield os.path.join(root, f)
 634             else:
 635                 yield path
 636
 637     def need_backup(self):
 638         '''Compare backed up workspace metadata to workspace'''
 639
 640         def strip_trailing_pathsep(pathname):
 641             '''Remove a possible trailing path separator from PATHNAME'''
 642             return pathname.endswith('/') and pathname[:-1] or pathname
 643
 644         if self.bu.exists('metadata.tar.gz'):
 645             tarpath = self.bu.backupfile('metadata.tar.gz')
 646             try:
 647                 tar = CdmTarFile.gzopen(tarpath)
 648             except (EnvironmentError, tarfile.TarError), e:
 649                 raise util.Abort("couldn't open metadata tarball: %s\n"
 650                                  "   %s" % (tarpath, e))
 651
 652             if not tar.members_match_fs(self.ws.repo.path):
 653                 tar.close()
 654                 return True
 655
 656             tarnames = map(strip_trailing_pathsep, tar.getnames())
 657             tar.close()
 658         else:
 659             tarnames = []
 660
 661         repopath = self.ws.repo.path
 662         if not repopath.endswith('/'):
 663             repopath += '/'
 664
 665         for path in self._walk():
 666             if path.replace(repopath, '', 1) not in tarnames:
 667                 return True
 668
 669         return False
 670
 671     def cleanup(self):
 672         '''Remove backed up workspace metadata'''
 673         self.bu.unlink('metadata.tar.gz')
 674
 675
 676 class CdmClearBackup(object):
 677     '''A backup (in tar format) of complete source files from every
 678     workspace head.
 679
 680     Paths in the tarball are prefixed by the revision and node of the
 681     head, or "working" for the working directory.
 682
 683     This is done purely for the benefit of the user, and as such takes
 684     no part in restore or need_backup checking, restore always
 685     succeeds, need_backup always returns False
 686     '''
 687
 688     def __init__(self, backup, ws):
 689         self.bu = backup
 690         self.ws = ws
 691
 692     def _branch_pairs(self):
 693         '''Return a list of tuples (parenttip, localtip) for each
 694         outgoing head.  If the working copy contains modified files,
 695         it is a head, and neither of its parents are.
 696         '''
 697
 698         parent = self.ws.parent()
 699
 700         if parent:
 701             outgoing = self.ws.findoutgoing(parent)
 702             outnodes = set(self.ws.repo.changelog.nodesbetween(outgoing)[0])
 703
 704             heads = [self.ws.repo.changectx(n) for n in self.ws.repo.heads()
 705                      if n in outnodes]
 706         else:
 707             heads = []
 708             outnodes = []
 709
 710         wctx = self.ws.workingctx()
 711         if wctx.files():        # We only care about file changes.
 712             heads = filter(lambda x: x not in wctx.parents(), heads) + [wctx]
 713
 714         pairs = []
 715         for head in heads:
 716             if head.rev() is None:
 717                 c = head.parents()
 718             else:
 719                 c = [head]
 720
 721             pairs.append((self.ws.parenttip(c, outnodes), head))
 722         return pairs
 723
 724     def backup(self):
 725         '''Save a clear copy of each source file modified between each
 726         head and that head's parenttip (see WorkSpace.parenttip).
 727         '''
 728
 729         tarpath = self.bu.backupfile('clear.tar.gz')
 730         branches = self._branch_pairs()
 731
 732         if not branches:
 733             return
 734
 735         try:
 736             tar = CdmTarFile.gzopen(tarpath, 'w')
 737         except (EnvironmentError, tarfile.TarError), e:
 738             raise util.Abort("Could not open %s for writing: %s" %
 739                              (tarpath, e))
 740
 741         try:
 742             for parent, child in branches:
 743                 tpath = child.node() and node.short(child.node()) or "working"
 744
 745                 for fname, change in self.ws.status(parent, child).iteritems():
 746                     if change not in ('added', 'modified'):
 747                         continue
 748
 749                     try:
 750                         tar.addfilectx(child.filectx(fname),
 751                                        os.path.join(tpath, fname))
 752                     except ValueError, e:
 753                         crev = child.rev()
 754                         if crev is None:
 755                             crev = "working copy"
 756                         raise util.Abort("Could not backup clear file %s "
 757                                          "from %s: %s\n" % (fname, crev, e))
 758         finally:
 759             tar.close()
 760
 761     def cleanup(self):
 762         '''Cleanup a failed Clear backup.
 763
 764         Remove the clear tarball from the backup directory.
 765         '''
 766
 767         self.bu.unlink('clear.tar.gz')
 768
 769     def restore(self):
 770         '''Clear backups are never restored, do nothing'''
 771         pass
 772
 773     def need_backup(self):
 774         '''Clear backups are never compared, return False (no backup needed).
 775
 776         Should a backup actually be needed, one of the other
 777         implementation classes would notice in any situation we would.
 778         '''
 779
 780         return False
 781
 782
 783 class CdmBackup(object):
 784     '''A backup of a given workspace'''
 785
 786     def __init__(self, ui, ws, name):
 787         self.ws = ws
 788         self.ui = ui
 789         self.backupdir = self._find_backup_dir(name)
 790
 791         #
 792         # The order of instances here controls the order the various operations
 793         # are run.
 794         #
 795         # There's some inherent dependence, in that on restore we need
 796         # to restore committed changes prior to uncommitted changes
 797         # (as the parent revision of any uncommitted changes is quite
 798         # likely to not exist until committed changes are restored).
 799         # Metadata restore can happen at any point, but happens last
 800         # as a matter of convention.
 801         #
 802         self.modules = [x(self, ws) for x in [CdmCommittedBackup,
 803                                               CdmUncommittedBackup,
 804                                               CdmClearBackup,
 805                                               CdmMetadataBackup]]
 806
 807         if os.path.exists(os.path.join(self.backupdir, 'latest')):
 808             generation = os.readlink(os.path.join(self.backupdir, 'latest'))
 809             self.generation = int(os.path.split(generation)[1])
 810         else:
 811             self.generation = 0
 812
 813     def _find_backup_dir(self, name):
 814         '''Find the path to an appropriate backup directory based on NAME'''
 815
 816         if os.path.isabs(name):
 817             return name
 818
 819         if self.ui.config('cdm', 'backupdir'):
 820             backupbase = os.path.expanduser(self.ui.config('cdm', 'backupdir'))
 821         else:
 822             home = None
 823
 824             try:
 825                 home = os.getenv('HOME') or pwd.getpwuid(os.getuid()).pw_dir
 826             except KeyError:
 827                 pass                    # Handled anyway
 828
 829             if not home:
 830                 raise util.Abort('Could not determine your HOME directory to '
 831                                  'find backup path')
 832
 833             backupbase = os.path.join(home, 'cdm.backup')
 834
 835         backupdir = os.path.join(backupbase, name)
 836
 837         # If backupdir exists, it must be a directory.
 838         if (os.path.exists(backupdir) and not os.path.isdir(backupdir)):
 839             raise util.Abort('%s exists but is not a directory' % backupdir)
 840
 841         return backupdir
 842
 843     def _update_latest(self, gen):
 844         '''Update latest symlink to point to the current generation'''
 845         linkpath = os.path.join(self.backupdir, 'latest')
 846
 847         if os.path.lexists(linkpath):
 848             os.unlink(linkpath)
 849
 850         os.symlink(str(gen), linkpath)
 851
 852     def _create_gen(self, gen):
 853         '''Create a new backup generation'''
 854         try:
 855             os.makedirs(os.path.join(self.backupdir, str(gen)))
 856             self._update_latest(gen)
 857         except EnvironmentError, e:
 858             raise util.Abort("Couldn't create backup generation %s: %s" %
 859                              (os.path.join(self.backupdir, str(gen)), e))
 860
 861     def backupfile(self, path):
 862         '''return full path to backup file FILE at GEN'''
 863         return os.path.join(self.backupdir, str(self.generation), path)
 864
 865     def unlink(self, name):
 866         '''Unlink the specified path from the backup directory.
 867         A no-op if the path does not exist.
 868         '''
 869
 870         fpath = self.backupfile(name)
 871         if os.path.exists(fpath):
 872             os.unlink(fpath)
 873
 874     def open(self, name, mode='r'):
 875         '''Open the specified file in the backup directory'''
 876         return open(self.backupfile(name), mode)
 877
 878     def exists(self, name):
 879         '''Return boolean indicating wether a given file exists in the
 880         backup directory.'''
 881         return os.path.exists(self.backupfile(name))
 882
 883     def need_backup(self):
 884         '''Compare backed up changes to workspace'''
 885         #
 886         # If there's no current backup generation, or the last backup was
 887         # invalid (lacking the dirstate file), we need a backup regardless
 888         # of anything else.
 889         #
 890         if not self.generation or not self.exists('dirstate'):
 891             return True
 892
 893         for x in self.modules:
 894             if x.need_backup():
 895                 return True
 896
 897         return False
 898
 899     def backup(self):
 900         '''Take a backup of the current workspace
 901
 902         Calling code is expected to hold both the working copy lock
 903         and repository lock.'''
 904
 905         if not os.path.exists(self.backupdir):
 906             try:
 907                 os.makedirs(self.backupdir)
 908             except EnvironmentError, e:
 909                 raise util.Abort('Could not create backup directory %s: %s' %
 910                                  (self.backupdir, e))
 911
 912         self.generation += 1
 913         self._create_gen(self.generation)
 914
 915         try:
 916             for x in self.modules:
 917                 x.backup()
 918         except Exception, e:
 919             if isinstance(e, KeyboardInterrupt):
 920                 self.ws.ui.warn("Interrupted\n")
 921             else:
 922                 self.ws.ui.warn("Error: %s\n" % e)
 923                 show_traceback = self.ws.ui.configbool('ui', 'traceback',
 924                                                        False)
 925
 926                 #
 927                 # If it's not a 'normal' error, we want to print a stack
 928                 # trace now in case the attempt to remove the partial
 929                 # backup also fails, and raises a second exception.
 930                 #
 931                 if (not isinstance(e, (EnvironmentError, util.Abort))
 932                     or show_traceback):
 933                     traceback.print_exc()
 934
 935             for x in self.modules:
 936                 x.cleanup()
 937
 938             os.rmdir(os.path.join(self.backupdir, str(self.generation)))
 939             self.generation -= 1
 940
 941             if self.generation != 0:
 942                 self._update_latest(self.generation)
 943             else:
 944                 os.unlink(os.path.join(self.backupdir, 'latest'))
 945
 946             raise util.Abort('Backup failed')
 947
 948     def restore(self, gen=None):
 949         '''Restore workspace from backup
 950
 951         Restores from backup generation GEN (defaulting to the latest)
 952         into workspace WS.
 953
 954         Calling code is expected to hold both the working copy lock
 955         and repository lock of the destination workspace.'''
 956
 957         if not os.path.exists(self.backupdir):
 958             raise util.Abort('Backup directory does not exist: %s' %
 959                              (self.backupdir))
 960
 961         if gen:
 962             if not os.path.exists(os.path.join(self.backupdir, str(gen))):
 963                 raise util.Abort('Backup generation does not exist: %s' %
 964                                  (os.path.join(self.backupdir, str(gen))))
 965             self.generation = int(gen)
 966
 967         if not self.generation: # This is OK, 0 is not a valid generation
 968             raise util.Abort('Backup has no generations: %s' % self.backupdir)
 969
 970         if not self.exists('dirstate'):
 971             raise util.Abort('Backup %s/%s is incomplete (dirstate missing)' %
 972                              (self.backupdir, self.generation))
 973
 974         try:
 975             for x in self.modules:
 976                 x.restore()
 977         except util.Abort, e:
 978             raise util.Abort('Error restoring workspace:\n'
 979                              '%s\n'
 980                              'Workspace may be partially restored' % e)