mdw@git.distorted.org.uk Git - stgit/blob - stgit/lib/transaction.py

   1 """The L{StackTransaction} class makes it possible to make complex
   2 updates to an StGit stack in a safe and convenient way."""
   3
   4 import atexit
   5 import itertools as it
   6
   7 from stgit import exception, utils
   8 from stgit.utils import any, all
   9 from stgit.out import *
  10 from stgit.lib import git, log
  11
  12 class TransactionException(exception.StgException):
  13     """Exception raised when something goes wrong with a
  14     L{StackTransaction}."""
  15
  16 class TransactionHalted(TransactionException):
  17     """Exception raised when a L{StackTransaction} stops part-way through.
  18     Used to make a non-local jump from the transaction setup to the
  19     part of the transaction code where the transaction is run."""
  20
  21 def _print_current_patch(old_applied, new_applied):
  22     def now_at(pn):
  23         out.info('Now at patch "%s"' % pn)
  24     if not old_applied and not new_applied:
  25         pass
  26     elif not old_applied:
  27         now_at(new_applied[-1])
  28     elif not new_applied:
  29         out.info('No patch applied')
  30     elif old_applied[-1] == new_applied[-1]:
  31         pass
  32     else:
  33         now_at(new_applied[-1])
  34
  35 class _TransPatchMap(dict):
  36     """Maps patch names to sha1 strings."""
  37     def __init__(self, stack):
  38         dict.__init__(self)
  39         self.__stack = stack
  40     def __getitem__(self, pn):
  41         try:
  42             return dict.__getitem__(self, pn)
  43         except KeyError:
  44             return self.__stack.patches.get(pn).commit
  45
  46 class StackTransaction(object):
  47     """A stack transaction, used for making complex updates to an StGit
  48     stack in one single operation that will either succeed or fail
  49     cleanly.
  50
  51     The basic theory of operation is the following:
  52
  53       1. Create a transaction object.
  54
  55       2. Inside a::
  56
  57          try
  58            ...
  59          except TransactionHalted:
  60            pass
  61
  62       block, update the transaction with e.g. methods like
  63       L{pop_patches} and L{push_patch}. This may create new git
  64       objects such as commits, but will not write any refs; this means
  65       that in case of a fatal error we can just walk away, no clean-up
  66       required.
  67
  68       (Some operations may need to touch your index and working tree,
  69       though. But they are cleaned up when needed.)
  70
  71       3. After the C{try} block -- wheher or not the setup ran to
  72       completion or halted part-way through by raising a
  73       L{TransactionHalted} exception -- call the transaction's L{run}
  74       method. This will either succeed in writing the updated state to
  75       your refs and index+worktree, or fail without having done
  76       anything."""
  77     def __init__(self, stack, msg, discard_changes = False,
  78                  allow_conflicts = False, allow_bad_head = False):
  79         """Create a new L{StackTransaction}.
  80
  81         @param discard_changes: Discard any changes in index+worktree
  82         @type discard_changes: bool
  83         @param allow_conflicts: Whether to allow pre-existing conflicts
  84         @type allow_conflicts: bool or function of L{StackTransaction}"""
  85         self.__stack = stack
  86         self.__msg = msg
  87         self.__patches = _TransPatchMap(stack)
  88         self.__applied = list(self.__stack.patchorder.applied)
  89         self.__unapplied = list(self.__stack.patchorder.unapplied)
  90         self.__hidden = list(self.__stack.patchorder.hidden)
  91         self.__conflicting_push = None
  92         self.__error = None
  93         self.__current_tree = self.__stack.head.data.tree
  94         self.__base = self.__stack.base
  95         self.__discard_changes = discard_changes
  96         self.__bad_head = None
  97         if isinstance(allow_conflicts, bool):
  98             self.__allow_conflicts = lambda trans: allow_conflicts
  99         else:
 100             self.__allow_conflicts = allow_conflicts
 101         self.__temp_index = self.temp_index_tree = None
 102         if not allow_bad_head:
 103             self.__assert_head_top_equal()
 104     stack = property(lambda self: self.__stack)
 105     patches = property(lambda self: self.__patches)
 106     def __set_applied(self, val):
 107         self.__applied = list(val)
 108     applied = property(lambda self: self.__applied, __set_applied)
 109     def __set_unapplied(self, val):
 110         self.__unapplied = list(val)
 111     unapplied = property(lambda self: self.__unapplied, __set_unapplied)
 112     def __set_hidden(self, val):
 113         self.__hidden = list(val)
 114     hidden = property(lambda self: self.__hidden, __set_hidden)
 115     all_patches = property(lambda self: (self.__applied + self.__unapplied
 116                                          + self.__hidden))
 117     def __set_base(self, val):
 118         assert (not self.__applied
 119                 or self.patches[self.applied[0]].data.parent == val)
 120         self.__base = val
 121     base = property(lambda self: self.__base, __set_base)
 122     @property
 123     def temp_index(self):
 124         if not self.__temp_index:
 125             self.__temp_index = self.__stack.repository.temp_index()
 126             atexit.register(self.__temp_index.delete)
 127         return self.__temp_index
 128     @property
 129     def top(self):
 130         if self.__applied:
 131             return self.__patches[self.__applied[-1]]
 132         else:
 133             return self.__base
 134     def __get_head(self):
 135         if self.__bad_head:
 136             return self.__bad_head
 137         else:
 138             return self.top
 139     def __set_head(self, val):
 140         self.__bad_head = val
 141     head = property(__get_head, __set_head)
 142     def __assert_head_top_equal(self):
 143         if not self.__stack.head_top_equal():
 144             out.error(
 145                 'HEAD and top are not the same.',
 146                 'This can happen if you modify a branch with git.',
 147                 '"stg repair --help" explains more about what to do next.')
 148             self.__abort()
 149     def __checkout(self, tree, iw, allow_bad_head):
 150         if not allow_bad_head:
 151             self.__assert_head_top_equal()
 152         if self.__current_tree == tree and not self.__discard_changes:
 153             # No tree change, but we still want to make sure that
 154             # there are no unresolved conflicts. Conflicts
 155             # conceptually "belong" to the topmost patch, and just
 156             # carrying them along to another patch is confusing.
 157             if (self.__allow_conflicts(self) or iw == None
 158                 or not iw.index.conflicts()):
 159                 return
 160             out.error('Need to resolve conflicts first')
 161             self.__abort()
 162         assert iw != None
 163         if self.__discard_changes:
 164             iw.checkout_hard(tree)
 165         else:
 166             iw.checkout(self.__current_tree, tree)
 167         self.__current_tree = tree
 168     @staticmethod
 169     def __abort():
 170         raise TransactionException(
 171             'Command aborted (all changes rolled back)')
 172     def __check_consistency(self):
 173         remaining = set(self.all_patches)
 174         for pn, commit in self.__patches.iteritems():
 175             if commit == None:
 176                 assert self.__stack.patches.exists(pn)
 177             else:
 178                 assert pn in remaining
 179     def abort(self, iw = None):
 180         # The only state we need to restore is index+worktree.
 181         if iw:
 182             self.__checkout(self.__stack.head.data.tree, iw,
 183                             allow_bad_head = True)
 184     def run(self, iw = None, set_head = True, allow_bad_head = False):
 185         """Execute the transaction. Will either succeed, or fail (with an
 186         exception) and do nothing."""
 187         self.__check_consistency()
 188         log.log_external_mods(self.__stack)
 189         new_head = self.head
 190
 191         # Set branch head.
 192         if set_head:
 193             if iw:
 194                 try:
 195                     self.__checkout(new_head.data.tree, iw, allow_bad_head)
 196                 except git.CheckoutException:
 197                     # We have to abort the transaction.
 198                     self.abort(iw)
 199                     self.__abort()
 200             self.__stack.set_head(new_head, self.__msg)
 201
 202         if self.__error:
 203             out.error(self.__error)
 204
 205         # Write patches.
 206         def write(msg):
 207             for pn, commit in self.__patches.iteritems():
 208                 if self.__stack.patches.exists(pn):
 209                     p = self.__stack.patches.get(pn)
 210                     if commit == None:
 211                         p.delete()
 212                     else:
 213                         p.set_commit(commit, msg)
 214                 else:
 215                     self.__stack.patches.new(pn, commit, msg)
 216             self.__stack.patchorder.applied = self.__applied
 217             self.__stack.patchorder.unapplied = self.__unapplied
 218             self.__stack.patchorder.hidden = self.__hidden
 219             log.log_entry(self.__stack, msg)
 220         old_applied = self.__stack.patchorder.applied
 221         write(self.__msg)
 222         if self.__conflicting_push != None:
 223             self.__patches = _TransPatchMap(self.__stack)
 224             self.__conflicting_push()
 225             write(self.__msg + ' (CONFLICT)')
 226         _print_current_patch(old_applied, self.__applied)
 227
 228         if self.__error:
 229             return utils.STGIT_CONFLICT
 230         else:
 231             return utils.STGIT_SUCCESS
 232
 233     def __halt(self, msg):
 234         self.__error = msg
 235         raise TransactionHalted(msg)
 236
 237     @staticmethod
 238     def __print_popped(popped):
 239         if len(popped) == 0:
 240             pass
 241         elif len(popped) == 1:
 242             out.info('Popped %s' % popped[0])
 243         else:
 244             out.info('Popped %s -- %s' % (popped[-1], popped[0]))
 245
 246     def pop_patches(self, p):
 247         """Pop all patches pn for which p(pn) is true. Return the list of
 248         other patches that had to be popped to accomplish this. Always
 249         succeeds."""
 250         popped = []
 251         for i in xrange(len(self.applied)):
 252             if p(self.applied[i]):
 253                 popped = self.applied[i:]
 254                 del self.applied[i:]
 255                 break
 256         popped1 = [pn for pn in popped if not p(pn)]
 257         popped2 = [pn for pn in popped if p(pn)]
 258         self.unapplied = popped1 + popped2 + self.unapplied
 259         self.__print_popped(popped)
 260         return popped1
 261
 262     def delete_patches(self, p):
 263         """Delete all patches pn for which p(pn) is true. Return the list of
 264         other patches that had to be popped to accomplish this. Always
 265         succeeds."""
 266         popped = []
 267         all_patches = self.applied + self.unapplied + self.hidden
 268         for i in xrange(len(self.applied)):
 269             if p(self.applied[i]):
 270                 popped = self.applied[i:]
 271                 del self.applied[i:]
 272                 break
 273         popped = [pn for pn in popped if not p(pn)]
 274         self.unapplied = popped + [pn for pn in self.unapplied if not p(pn)]
 275         self.hidden = [pn for pn in self.hidden if not p(pn)]
 276         self.__print_popped(popped)
 277         for pn in all_patches:
 278             if p(pn):
 279                 s = ['', ' (empty)'][self.patches[pn].data.is_nochange()]
 280                 self.patches[pn] = None
 281                 out.info('Deleted %s%s' % (pn, s))
 282         return popped
 283
 284     def push_patch(self, pn, iw = None):
 285         """Attempt to push the named patch. If this results in conflicts,
 286         halts the transaction. If index+worktree are given, spill any
 287         conflicts to them."""
 288         orig_cd = self.patches[pn].data
 289         cd = orig_cd.set_committer(None)
 290         s = ['', ' (empty)'][cd.is_nochange()]
 291         oldparent = cd.parent
 292         cd = cd.set_parent(self.top)
 293         base = oldparent.data.tree
 294         ours = cd.parent.data.tree
 295         theirs = cd.tree
 296         tree, self.temp_index_tree = self.temp_index.merge(
 297             base, ours, theirs, self.temp_index_tree)
 298         merge_conflict = False
 299         if not tree:
 300             if iw == None:
 301                 self.__halt('%s does not apply cleanly' % pn)
 302             try:
 303                 self.__checkout(ours, iw, allow_bad_head = False)
 304             except git.CheckoutException:
 305                 self.__halt('Index/worktree dirty')
 306             try:
 307                 iw.merge(base, ours, theirs)
 308                 tree = iw.index.write_tree()
 309                 self.__current_tree = tree
 310                 s = ' (modified)'
 311             except git.MergeConflictException:
 312                 tree = ours
 313                 merge_conflict = True
 314                 s = ' (conflict)'
 315             except git.MergeException, e:
 316                 self.__halt(str(e))
 317         cd = cd.set_tree(tree)
 318         if any(getattr(cd, a) != getattr(orig_cd, a) for a in
 319                ['parent', 'tree', 'author', 'message']):
 320             comm = self.__stack.repository.commit(cd)
 321         else:
 322             comm = None
 323             s = ' (unmodified)'
 324         out.info('Pushed %s%s' % (pn, s))
 325         def update():
 326             if comm:
 327                 self.patches[pn] = comm
 328             if pn in self.hidden:
 329                 x = self.hidden
 330             else:
 331                 x = self.unapplied
 332             del x[x.index(pn)]
 333             self.applied.append(pn)
 334         if merge_conflict:
 335             # We've just caused conflicts, so we must allow them in
 336             # the final checkout.
 337             self.__allow_conflicts = lambda trans: True
 338
 339             # Save this update so that we can run it a little later.
 340             self.__conflicting_push = update
 341             self.__halt('Merge conflict')
 342         else:
 343             # Update immediately.
 344             update()
 345
 346     def reorder_patches(self, applied, unapplied, hidden, iw = None):
 347         """Push and pop patches to attain the given ordering."""
 348         common = len(list(it.takewhile(lambda (a, b): a == b,
 349                                        zip(self.applied, applied))))
 350         to_pop = set(self.applied[common:])
 351         self.pop_patches(lambda pn: pn in to_pop)
 352         for pn in applied[common:]:
 353             self.push_patch(pn, iw)
 354         assert self.applied == applied
 355         assert set(self.unapplied + self.hidden) == set(unapplied + hidden)
 356         self.unapplied = unapplied
 357         self.hidden = hidden