d82e72439005ec5c6bc05a42ec1e2db9d2db47e7
1 """The L{StackTransaction} class makes it possible to make complex
2 updates to an StGit stack in a safe and convenient way."""
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 from stgit
.config
import config
13 class TransactionException(exception
.StgException
):
14 """Exception raised when something goes wrong with a
15 L{StackTransaction}."""
17 class TransactionHalted(TransactionException
):
18 """Exception raised when a L{StackTransaction} stops part-way through.
19 Used to make a non-local jump from the transaction setup to the
20 part of the transaction code where the transaction is run."""
22 def _print_current_patch(old_applied
, new_applied
):
24 out
.info('Now at patch "%s"' % pn
)
25 if not old_applied
and not new_applied
:
28 now_at(new_applied
[-1])
30 out
.info('No patch applied')
31 elif old_applied
[-1] == new_applied
[-1]:
34 now_at(new_applied
[-1])
36 class _TransPatchMap(dict):
37 """Maps patch names to sha1 strings."""
38 def __init__(self
, stack
):
41 def __getitem__(self
, pn
):
43 return dict.__getitem__(self
, pn
)
45 return self
.__stack
.patches
.get(pn
).commit
47 class StackTransaction(object):
48 """A stack transaction, used for making complex updates to an StGit
49 stack in one single operation that will either succeed or fail
52 The basic theory of operation is the following:
54 1. Create a transaction object.
60 except TransactionHalted:
63 block, update the transaction with e.g. methods like
64 L{pop_patches} and L{push_patch}. This may create new git
65 objects such as commits, but will not write any refs; this means
66 that in case of a fatal error we can just walk away, no clean-up
69 (Some operations may need to touch your index and working tree,
70 though. But they are cleaned up when needed.)
72 3. After the C{try} block -- wheher or not the setup ran to
73 completion or halted part-way through by raising a
74 L{TransactionHalted} exception -- call the transaction's L{run}
75 method. This will either succeed in writing the updated state to
76 your refs and index+worktree, or fail without having done
78 def __init__(self
, stack
, msg
, discard_changes
= False,
79 allow_conflicts
= False, allow_bad_head
= False,
80 check_clean_iw
= None):
81 """Create a new L{StackTransaction}.
83 @param discard_changes: Discard any changes in index+worktree
84 @type discard_changes: bool
85 @param allow_conflicts: Whether to allow pre-existing conflicts
86 @type allow_conflicts: bool or function of L{StackTransaction}"""
89 self
.__patches
= _TransPatchMap(stack
)
90 self
.__applied
= list(self
.__stack
.patchorder
.applied
)
91 self
.__unapplied
= list(self
.__stack
.patchorder
.unapplied
)
92 self
.__hidden
= list(self
.__stack
.patchorder
.hidden
)
94 self
.__current_tree
= self
.__stack
.head
.data
.tree
95 self
.__base
= self
.__stack
.base
96 self
.__discard_changes
= discard_changes
97 self
.__bad_head
= None
98 self
.__conflicts
= None
99 if isinstance(allow_conflicts
, bool):
100 self
.__allow_conflicts
= lambda trans
: allow_conflicts
102 self
.__allow_conflicts
= allow_conflicts
103 self
.__temp_index
= self
.temp_index_tree
= None
104 if not allow_bad_head
:
105 self
.__assert_head_top_equal()
107 self
.__assert_index_worktree_clean(check_clean_iw
)
108 stack
= property(lambda self
: self
.__stack
)
109 patches
= property(lambda self
: self
.__patches
)
110 def __set_applied(self
, val
):
111 self
.__applied
= list(val
)
112 applied
= property(lambda self
: self
.__applied
, __set_applied
)
113 def __set_unapplied(self
, val
):
114 self
.__unapplied
= list(val
)
115 unapplied
= property(lambda self
: self
.__unapplied
, __set_unapplied
)
116 def __set_hidden(self
, val
):
117 self
.__hidden
= list(val
)
118 hidden
= property(lambda self
: self
.__hidden
, __set_hidden
)
119 all_patches
= property(lambda self
: (self
.__applied
+ self
.__unapplied
121 def __set_base(self
, val
):
122 assert (not self
.__applied
123 or self
.patches
[self
.applied
[0]].data
.parent
== val
)
125 base
= property(lambda self
: self
.__base
, __set_base
)
127 def temp_index(self
):
128 if not self
.__temp_index
:
129 self
.__temp_index
= self
.__stack
.repository
.temp_index()
130 atexit
.register(self
.__temp_index
.delete
)
131 return self
.__temp_index
135 return self
.__patches
[self
.__applied
[-1]]
138 def __get_head(self
):
140 return self
.__bad_head
143 def __set_head(self
, val
):
144 self
.__bad_head
= val
145 head
= property(__get_head
, __set_head
)
146 def __assert_head_top_equal(self
):
147 if not self
.__stack
.head_top_equal():
149 'HEAD and top are not the same.',
150 'This can happen if you modify a branch with git.',
151 '"stg repair --help" explains more about what to do next.')
153 def __assert_index_worktree_clean(self
, iw
):
154 if not iw
.worktree_clean():
155 self
.__halt('Worktree not clean. Use "refresh" or "status --reset"')
156 if not iw
.index
.is_clean(self
.stack
.head
):
157 self
.__halt('Index not clean. Use "refresh" or "status --reset"')
158 def __checkout(self
, tree
, iw
, allow_bad_head
):
159 if not allow_bad_head
:
160 self
.__assert_head_top_equal()
161 if self
.__current_tree
== tree
and not self
.__discard_changes
:
162 # No tree change, but we still want to make sure that
163 # there are no unresolved conflicts. Conflicts
164 # conceptually "belong" to the topmost patch, and just
165 # carrying them along to another patch is confusing.
166 if (self
.__allow_conflicts(self
) or iw
== None
167 or not iw
.index
.conflicts()):
169 out
.error('Need to resolve conflicts first')
172 if self
.__discard_changes
:
173 iw
.checkout_hard(tree
)
175 iw
.checkout(self
.__current_tree
, tree
)
176 self
.__current_tree
= tree
179 raise TransactionException(
180 'Command aborted (all changes rolled back)')
181 def __check_consistency(self
):
182 remaining
= set(self
.all_patches
)
183 for pn
, commit
in self
.__patches
.iteritems():
185 assert self
.__stack
.patches
.exists(pn
)
187 assert pn
in remaining
188 def abort(self
, iw
= None):
189 # The only state we need to restore is index+worktree.
191 self
.__checkout(self
.__stack
.head
.data
.tree
, iw
,
192 allow_bad_head
= True)
193 def run(self
, iw
= None, set_head
= True, allow_bad_head
= False,
194 print_current_patch
= True):
195 """Execute the transaction. Will either succeed, or fail (with an
196 exception) and do nothing."""
197 self
.__check_consistency()
198 log
.log_external_mods(self
.__stack
)
205 self
.__checkout(new_head
.data
.tree
, iw
, allow_bad_head
)
206 except git
.CheckoutException
:
207 # We have to abort the transaction.
210 self
.__stack
.set_head(new_head
, self
.__msg
)
214 out
.error(*([self
.__error
] + self
.__conflicts
))
216 out
.error(self
.__error
)
220 for pn
, commit
in self
.__patches
.iteritems():
221 if self
.__stack
.patches
.exists(pn
):
222 p
= self
.__stack
.patches
.get(pn
)
226 p
.set_commit(commit
, msg
)
228 self
.__stack
.patches
.new(pn
, commit
, msg
)
229 self
.__stack
.patchorder
.applied
= self
.__applied
230 self
.__stack
.patchorder
.unapplied
= self
.__unapplied
231 self
.__stack
.patchorder
.hidden
= self
.__hidden
232 log
.log_entry(self
.__stack
, msg
)
233 old_applied
= self
.__stack
.patchorder
.applied
234 if not self
.__conflicts
:
237 write(self
.__msg
+ ' (CONFLICT)')
238 if print_current_patch
:
239 _print_current_patch(old_applied
, self
.__applied
)
242 return utils
.STGIT_CONFLICT
244 return utils
.STGIT_SUCCESS
246 def __halt(self
, msg
):
248 raise TransactionHalted(msg
)
251 def __print_popped(popped
):
254 elif len(popped
) == 1:
255 out
.info('Popped %s' % popped
[0])
257 out
.info('Popped %s -- %s' %
(popped
[-1], popped
[0]))
259 def pop_patches(self
, p
):
260 """Pop all patches pn for which p(pn) is true. Return the list of
261 other patches that had to be popped to accomplish this. Always
264 for i
in xrange(len(self
.applied
)):
265 if p(self
.applied
[i
]):
266 popped
= self
.applied
[i
:]
269 popped1
= [pn
for pn
in popped
if not p(pn
)]
270 popped2
= [pn
for pn
in popped
if p(pn
)]
271 self
.unapplied
= popped1
+ popped2
+ self
.unapplied
272 self
.__print_popped(popped
)
275 def delete_patches(self
, p
, quiet
= False):
276 """Delete all patches pn for which p(pn) is true. Return the list of
277 other patches that had to be popped to accomplish this. Always
280 all_patches
= self
.applied
+ self
.unapplied
+ self
.hidden
281 for i
in xrange(len(self
.applied
)):
282 if p(self
.applied
[i
]):
283 popped
= self
.applied
[i
:]
286 popped
= [pn
for pn
in popped
if not p(pn
)]
287 self
.unapplied
= popped
+ [pn
for pn
in self
.unapplied
if not p(pn
)]
288 self
.hidden
= [pn
for pn
in self
.hidden
if not p(pn
)]
289 self
.__print_popped(popped
)
290 for pn
in all_patches
:
292 s
= ['', ' (empty)'][self
.patches
[pn
].data
.is_nochange()]
293 self
.patches
[pn
] = None
295 out
.info('Deleted %s%s' %
(pn
, s
))
298 def push_patch(self
, pn
, iw
= None, allow_interactive
= False,
299 already_merged
= False):
300 """Attempt to push the named patch. If this results in conflicts,
301 halts the transaction. If index+worktree are given, spill any
302 conflicts to them."""
303 out
.start('Pushing patch "%s"' % pn
)
304 orig_cd
= self
.patches
[pn
].data
305 cd
= orig_cd
.set_committer(None)
306 oldparent
= cd
.parent
307 cd
= cd
.set_parent(self
.top
)
309 # the resulting patch is empty
310 tree
= cd
.parent
.data
.tree
312 base
= oldparent
.data
.tree
313 ours
= cd
.parent
.data
.tree
315 tree
, self
.temp_index_tree
= self
.temp_index
.merge(
316 base
, ours
, theirs
, self
.temp_index_tree
)
318 merge_conflict
= False
321 self
.__halt('%s does not apply cleanly' % pn
)
323 self
.__checkout(ours
, iw
, allow_bad_head
= False)
324 except git
.CheckoutException
:
325 self
.__halt('Index/worktree dirty')
327 interactive
= (allow_interactive
and
328 config
.get('stgit.autoimerge') == 'yes')
329 iw
.merge(base
, ours
, theirs
, interactive
= interactive
)
330 tree
= iw
.index
.write_tree()
331 self
.__current_tree
= tree
333 except git
.MergeConflictException
, e
:
335 merge_conflict
= True
336 self
.__conflicts
= e
.conflicts
338 except git
.MergeException
, e
:
340 cd
= cd
.set_tree(tree
)
341 if any(getattr(cd
, a
) != getattr(orig_cd
, a
) for a
in
342 ['parent', 'tree', 'author', 'message']):
343 comm
= self
.__stack
.repository
.commit(cd
)
345 # When we produce a conflict, we'll run the update()
346 # function defined below _after_ having done the
347 # checkout in run(). To make sure that we check out
348 # the real stack top (as it will look after update()
349 # has been run), set it hard here.
356 elif not merge_conflict
and cd
.is_nochange():
361 # We've just caused conflicts, so we must allow them in
362 # the final checkout.
363 self
.__allow_conflicts
= lambda trans
: True
364 self
.__patches
= _TransPatchMap(self
.__stack
)
366 # Update the stack state
368 self
.patches
[pn
] = comm
369 if pn
in self
.hidden
:
374 self
.applied
.append(pn
)
377 self
.__halt("%d merge conflict(s)" %
len(self
.__conflicts
))
379 def push_tree(self
, pn
):
380 """Push the named patch without updating its tree."""
381 orig_cd
= self
.patches
[pn
].data
382 cd
= orig_cd
.set_committer(None).set_parent(self
.top
)
385 if any(getattr(cd
, a
) != getattr(orig_cd
, a
) for a
in
386 ['parent', 'tree', 'author', 'message']):
387 self
.patches
[pn
] = self
.__stack
.repository
.commit(cd
)
392 out
.info('Pushed %s%s' %
(pn
, s
))
394 if pn
in self
.hidden
:
399 self
.applied
.append(pn
)
401 def reorder_patches(self
, applied
, unapplied
, hidden
= None, iw
= None):
402 """Push and pop patches to attain the given ordering."""
405 common
= len(list(it
.takewhile(lambda (a
, b
): a
== b
,
406 zip(self
.applied
, applied
))))
407 to_pop
= set(self
.applied
[common
:])
408 self
.pop_patches(lambda pn
: pn
in to_pop
)
409 for pn
in applied
[common
:]:
410 self
.push_patch(pn
, iw
)
411 assert self
.applied
== applied
412 assert set(self
.unapplied
+ self
.hidden
) == set(unapplied
+ hidden
)
413 self
.unapplied
= unapplied
416 def check_merged(self
, patches
):
417 """Return a subset of patches already merged."""
418 out
.start('Checking for patches merged upstream')
420 if self
.temp_index_tree
!= self
.stack
.head
.data
.tree
:
421 self
.temp_index
.read_tree(self
.stack
.head
.data
.tree
)
422 self
.temp_index_tree
= self
.stack
.head
.data
.tree
423 for pn
in reversed(patches
):
424 # check whether patch changes can be reversed in the current index
425 cd
= self
.patches
[pn
].data
429 self
.temp_index
.apply_treediff(cd
.tree
, cd
.parent
.data
.tree
,
432 # The self.temp_index was modified by apply_treediff() so
433 # force read_tree() the next time merge() is used.
434 self
.temp_index_tree
= None
435 except git
.MergeException
:
437 out
.done('%d found' %
len(merged
))