Changeset 574 in tailor

Timestamp:

08/15/05 18:03:09 (8 years ago)

Author:

lele@…

Hash name:

20050815160309-97f81-ac9cfbf1dc765959bbdd54a7e0fda198db15e313

Message:

Revised the applyPendingChangesets() to save the state only once
The method was rewriting the state file at each iteration over the
pending changesets, very safe but also very time expensive. Now it
does that just once, before leaving.

Also, introduced a new _handleConflict() that subclasses may override
to prompt the user about conflict raised by application of a changeset.

File:

• vcpx/source.py (modified) (2 diffs)

vcpx/source.py

@@ -86 +86 @@
             return last, conflicts
 
-        remaining = self.pending[:]
-        for c in self.pending:
-            if not self._willApplyChangeset(c, applyable):
-                break
-
-            self.log_info("Applying changeset %s" % c.revision)
-
-            try:
-                res = self._applyChangeset(c)
-            except:
-                self.log_error("Couldn't apply changeset %s" % c.revision,
-                               exc=True)
-                raise
-
-            if res:
-                conflicts.append((c, res))
+        try:
+            while self.pending:
+                c = self.pending[0]
+
+                # Give the opportunity to subclasses to stop the application
+                # of the queue, before the application of the patch by the
+                # source backend.
+                if not self._willApplyChangeset(c, applyable):
+                    break
+
+                self.log_info("Applying changeset %s" % c.revision)
+
                 try:
-                    raw_input(CONFLICTS_PROMPT % (str(c), '\n * '.join(res)))
-                except KeyboardInterrupt:
-                    self.log_info("INTERRUPTED BY THE USER!")
-                    return last, conflicts
-
-            if not self._didApplyChangeset(c, replayable):
-                continue
-
-            if replay:
-                replay(c)
-
-            remaining.remove(c)
-            self.state_file.write(c.revision, remaining)
-
-            if applied:
-                applied(c)
-
-            last = c
-
-        self.pending = remaining
+                    res = self._applyChangeset(c)
+                except:
+                    self.log_error("Couldn't apply changeset %s" % c.revision,
+                                   exc=True)
+                    raise
+
+                if res:
+                    # Uh, we have a conflict: this should not ever
+                    # happen, but the user may have manually tweaked
+                    # the working directory. Give her a chance of
+                    # fixing the situation, or abort with Ctrl-C, or
+                    # whatever the subclasses decide.
+                    try:
+                        self._handleConflict(c, conflicts, res)
+                    except KeyboardInterrupt:
+                        self.log_info("INTERRUPTED BY THE USER!")
+                        break
+
+                # Give the opportunity to subclasses to skip the commit on
+                # the target backend.
+                if self._didApplyChangeset(c, replayable):
+                    if replay:
+                        replay(c)
+
+                # Remove it from the queue and remember it for the finally
+                # clause
+                last = self.pending.pop(0)
+
+                # Another hook (last==c here)
+                if applied:
+                    applied(last)
+        finally:
+            # For whatever reason we exit the loop, save the last state
+            self.state_file.write(last.revision, self.pending)
+
         return last, conflicts
 
@@ -154 +165 @@
             return True
 
+    def _handleConflict(self, changeset, conflicts, conflict):
+        """
+        Handle the conflict raised by the application of the upstream changeset.
+
+        This implementation just append a (changeset, conflict) to the
+        list of all conflicts, and present a prompt to the user that
+        may abort with Ctrl-C (that in turn generates a KeyboardInterrupt).
+        """
+
+        conflicts.append((changeset, conflict))
+        raw_input(CONFLICTS_PROMPT % (str(changeset), '\n * '.join(conflict)))
+
     def getPendingChangesets(self, sincerev=None):
         """