~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Martin Pool
  • Date: 2005-08-24 00:34:21 UTC
  • Revision ID: mbp@sourcefrog.net-20050824003421-33dd8e5c739cad2a
- send trace messages out through python logging module

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006, 2007 Canonical Ltd
2
 
#
 
1
# Copyright (C) 2005 Canonical Ltd
 
2
 
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
5
5
# the Free Software Foundation; either version 2 of the License, or
6
6
# (at your option) any later version.
7
 
#
 
7
 
8
8
# This program is distributed in the hope that it will be useful,
9
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
11
# GNU General Public License for more details.
12
 
#
 
12
 
13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
17
 
18
 
# The newly committed revision is going to have a shape corresponding
19
 
# to that of the working inventory.  Files that are not in the
20
 
# working tree and that were in the predecessor are reported as
21
 
# removed --- this can include files that were either removed from the
22
 
# inventory or deleted in the working tree.  If they were only
23
 
# deleted from disk, they are removed from the working inventory.
24
 
 
25
 
# We then consider the remaining entries, which will be in the new
26
 
# version.  Directory entries are simply copied across.  File entries
27
 
# must be checked to see if a new version of the file should be
28
 
# recorded.  For each parent revision inventory, we check to see what
29
 
# version of the file was present.  If the file was present in at
30
 
# least one tree, and if it was the same version in all the trees,
31
 
# then we can just refer to that version.  Otherwise, a new version
32
 
# representing the merger of the file versions must be added.
33
 
 
34
 
# TODO: Update hashcache before and after - or does the WorkingTree
35
 
# look after that?
36
 
 
37
 
# TODO: Rather than mashing together the ancestry and storing it back,
38
 
# perhaps the weave should have single method which does it all in one
39
 
# go, avoiding a lot of redundant work.
40
 
 
41
 
# TODO: Perhaps give a warning if one of the revisions marked as
42
 
# merged is already in the ancestry, and then don't record it as a
43
 
# distinct parent.
44
 
 
45
 
# TODO: If the file is newly merged but unchanged from the version it
46
 
# merges from, then it should still be reported as newly added
47
 
# relative to the basis revision.
48
 
 
49
 
# TODO: Change the parameter 'rev_id' to 'revision_id' to be consistent with
50
 
# the rest of the code; add a deprecation of the old name.
51
 
 
52
 
import os
53
 
import re
54
 
import sys
55
 
import time
56
 
 
57
 
from cStringIO import StringIO
58
 
 
59
 
from bzrlib import (
60
 
    debug,
61
 
    errors,
62
 
    inventory,
63
 
    tree,
64
 
    )
65
 
from bzrlib.branch import Branch
66
 
import bzrlib.config
67
 
from bzrlib.errors import (BzrError, PointlessCommit,
68
 
                           ConflictsInTree,
69
 
                           StrictCommitFailed
70
 
                           )
71
 
from bzrlib.osutils import (kind_marker, isdir,isfile, is_inside_any, 
72
 
                            is_inside_or_parent_of_any,
73
 
                            quotefn, sha_file, split_lines)
74
 
from bzrlib.testament import Testament
75
 
from bzrlib.trace import mutter, note, warning
76
 
from bzrlib.xml5 import serializer_v5
77
 
from bzrlib.inventory import Inventory, InventoryEntry
78
 
from bzrlib import symbol_versioning
79
 
from bzrlib.symbol_versioning import (deprecated_passed,
80
 
        deprecated_function,
81
 
        DEPRECATED_PARAMETER)
82
 
from bzrlib.workingtree import WorkingTree
83
 
import bzrlib.ui
84
 
 
85
 
 
86
 
class NullCommitReporter(object):
87
 
    """I report on progress of a commit."""
88
 
 
89
 
    def snapshot_change(self, change, path):
90
 
        pass
91
 
 
92
 
    def completed(self, revno, rev_id):
93
 
        pass
94
 
 
95
 
    def deleted(self, file_id):
96
 
        pass
97
 
 
98
 
    def escaped(self, escape_count, message):
99
 
        pass
100
 
 
101
 
    def missing(self, path):
102
 
        pass
103
 
 
104
 
    def renamed(self, change, old_path, new_path):
105
 
        pass
106
 
 
107
 
 
108
 
class ReportCommitToLog(NullCommitReporter):
109
 
 
110
 
    def _note(self, format, *args):
111
 
        """Output a message.
112
 
 
113
 
        Subclasses may choose to override this method.
114
 
        """
115
 
        note(format, *args)
116
 
 
117
 
    def snapshot_change(self, change, path):
118
 
        if change == 'unchanged':
119
 
            return
120
 
        if change == 'added' and path == '':
121
 
            return
122
 
        self._note("%s %s", change, path)
123
 
 
124
 
    def completed(self, revno, rev_id):
125
 
        self._note('Committed revision %d.', revno)
126
 
    
127
 
    def deleted(self, file_id):
128
 
        self._note('deleted %s', file_id)
129
 
 
130
 
    def escaped(self, escape_count, message):
131
 
        self._note("replaced %d control characters in message", escape_count)
132
 
 
133
 
    def missing(self, path):
134
 
        self._note('missing %s', path)
135
 
 
136
 
    def renamed(self, change, old_path, new_path):
137
 
        self._note('%s %s => %s', change, old_path, new_path)
138
 
 
139
 
 
140
 
class Commit(object):
141
 
    """Task of committing a new revision.
142
 
 
143
 
    This is a MethodObject: it accumulates state as the commit is
144
 
    prepared, and then it is discarded.  It doesn't represent
145
 
    historical revisions, just the act of recording a new one.
146
 
 
147
 
            missing_ids
148
 
            Modified to hold a list of files that have been deleted from
149
 
            the working directory; these should be removed from the
150
 
            working inventory.
 
18
 
 
19
# FIXME: "bzr commit doc/format" commits doc/format.txt!
 
20
 
 
21
def commit(branch, message,
 
22
           timestamp=None,
 
23
           timezone=None,
 
24
           committer=None,
 
25
           verbose=True,
 
26
           specific_files=None,
 
27
           rev_id=None,
 
28
           allow_pointless=True):
 
29
    """Commit working copy as a new revision.
 
30
 
 
31
    The basic approach is to add all the file texts into the
 
32
    store, then the inventory, then make a new revision pointing
 
33
    to that inventory and store that.
 
34
 
 
35
    This is not quite safe if the working copy changes during the
 
36
    commit; for the moment that is simply not allowed.  A better
 
37
    approach is to make a temporary copy of the files before
 
38
    computing their hashes, and then add those hashes in turn to
 
39
    the inventory.  This should mean at least that there are no
 
40
    broken hash pointers.  There is no way we can get a snapshot
 
41
    of the whole directory at an instant.  This would also have to
 
42
    be robust against files disappearing, moving, etc.  So the
 
43
    whole thing is a bit hard.
 
44
 
 
45
    This raises PointlessCommit if there are no changes, no new merges,
 
46
    and allow_pointless  is false.
 
47
 
 
48
    timestamp -- if not None, seconds-since-epoch for a
 
49
         postdated/predated commit.
 
50
 
 
51
    specific_files
 
52
        If true, commit only those files.
 
53
 
 
54
    rev_id
 
55
        If set, use this as the new revision id.
 
56
        Useful for test or import commands that need to tightly
 
57
        control what revisions are assigned.  If you duplicate
 
58
        a revision id that exists elsewhere it is your own fault.
 
59
        If null (default), a time/random revision id is generated.
151
60
    """
152
 
    def __init__(self,
153
 
                 reporter=None,
154
 
                 config=None):
155
 
        if reporter is not None:
156
 
            self.reporter = reporter
157
 
        else:
158
 
            self.reporter = NullCommitReporter()
159
 
        self.config = config
160
 
        
161
 
    def commit(self,
162
 
               message=None,
163
 
               timestamp=None,
164
 
               timezone=None,
165
 
               committer=None,
166
 
               specific_files=None,
167
 
               rev_id=None,
168
 
               allow_pointless=True,
169
 
               strict=False,
170
 
               verbose=False,
171
 
               revprops=None,
172
 
               working_tree=None,
173
 
               local=False,
174
 
               reporter=None,
175
 
               config=None,
176
 
               message_callback=None,
177
 
               recursive='down'):
178
 
        """Commit working copy as a new revision.
179
 
 
180
 
        :param message: the commit message (it or message_callback is required)
181
 
 
182
 
        :param timestamp: if not None, seconds-since-epoch for a
183
 
            postdated/predated commit.
184
 
 
185
 
        :param specific_files: If true, commit only those files.
186
 
 
187
 
        :param rev_id: If set, use this as the new revision id.
188
 
            Useful for test or import commands that need to tightly
189
 
            control what revisions are assigned.  If you duplicate
190
 
            a revision id that exists elsewhere it is your own fault.
191
 
            If null (default), a time/random revision id is generated.
192
 
 
193
 
        :param allow_pointless: If true (default), commit even if nothing
194
 
            has changed and no merges are recorded.
195
 
 
196
 
        :param strict: If true, don't allow a commit if the working tree
197
 
            contains unknown files.
198
 
 
199
 
        :param revprops: Properties for new revision
200
 
        :param local: Perform a local only commit.
201
 
        :param recursive: If set to 'down', commit in any subtrees that have
202
 
            pending changes of any sort during this commit.
203
 
        """
204
 
        mutter('preparing to commit')
205
 
 
206
 
        if working_tree is None:
207
 
            raise BzrError("working_tree must be passed into commit().")
208
 
        else:
209
 
            self.work_tree = working_tree
210
 
            self.branch = self.work_tree.branch
211
 
            if getattr(self.work_tree, 'requires_rich_root', lambda: False)():
212
 
                if not self.branch.repository.supports_rich_root():
213
 
                    raise errors.RootNotRich()
214
 
        if message_callback is None:
215
 
            if message is not None:
216
 
                if isinstance(message, str):
217
 
                    message = message.decode(bzrlib.user_encoding)
218
 
                message_callback = lambda x: message
219
 
            else:
220
 
                raise BzrError("The message or message_callback keyword"
221
 
                               " parameter is required for commit().")
222
 
 
223
 
        self.bound_branch = None
224
 
        self.local = local
225
 
        self.master_branch = None
226
 
        self.master_locked = False
227
 
        self.rev_id = None
228
 
        self.specific_files = specific_files
229
 
        self.allow_pointless = allow_pointless
230
 
        self.recursive = recursive
231
 
        self.revprops = revprops
232
 
        self.message_callback = message_callback
233
 
        self.timestamp = timestamp
234
 
        self.timezone = timezone
235
 
        self.committer = committer
236
 
        self.strict = strict
237
 
        self.verbose = verbose
238
 
 
239
 
        if reporter is None and self.reporter is None:
240
 
            self.reporter = NullCommitReporter()
241
 
        elif reporter is not None:
242
 
            self.reporter = reporter
243
 
 
244
 
        self.work_tree.lock_write()
245
 
        self.pb = bzrlib.ui.ui_factory.nested_progress_bar()
246
 
        self.basis_tree = self.work_tree.basis_tree()
247
 
        self.basis_tree.lock_read()
248
 
        try:
249
 
            # Cannot commit with conflicts present.
250
 
            if len(self.work_tree.conflicts()) > 0:
251
 
                raise ConflictsInTree
252
 
 
253
 
            # Setup the bound branch variables as needed.
254
 
            self._check_bound_branch()
255
 
 
256
 
            # Check that the working tree is up to date
257
 
            old_revno,new_revno = self._check_out_of_date_tree()
258
 
 
259
 
            if self.config is None:
260
 
                self.config = self.branch.get_config()
261
 
 
262
 
            # If provided, ensure the specified files are versioned
263
 
            if specific_files is not None:
264
 
                # Note: We don't actually need the IDs here. This routine
265
 
                # is being called because it raises PathNotVerisonedError
266
 
                # as a side effect of finding the IDs.
267
 
                # XXX: Dont we have filter_unversioned to do this more
268
 
                # cheaply?
269
 
                tree.find_ids_across_trees(specific_files,
270
 
                                           [self.basis_tree, self.work_tree])
271
 
 
272
 
            # Setup the progress bar. As the number of files that need to be
273
 
            # committed in unknown, progress is reported as stages.
274
 
            # We keep track of entries separately though and include that
275
 
            # information in the progress bar during the relevant stages.
276
 
            self.pb_stage_name = ""
277
 
            self.pb_stage_count = 0
278
 
            self.pb_stage_total = 4
279
 
            if self.bound_branch:
280
 
                self.pb_stage_total += 1
281
 
            self.pb.show_pct = False
282
 
            self.pb.show_spinner = False
283
 
            self.pb.show_eta = False
284
 
            self.pb.show_count = True
285
 
            self.pb.show_bar = True
286
 
 
287
 
            # After a merge, a selected file commit is not supported.
288
 
            # See 'bzr help merge' for an explanation as to why.
289
 
            self.basis_inv = self.basis_tree.inventory
290
 
            self._gather_parents()
291
 
            if len(self.parents) > 1 and self.specific_files:
292
 
                raise errors.CannotCommitSelectedFileMerge(self.specific_files)
293
 
            
294
 
            # Collect the changes
295
 
            self._set_progress_stage("Collecting changes",
296
 
                    entries_title="Directory")
297
 
            self.builder = self.branch.get_commit_builder(self.parents,
298
 
                self.config, timestamp, timezone, committer, revprops, rev_id)
299
 
            try:
300
 
                self._update_builder_with_changes()
301
 
                self._check_pointless()
302
 
 
303
 
                # TODO: Now the new inventory is known, check for conflicts.
304
 
                # ADHB 2006-08-08: If this is done, populate_new_inv should not add
305
 
                # weave lines, because nothing should be recorded until it is known
306
 
                # that commit will succeed.
307
 
                self._set_progress_stage("Saving data locally")
308
 
                self.builder.finish_inventory()
309
 
 
310
 
                # Prompt the user for a commit message if none provided
311
 
                message = message_callback(self)
312
 
                assert isinstance(message, unicode), type(message)
313
 
                self.message = message
314
 
                self._escape_commit_message()
315
 
 
316
 
                # Add revision data to the local branch
317
 
                self.rev_id = self.builder.commit(self.message)
318
 
            except:
319
 
                # perhaps this should be done by the CommitBuilder ?
320
 
                self.work_tree.branch.repository.abort_write_group()
321
 
                raise
322
 
 
323
 
            # Upload revision data to the master.
324
 
            # this will propagate merged revisions too if needed.
325
 
            if self.bound_branch:
326
 
                self._set_progress_stage("Uploading data to master branch")
327
 
                self.master_branch.repository.fetch(self.branch.repository,
328
 
                                                    revision_id=self.rev_id)
329
 
                # now the master has the revision data
330
 
                # 'commit' to the master first so a timeout here causes the
331
 
                # local branch to be out of date
332
 
                self.master_branch.set_last_revision_info(new_revno,
333
 
                                                          self.rev_id)
334
 
 
335
 
            # and now do the commit locally.
336
 
            self.branch.set_last_revision_info(new_revno, self.rev_id)
337
 
 
338
 
            # Make the working tree up to date with the branch
339
 
            self._set_progress_stage("Updating the working tree")
340
 
            rev_tree = self.builder.revision_tree()
341
 
            self.work_tree.set_parent_trees([(self.rev_id, rev_tree)])
342
 
            self.reporter.completed(new_revno, self.rev_id)
343
 
            self._process_hooks(old_revno, new_revno)
344
 
        finally:
345
 
            self._cleanup()
346
 
        return self.rev_id
347
 
 
348
 
    def _any_real_changes(self):
349
 
        """Are there real changes between new_inventory and basis?
350
 
 
351
 
        For trees without rich roots, inv.root.revision changes every commit.
352
 
        But if that is the only change, we want to treat it as though there
353
 
        are *no* changes.
354
 
        """
355
 
        new_entries = self.builder.new_inventory.iter_entries()
356
 
        basis_entries = self.basis_inv.iter_entries()
357
 
        new_path, new_root_ie = new_entries.next()
358
 
        basis_path, basis_root_ie = basis_entries.next()
359
 
 
360
 
        # This is a copy of InventoryEntry.__eq__ only leaving out .revision
361
 
        def ie_equal_no_revision(this, other):
362
 
            return ((this.file_id == other.file_id)
363
 
                    and (this.name == other.name)
364
 
                    and (this.symlink_target == other.symlink_target)
365
 
                    and (this.text_sha1 == other.text_sha1)
366
 
                    and (this.text_size == other.text_size)
367
 
                    and (this.text_id == other.text_id)
368
 
                    and (this.parent_id == other.parent_id)
369
 
                    and (this.kind == other.kind)
370
 
                    and (this.executable == other.executable)
371
 
                    and (this.reference_revision == other.reference_revision)
372
 
                    )
373
 
        if not ie_equal_no_revision(new_root_ie, basis_root_ie):
374
 
            return True
375
 
 
376
 
        for new_ie, basis_ie in zip(new_entries, basis_entries):
377
 
            if new_ie != basis_ie:
378
 
                return True
379
 
 
380
 
        # No actual changes present
381
 
        return False
382
 
 
383
 
    def _check_pointless(self):
384
 
        if self.allow_pointless:
385
 
            return
386
 
        # A merge with no effect on files
387
 
        if len(self.parents) > 1:
388
 
            return
389
 
        # work around the fact that a newly-initted tree does differ from its
390
 
        # basis
391
 
        if len(self.basis_inv) == 0 and len(self.builder.new_inventory) == 1:
 
61
 
 
62
    import time, tempfile
 
63
 
 
64
    from bzrlib.osutils import local_time_offset, username
 
65
    from bzrlib.branch import gen_file_id
 
66
    from bzrlib.errors import BzrError, PointlessCommit
 
67
    from bzrlib.revision import Revision, RevisionReference
 
68
    from bzrlib.trace import mutter, note
 
69
    from bzrlib.xml import pack_xml
 
70
 
 
71
    branch.lock_write()
 
72
 
 
73
    try:
 
74
        # First walk over the working inventory; and both update that
 
75
        # and also build a new revision inventory.  The revision
 
76
        # inventory needs to hold the text-id, sha1 and size of the
 
77
        # actual file versions committed in the revision.  (These are
 
78
        # not present in the working inventory.)  We also need to
 
79
        # detect missing/deleted files, and remove them from the
 
80
        # working inventory.
 
81
 
 
82
        work_tree = branch.working_tree()
 
83
        work_inv = work_tree.inventory
 
84
        basis = branch.basis_tree()
 
85
        basis_inv = basis.inventory
 
86
 
 
87
        if verbose:
 
88
            # note('looking for changes...')
 
89
            # print 'looking for changes...'
 
90
            # disabled; should be done at a higher level
 
91
            pass
 
92
 
 
93
        pending_merges = branch.pending_merges()
 
94
 
 
95
        missing_ids, new_inv, any_changes = \
 
96
                     _gather_commit(branch,
 
97
                                    work_tree,
 
98
                                    work_inv,
 
99
                                    basis_inv,
 
100
                                    specific_files,
 
101
                                    verbose)
 
102
 
 
103
        if not (any_changes or allow_pointless or pending_merges):
392
104
            raise PointlessCommit()
393
 
        # Shortcut, if the number of entries changes, then we obviously have
394
 
        # a change
395
 
        if len(self.builder.new_inventory) != len(self.basis_inv):
396
 
            return
397
 
        # If length == 1, then we only have the root entry. Which means
398
 
        # that there is no real difference (only the root could be different)
399
 
        if (len(self.builder.new_inventory) != 1 and self._any_real_changes()):
400
 
            return
401
 
        raise PointlessCommit()
402
 
 
403
 
    def _check_bound_branch(self):
404
 
        """Check to see if the local branch is bound.
405
 
 
406
 
        If it is bound, then most of the commit will actually be
407
 
        done using the remote branch as the target branch.
408
 
        Only at the end will the local branch be updated.
409
 
        """
410
 
        if self.local and not self.branch.get_bound_location():
411
 
            raise errors.LocalRequiresBoundBranch()
412
 
 
413
 
        if not self.local:
414
 
            self.master_branch = self.branch.get_master_branch()
415
 
 
416
 
        if not self.master_branch:
417
 
            # make this branch the reference branch for out of date checks.
418
 
            self.master_branch = self.branch
419
 
            return
420
 
 
421
 
        # If the master branch is bound, we must fail
422
 
        master_bound_location = self.master_branch.get_bound_location()
423
 
        if master_bound_location:
424
 
            raise errors.CommitToDoubleBoundBranch(self.branch,
425
 
                    self.master_branch, master_bound_location)
426
 
 
427
 
        # TODO: jam 20051230 We could automatically push local
428
 
        #       commits to the remote branch if they would fit.
429
 
        #       But for now, just require remote to be identical
430
 
        #       to local.
431
 
        
432
 
        # Make sure the local branch is identical to the master
433
 
        master_info = self.master_branch.last_revision_info()
434
 
        local_info = self.branch.last_revision_info()
435
 
        if local_info != master_info:
436
 
            raise errors.BoundBranchOutOfDate(self.branch,
437
 
                    self.master_branch)
438
 
 
439
 
        # Now things are ready to change the master branch
440
 
        # so grab the lock
441
 
        self.bound_branch = self.branch
442
 
        self.master_branch.lock_write()
443
 
        self.master_locked = True
444
 
 
445
 
    def _check_out_of_date_tree(self):
446
 
        """Check that the working tree is up to date.
447
 
 
448
 
        :return: old_revision_number,new_revision_number tuple
449
 
        """
450
 
        try:
451
 
            first_tree_parent = self.work_tree.get_parent_ids()[0]
452
 
        except IndexError:
453
 
            # if there are no parents, treat our parent as 'None'
454
 
            # this is so that we still consider the master branch
455
 
            # - in a checkout scenario the tree may have no
456
 
            # parents but the branch may do.
457
 
            first_tree_parent = bzrlib.revision.NULL_REVISION
458
 
        old_revno, master_last = self.master_branch.last_revision_info()
459
 
        if master_last != first_tree_parent:
460
 
            if master_last != bzrlib.revision.NULL_REVISION:
461
 
                raise errors.OutOfDateTree(self.work_tree)
462
 
        if self.branch.repository.has_revision(first_tree_parent):
463
 
            new_revno = old_revno + 1
464
 
        else:
465
 
            # ghost parents never appear in revision history.
466
 
            new_revno = 1
467
 
        return old_revno,new_revno
468
 
 
469
 
    def _process_hooks(self, old_revno, new_revno):
470
 
        """Process any registered commit hooks."""
471
 
        # Process the post commit hooks, if any
472
 
        self._set_progress_stage("Running post commit hooks")
473
 
        # old style commit hooks - should be deprecated ? (obsoleted in
474
 
        # 0.15)
475
 
        if self.config.post_commit() is not None:
476
 
            hooks = self.config.post_commit().split(' ')
477
 
            # this would be nicer with twisted.python.reflect.namedAny
478
 
            for hook in hooks:
479
 
                result = eval(hook + '(branch, rev_id)',
480
 
                              {'branch':self.branch,
481
 
                               'bzrlib':bzrlib,
482
 
                               'rev_id':self.rev_id})
483
 
        # new style commit hooks:
484
 
        if not self.bound_branch:
485
 
            hook_master = self.branch
486
 
            hook_local = None
487
 
        else:
488
 
            hook_master = self.master_branch
489
 
            hook_local = self.branch
490
 
        # With bound branches, when the master is behind the local branch,
491
 
        # the 'old_revno' and old_revid values here are incorrect.
492
 
        # XXX: FIXME ^. RBC 20060206
493
 
        if self.parents:
494
 
            old_revid = self.parents[0]
495
 
        else:
496
 
            old_revid = bzrlib.revision.NULL_REVISION
497
 
        for hook in Branch.hooks['post_commit']:
498
 
            # show the running hook in the progress bar. As hooks may
499
 
            # end up doing nothing (e.g. because they are not configured by
500
 
            # the user) this is still showing progress, not showing overall
501
 
            # actions - its up to each plugin to show a UI if it want's to
502
 
            # (such as 'Emailing diff to foo@example.com').
503
 
            self.pb_stage_name = "Running post commit hooks [%s]" % \
504
 
                Branch.hooks.get_hook_name(hook)
505
 
            self._emit_progress()
506
 
            if 'hooks' in debug.debug_flags:
507
 
                mutter("Invoking commit hook: %r", hook)
508
 
            hook(hook_local, hook_master, old_revno, old_revid, new_revno,
509
 
                self.rev_id)
510
 
 
511
 
    def _cleanup(self):
512
 
        """Cleanup any open locks, progress bars etc."""
513
 
        cleanups = [self._cleanup_bound_branch,
514
 
                    self.basis_tree.unlock,
515
 
                    self.work_tree.unlock,
516
 
                    self.pb.finished]
517
 
        found_exception = None
518
 
        for cleanup in cleanups:
519
 
            try:
520
 
                cleanup()
521
 
            # we want every cleanup to run no matter what.
522
 
            # so we have a catchall here, but we will raise the
523
 
            # last encountered exception up the stack: and
524
 
            # typically this will be useful enough.
525
 
            except Exception, e:
526
 
                found_exception = e
527
 
        if found_exception is not None: 
528
 
            # don't do a plan raise, because the last exception may have been
529
 
            # trashed, e is our sure-to-work exception even though it loses the
530
 
            # full traceback. XXX: RBC 20060421 perhaps we could check the
531
 
            # exc_info and if its the same one do a plain raise otherwise 
532
 
            # 'raise e' as we do now.
533
 
            raise e
534
 
 
535
 
    def _cleanup_bound_branch(self):
536
 
        """Executed at the end of a try/finally to cleanup a bound branch.
537
 
 
538
 
        If the branch wasn't bound, this is a no-op.
539
 
        If it was, it resents self.branch to the local branch, instead
540
 
        of being the master.
541
 
        """
542
 
        if not self.bound_branch:
543
 
            return
544
 
        if self.master_locked:
545
 
            self.master_branch.unlock()
546
 
 
547
 
    def _escape_commit_message(self):
548
 
        """Replace xml-incompatible control characters."""
549
 
        # FIXME: RBC 20060419 this should be done by the revision
550
 
        # serialiser not by commit. Then we can also add an unescaper
551
 
        # in the deserializer and start roundtripping revision messages
552
 
        # precisely. See repository_implementations/test_repository.py
553
 
        
554
 
        # Python strings can include characters that can't be
555
 
        # represented in well-formed XML; escape characters that
556
 
        # aren't listed in the XML specification
557
 
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
558
 
        self.message, escape_count = re.subn(
559
 
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
560
 
            lambda match: match.group(0).encode('unicode_escape'),
561
 
            self.message)
562
 
        if escape_count:
563
 
            self.reporter.escaped(escape_count, self.message)
564
 
 
565
 
    def _gather_parents(self):
566
 
        """Record the parents of a merge for merge detection."""
567
 
        # TODO: Make sure that this list doesn't contain duplicate 
568
 
        # entries and the order is preserved when doing this.
569
 
        self.parents = self.work_tree.get_parent_ids()
570
 
        self.parent_invs = [self.basis_inv]
571
 
        for revision in self.parents[1:]:
572
 
            if self.branch.repository.has_revision(revision):
573
 
                mutter('commit parent revision {%s}', revision)
574
 
                inventory = self.branch.repository.get_inventory(revision)
575
 
                self.parent_invs.append(inventory)
 
105
 
 
106
        for file_id in missing_ids:
 
107
            # Any files that have been deleted are now removed from the
 
108
            # working inventory.  Files that were not selected for commit
 
109
            # are left as they were in the working inventory and ommitted
 
110
            # from the revision inventory.
 
111
 
 
112
            # have to do this later so we don't mess up the iterator.
 
113
            # since parents may be removed before their children we
 
114
            # have to test.
 
115
 
 
116
            # FIXME: There's probably a better way to do this; perhaps
 
117
            # the workingtree should know how to filter itbranch.
 
118
            if work_inv.has_id(file_id):
 
119
                del work_inv[file_id]
 
120
 
 
121
        if rev_id is None:
 
122
            rev_id = _gen_revision_id(branch, time.time())
 
123
        inv_id = rev_id
 
124
 
 
125
        inv_tmp = tempfile.TemporaryFile()
 
126
        pack_xml(new_inv, inv_tmp)
 
127
        inv_tmp.seek(0)
 
128
        branch.inventory_store.add(inv_tmp, inv_id)
 
129
        mutter('new inventory_id is {%s}' % inv_id)
 
130
 
 
131
        # We could also just sha hash the inv_tmp file
 
132
        # however, in the case that branch.inventory_store.add()
 
133
        # ever actually does anything special
 
134
        inv_sha1 = branch.get_inventory_sha1(inv_id)
 
135
 
 
136
        branch._write_inventory(work_inv)
 
137
 
 
138
        if timestamp == None:
 
139
            timestamp = time.time()
 
140
 
 
141
        if committer == None:
 
142
            committer = username(branch)
 
143
 
 
144
        if timezone == None:
 
145
            timezone = local_time_offset()
 
146
 
 
147
        mutter("building commit log message")
 
148
        rev = Revision(timestamp=timestamp,
 
149
                       timezone=timezone,
 
150
                       committer=committer,
 
151
                       message = message,
 
152
                       inventory_id=inv_id,
 
153
                       inventory_sha1=inv_sha1,
 
154
                       revision_id=rev_id)
 
155
 
 
156
        rev.parents = []
 
157
        precursor_id = branch.last_patch()
 
158
        if precursor_id:
 
159
            precursor_sha1 = branch.get_revision_sha1(precursor_id)
 
160
            rev.parents.append(RevisionReference(precursor_id, precursor_sha1))
 
161
        for merge_rev in pending_merges:
 
162
            rev.parents.append(RevisionReference(merge_rev))            
 
163
 
 
164
        rev_tmp = tempfile.TemporaryFile()
 
165
        pack_xml(rev, rev_tmp)
 
166
        rev_tmp.seek(0)
 
167
        branch.revision_store.add(rev_tmp, rev_id)
 
168
        mutter("new revision_id is {%s}" % rev_id)
 
169
 
 
170
        ## XXX: Everything up to here can simply be orphaned if we abort
 
171
        ## the commit; it will leave junk files behind but that doesn't
 
172
        ## matter.
 
173
 
 
174
        ## TODO: Read back the just-generated changeset, and make sure it
 
175
        ## applies and recreates the right state.
 
176
 
 
177
        ## TODO: Also calculate and store the inventory SHA1
 
178
        mutter("committing patch r%d" % (branch.revno() + 1))
 
179
 
 
180
        branch.append_revision(rev_id)
 
181
 
 
182
        branch.set_pending_merges([])
 
183
 
 
184
        if verbose:
 
185
            # disabled; should go through logging
 
186
            # note("commited r%d" % branch.revno())
 
187
            # print ("commited r%d" % branch.revno())
 
188
            pass
 
189
    finally:
 
190
        branch.unlock()
 
191
 
 
192
 
 
193
 
 
194
def _gen_revision_id(branch, when):
 
195
    """Return new revision-id."""
 
196
    from binascii import hexlify
 
197
    from bzrlib.osutils import rand_bytes, compact_date, user_email
 
198
 
 
199
    s = '%s-%s-' % (user_email(branch), compact_date(when))
 
200
    s += hexlify(rand_bytes(8))
 
201
    return s
 
202
 
 
203
 
 
204
def _gather_commit(branch, work_tree, work_inv, basis_inv, specific_files,
 
205
                   verbose):
 
206
    """Build inventory preparatory to commit.
 
207
 
 
208
    Returns missing_ids, new_inv, any_changes.
 
209
 
 
210
    This adds any changed files into the text store, and sets their
 
211
    test-id, sha and size in the returned inventory appropriately.
 
212
 
 
213
    missing_ids
 
214
        Modified to hold a list of files that have been deleted from
 
215
        the working directory; these should be removed from the
 
216
        working inventory.
 
217
    """
 
218
    from bzrlib.inventory import Inventory
 
219
    from bzrlib.osutils import isdir, isfile, sha_string, quotefn, \
 
220
         local_time_offset, username, kind_marker, is_inside_any
 
221
    
 
222
    from bzrlib.branch import gen_file_id
 
223
    from bzrlib.errors import BzrError
 
224
    from bzrlib.revision import Revision
 
225
    from bzrlib.trace import mutter, note
 
226
 
 
227
    any_changes = False
 
228
    inv = Inventory(work_inv.root.file_id)
 
229
    missing_ids = []
 
230
    
 
231
    for path, entry in work_inv.iter_entries():
 
232
        ## TODO: Check that the file kind has not changed from the previous
 
233
        ## revision of this file (if any).
 
234
 
 
235
        p = branch.abspath(path)
 
236
        file_id = entry.file_id
 
237
        mutter('commit prep file %s, id %r ' % (p, file_id))
 
238
 
 
239
        if specific_files and not is_inside_any(specific_files, path):
 
240
            mutter('  skipping file excluded from commit')
 
241
            if basis_inv.has_id(file_id):
 
242
                # carry over with previous state
 
243
                inv.add(basis_inv[file_id].copy())
576
244
            else:
577
 
                mutter('commit parent ghost revision {%s}', revision)
578
 
 
579
 
    def _update_builder_with_changes(self):
580
 
        """Update the commit builder with the data about what has changed.
581
 
        """
582
 
        # Build the revision inventory.
583
 
        #
584
 
        # This starts by creating a new empty inventory. Depending on
585
 
        # which files are selected for commit, and what is present in the
586
 
        # current tree, the new inventory is populated. inventory entries 
587
 
        # which are candidates for modification have their revision set to
588
 
        # None; inventory entries that are carried over untouched have their
589
 
        # revision set to their prior value.
590
 
        #
591
 
        # ESEPARATIONOFCONCERNS: this function is diffing and using the diff
592
 
        # results to create a new inventory at the same time, which results
593
 
        # in bugs like #46635.  Any reason not to use/enhance Tree.changes_from?
594
 
        # ADHB 11-07-2006
595
 
 
596
 
        specific_files = self.specific_files
597
 
        mutter("Selecting files for commit with filter %s", specific_files)
598
 
 
599
 
        # Check and warn about old CommitBuilders
600
 
        if not self.builder.record_root_entry:
601
 
            symbol_versioning.warn('CommitBuilders should support recording'
602
 
                ' the root entry as of bzr 0.10.', DeprecationWarning, 
603
 
                stacklevel=1)
604
 
            self.builder.new_inventory.add(self.basis_inv.root.copy())
605
 
 
606
 
        # Build the new inventory
607
 
        self._populate_from_inventory(specific_files)
608
 
 
609
 
        # If specific files are selected, then all un-selected files must be
610
 
        # recorded in their previous state. For more details, see
611
 
        # https://lists.ubuntu.com/archives/bazaar/2007q3/028476.html.
612
 
        if specific_files:
613
 
            for path, new_ie in self.basis_inv.iter_entries():
614
 
                if new_ie.file_id in self.builder.new_inventory:
615
 
                    continue
616
 
                if is_inside_any(specific_files, path):
617
 
                    continue
618
 
                ie = new_ie.copy()
619
 
                ie.revision = None
620
 
                self.builder.record_entry_contents(ie, self.parent_invs, path,
621
 
                                                   self.basis_tree)
622
 
 
623
 
        # Report what was deleted. We could skip this when no deletes are
624
 
        # detected to gain a performance win, but it arguably serves as a
625
 
        # 'safety check' by informing the user whenever anything disappears.
626
 
        for path, ie in self.basis_inv.iter_entries():
627
 
            if ie.file_id not in self.builder.new_inventory:
628
 
                self.reporter.deleted(path)
629
 
 
630
 
    def _populate_from_inventory(self, specific_files):
631
 
        """Populate the CommitBuilder by walking the working tree inventory."""
632
 
        if self.strict:
633
 
            # raise an exception as soon as we find a single unknown.
634
 
            for unknown in self.work_tree.unknowns():
635
 
                raise StrictCommitFailed()
636
 
               
637
 
        deleted_ids = []
638
 
        deleted_paths = set()
639
 
        work_inv = self.work_tree.inventory
640
 
        assert work_inv.root is not None
641
 
        entries = work_inv.iter_entries()
642
 
        if not self.builder.record_root_entry:
643
 
            entries.next()
644
 
        for path, existing_ie in entries:
645
 
            file_id = existing_ie.file_id
646
 
            name = existing_ie.name
647
 
            parent_id = existing_ie.parent_id
648
 
            kind = existing_ie.kind
649
 
            if kind == 'directory':
650
 
                self._next_progress_entry()
651
 
 
652
 
            # Skip files that have been deleted from the working tree.
653
 
            # The deleted files/directories are also recorded so they
654
 
            # can be explicitly unversioned later. Note that when a
655
 
            # filter of specific files is given, we must only skip/record
656
 
            # deleted files matching that filter.
657
 
            if is_inside_any(deleted_paths, path):
658
 
                continue
659
 
            if not specific_files or is_inside_any(specific_files, path):
660
 
                if not self.work_tree.has_filename(path):
661
 
                    deleted_paths.add(path)
662
 
                    self.reporter.missing(path)
663
 
                    deleted_ids.append(file_id)
664
 
                    continue
665
 
            try:
666
 
                kind = self.work_tree.kind(file_id)
667
 
                # TODO: specific_files filtering before nested tree processing
668
 
                if kind == 'tree-reference' and self.recursive == 'down':
669
 
                    self._commit_nested_tree(file_id, path)
670
 
            except errors.NoSuchFile:
 
245
                # omit this from committed inventory
671
246
                pass
672
 
 
673
 
            # Record an entry for this item
674
 
            # Note: I don't particularly want to have the existing_ie
675
 
            # parameter but the test suite currently (28-Jun-07) breaks
676
 
            # without it thanks to a unicode normalisation issue. :-(
677
 
            definitely_changed = kind != existing_ie.kind 
678
 
            self._record_entry(path, file_id, specific_files, kind, name,
679
 
                parent_id, definitely_changed, existing_ie)
680
 
 
681
 
        # Unversion IDs that were found to be deleted
682
 
        self.work_tree.unversion(deleted_ids)
683
 
 
684
 
    def _commit_nested_tree(self, file_id, path):
685
 
        "Commit a nested tree."
686
 
        sub_tree = self.work_tree.get_nested_tree(file_id, path)
687
 
        # FIXME: be more comprehensive here:
688
 
        # this works when both trees are in --trees repository,
689
 
        # but when both are bound to a different repository,
690
 
        # it fails; a better way of approaching this is to 
691
 
        # finally implement the explicit-caches approach design
692
 
        # a while back - RBC 20070306.
693
 
        if (sub_tree.branch.repository.bzrdir.root_transport.base
694
 
            ==
695
 
            self.work_tree.branch.repository.bzrdir.root_transport.base):
696
 
            sub_tree.branch.repository = \
697
 
                self.work_tree.branch.repository
698
 
        try:
699
 
            sub_tree.commit(message=None, revprops=self.revprops,
700
 
                recursive=self.recursive,
701
 
                message_callback=self.message_callback,
702
 
                timestamp=self.timestamp, timezone=self.timezone,
703
 
                committer=self.committer,
704
 
                allow_pointless=self.allow_pointless,
705
 
                strict=self.strict, verbose=self.verbose,
706
 
                local=self.local, reporter=self.reporter)
707
 
        except errors.PointlessCommit:
708
 
            pass
709
 
 
710
 
    def _record_entry(self, path, file_id, specific_files, kind, name,
711
 
                      parent_id, definitely_changed, existing_ie=None):
712
 
        "Record the new inventory entry for a path if any."
713
 
        # mutter('check %s {%s}', path, file_id)
714
 
        if (not specific_files or 
715
 
            is_inside_or_parent_of_any(specific_files, path)):
716
 
                # mutter('%s selected for commit', path)
717
 
                if definitely_changed or existing_ie is None:
718
 
                    ie = inventory.make_entry(kind, name, parent_id, file_id)
719
 
                else:
720
 
                    ie = existing_ie.copy()
721
 
                    ie.revision = None
722
 
        else:
723
 
            # mutter('%s not selected for commit', path)
724
 
            if self.basis_inv.has_id(file_id):
725
 
                ie = self.basis_inv[file_id].copy()
726
 
            else:
727
 
                # this entry is new and not being committed
728
 
                ie = None
729
 
        if ie is not None:
730
 
            self.builder.record_entry_contents(ie, self.parent_invs, 
731
 
                path, self.work_tree)
732
 
            self._report_change(ie, path)
733
 
        return ie
734
 
 
735
 
    def _report_change(self, ie, path):
736
 
        """Report a change to the user.
737
 
 
738
 
        The change that has occurred is described relative to the basis
739
 
        inventory.
740
 
        """
741
 
        if (self.basis_inv.has_id(ie.file_id)):
742
 
            basis_ie = self.basis_inv[ie.file_id]
743
 
        else:
744
 
            basis_ie = None
745
 
        change = ie.describe_change(basis_ie, ie)
746
 
        if change in (InventoryEntry.RENAMED, 
747
 
            InventoryEntry.MODIFIED_AND_RENAMED):
748
 
            old_path = self.basis_inv.id2path(ie.file_id)
749
 
            self.reporter.renamed(change, old_path, path)
750
 
        else:
751
 
            self.reporter.snapshot_change(change, path)
752
 
 
753
 
    def _set_progress_stage(self, name, entries_title=None):
754
 
        """Set the progress stage and emit an update to the progress bar."""
755
 
        self.pb_stage_name = name
756
 
        self.pb_stage_count += 1
757
 
        self.pb_entries_title = entries_title
758
 
        if entries_title is not None:
759
 
            self.pb_entries_count = 0
760
 
            self.pb_entries_total = '?'
761
 
        self._emit_progress()
762
 
 
763
 
    def _next_progress_entry(self):
764
 
        """Emit an update to the progress bar and increment the entry count."""
765
 
        self.pb_entries_count += 1
766
 
        self._emit_progress()
767
 
 
768
 
    def _emit_progress(self):
769
 
        if self.pb_entries_title:
770
 
            if self.pb_entries_total == '?':
771
 
                text = "%s [%s %d] - Stage" % (self.pb_stage_name,
772
 
                    self.pb_entries_title, self.pb_entries_count)
773
 
            else:
774
 
                text = "%s [%s %d/%s] - Stage" % (self.pb_stage_name,
775
 
                    self.pb_entries_title, self.pb_entries_count,
776
 
                    str(self.pb_entries_total))
777
 
        else:
778
 
            text = "%s - Stage" % (self.pb_stage_name)
779
 
        self.pb.update(text, self.pb_stage_count, self.pb_stage_total)
 
247
            continue
 
248
 
 
249
        if not work_tree.has_id(file_id):
 
250
            if verbose:
 
251
                print('deleted %s%s' % (path, kind_marker(entry.kind)))
 
252
                any_changes = True
 
253
            mutter("    file is missing, removing from inventory")
 
254
            missing_ids.append(file_id)
 
255
            continue
 
256
 
 
257
        # this is present in the new inventory; may be new, modified or
 
258
        # unchanged.
 
259
        old_ie = basis_inv.has_id(file_id) and basis_inv[file_id]
 
260
        
 
261
        entry = entry.copy()
 
262
        inv.add(entry)
 
263
 
 
264
        if old_ie:
 
265
            old_kind = old_ie.kind
 
266
            if old_kind != entry.kind:
 
267
                raise BzrError("entry %r changed kind from %r to %r"
 
268
                        % (file_id, old_kind, entry.kind))
 
269
 
 
270
        if entry.kind == 'directory':
 
271
            if not isdir(p):
 
272
                raise BzrError("%s is entered as directory but not a directory"
 
273
                               % quotefn(p))
 
274
        elif entry.kind == 'file':
 
275
            if not isfile(p):
 
276
                raise BzrError("%s is entered as file but is not a file" % quotefn(p))
 
277
 
 
278
            new_sha1 = work_tree.get_file_sha1(file_id)
 
279
 
 
280
            if (old_ie
 
281
                and old_ie.text_sha1 == new_sha1):
 
282
                ## assert content == basis.get_file(file_id).read()
 
283
                entry.text_id = old_ie.text_id
 
284
                entry.text_sha1 = new_sha1
 
285
                entry.text_size = old_ie.text_size
 
286
                mutter('    unchanged from previous text_id {%s}' %
 
287
                       entry.text_id)
 
288
            else:
 
289
                content = file(p, 'rb').read()
 
290
 
 
291
                # calculate the sha again, just in case the file contents
 
292
                # changed since we updated the cache
 
293
                entry.text_sha1 = sha_string(content)
 
294
                entry.text_size = len(content)
 
295
 
 
296
                entry.text_id = gen_file_id(entry.name)
 
297
                branch.text_store.add(content, entry.text_id)
 
298
                mutter('    stored with text_id {%s}' % entry.text_id)
 
299
 
 
300
        if verbose:
 
301
            marked = path + kind_marker(entry.kind)
 
302
            if not old_ie:
 
303
                print 'added', marked
 
304
                any_changes = True
 
305
            elif old_ie == entry:
 
306
                pass                    # unchanged
 
307
            elif (old_ie.name == entry.name
 
308
                  and old_ie.parent_id == entry.parent_id):
 
309
                print 'modified', marked
 
310
                any_changes = True
 
311
            else:
 
312
                print 'renamed', marked
 
313
                any_changes = True
 
314
                        
 
315
    return missing_ids, inv, any_changes
 
316
 
780
317