← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

[merge] aaron, various fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/commit.py
44
44
# TODO: Update hashcache before and after - or does the WorkingTree
45
45
# look after that?
46
46
 
47
 
# This code requires all merge parents to be present in the branch.
48
 
# We could relax this but for the sake of simplicity the constraint is
49
 
# here for now.  It's not totally clear to me how we'd know which file
50
 
# need new text versions if some parents are absent.  -- mbp 20050915
 
47
# TODO: Rather than mashing together the ancestry and storing it back,
 
48
# perhaps the weave should have single method which does it all in one
 
49
# go, avoiding a lot of redundant work.
 
50
 
 
51
# TODO: Perhaps give a warning if one of the revisions marked as
 
52
# merged is already in the ancestry, and then don't record it as a
 
53
# distinct parent.
 
54
 
 
55
# TODO: If the file is newly merged but unchanged from the version it
 
56
# merges from, then it should still be reported as newly added
 
57
# relative to the basis revision.
 
58
 
 
59
# TODO: Do checks that the tree can be committed *before* running the 
 
60
# editor; this should include checks for a pointless commit and for 
 
61
# unknown or missing files.
 
62
 
 
63
# TODO: If commit fails, leave the message in a file somewhere.
51
64
 
52
65
 
53
66
import os
 
67
import re
54
68
import sys
55
69
import time
56
70
import pdb
58
72
from binascii import hexlify
59
73
from cStringIO import StringIO
60
74
 
61
 
from bzrlib.osutils import (local_time_offset, username,
62
 
                            rand_bytes, compact_date, user_email,
 
75
from bzrlib.osutils import (local_time_offset,
 
76
                            rand_bytes, compact_date,
63
77
                            kind_marker, is_inside_any, quotefn,
64
78
                            sha_string, sha_strings, sha_file, isdir, isfile,
65
79
                            split_lines)
66
 
from bzrlib.branch import gen_file_id, INVENTORY_FILEID, ANCESTRY_FILEID
 
80
from bzrlib.branch import gen_file_id
 
81
import bzrlib.config
67
82
from bzrlib.errors import (BzrError, PointlessCommit,
68
83
                           HistoryMissing,
 
84
                           ConflictsInTree,
 
85
                           StrictCommitFailed
69
86
                           )
70
 
from bzrlib.revision import Revision, RevisionReference
 
87
import bzrlib.gpg as gpg
 
88
from bzrlib.revision import Revision
 
89
from bzrlib.testament import Testament
71
90
from bzrlib.trace import mutter, note, warning
72
91
from bzrlib.xml5 import serializer_v5
73
 
from bzrlib.inventory import Inventory
 
92
from bzrlib.inventory import Inventory, ROOT_ID
74
93
from bzrlib.weave import Weave
75
94
from bzrlib.weavefile import read_weave, write_weave_v5
76
95
from bzrlib.atomicfile import AtomicFile
89
108
 
90
109
class NullCommitReporter(object):
91
110
    """I report on progress of a commit."""
92
 
    def added(self, path):
93
 
        pass
94
 
 
95
 
    def removed(self, path):
96
 
        pass
97
 
 
98
 
    def renamed(self, old_path, new_path):
99
 
        pass
100
 
 
 
111
 
 
112
    def snapshot_change(self, change, path):
 
113
        pass
 
114
 
 
115
    def completed(self, revno, rev_id):
 
116
        pass
 
117
 
 
118
    def deleted(self, file_id):
 
119
        pass
 
120
 
 
121
    def escaped(self, escape_count, message):
 
122
        pass
 
123
 
 
124
    def missing(self, path):
 
125
        pass
101
126
 
102
127
class ReportCommitToLog(NullCommitReporter):
103
 
    def added(self, path):
104
 
        note('added %s', path)
105
 
 
106
 
    def removed(self, path):
107
 
        note('removed %s', path)
108
 
 
109
 
    def renamed(self, old_path, new_path):
110
 
        note('renamed %s => %s', old_path, new_path)
111
 
 
 
128
 
 
129
    def snapshot_change(self, change, path):
 
130
        note("%s %s", change, path)
 
131
 
 
132
    def completed(self, revno, rev_id):
 
133
        note('committed r%d {%s}', revno, rev_id)
 
134
    
 
135
    def deleted(self, file_id):
 
136
        note('deleted %s', file_id)
 
137
 
 
138
    def escaped(self, escape_count, message):
 
139
        note("replaced %d control characters in message", escape_count)
 
140
 
 
141
    def missing(self, path):
 
142
        note('missing %s', path)
112
143
 
113
144
class Commit(object):
114
145
    """Task of committing a new revision.
123
154
            working inventory.
124
155
    """
125
156
    def __init__(self,
126
 
                 reporter=None):
 
157
                 reporter=None,
 
158
                 config=None):
127
159
        if reporter is not None:
128
160
            self.reporter = reporter
129
161
        else:
130
162
            self.reporter = NullCommitReporter()
131
 
 
 
163
        if config is not None:
 
164
            self.config = config
 
165
        else:
 
166
            self.config = None
132
167
        
133
168
    def commit(self,
134
169
               branch, message,
138
173
               specific_files=None,
139
174
               rev_id=None,
140
175
               allow_pointless=True,
141
 
               verbose=False):
 
176
               strict=False,
 
177
               verbose=False,
 
178
               revprops=None):
142
179
        """Commit working copy as a new revision.
143
180
 
144
181
        timestamp -- if not None, seconds-since-epoch for a
154
191
 
155
192
        allow_pointless -- If true (default), commit even if nothing
156
193
            has changed and no merges are recorded.
 
194
 
 
195
        strict -- If true, don't allow a commit if the working tree
 
196
            contains unknown files.
 
197
 
 
198
        revprops -- Properties for new revision
157
199
        """
158
200
        mutter('preparing to commit')
159
201
 
162
204
        self.rev_id = rev_id
163
205
        self.specific_files = specific_files
164
206
        self.allow_pointless = allow_pointless
 
207
        self.revprops = {'branch-nick': branch.nick}
 
208
        if revprops:
 
209
            self.revprops.update(revprops)
 
210
 
 
211
        if strict:
 
212
            # raise an exception as soon as we find a single unknown.
 
213
            for unknown in branch.unknowns():
 
214
                raise StrictCommitFailed()
165
215
 
166
216
        if timestamp is None:
167
217
            self.timestamp = time.time()
168
218
        else:
169
219
            self.timestamp = long(timestamp)
170
220
            
 
221
        if self.config is None:
 
222
            self.config = bzrlib.config.BranchConfig(self.branch)
 
223
 
171
224
        if rev_id is None:
172
 
            self.rev_id = _gen_revision_id(self.branch, self.timestamp)
 
225
            self.rev_id = _gen_revision_id(self.config, self.timestamp)
173
226
        else:
174
227
            self.rev_id = rev_id
175
228
 
176
229
        if committer is None:
177
 
            self.committer = username(self.branch)
 
230
            self.committer = self.config.username()
178
231
        else:
179
232
            assert isinstance(committer, basestring), type(committer)
180
233
            self.committer = committer
186
239
 
187
240
        assert isinstance(message, basestring), type(message)
188
241
        self.message = message
 
242
        self._escape_commit_message()
189
243
 
190
244
        self.branch.lock_write()
191
245
        try:
195
249
            self.basis_inv = self.basis_tree.inventory
196
250
 
197
251
            self._gather_parents()
 
252
            if len(self.parents) > 1 and self.specific_files:
 
253
                raise NotImplementedError('selected-file commit of merges is not supported yet')
198
254
            self._check_parents_present()
199
255
            
200
256
            self._remove_deleted()
201
 
            self.new_inv = Inventory()
202
 
            self._store_entries()
 
257
            self._populate_new_inv()
 
258
            self._store_snapshot()
203
259
            self._report_deletes()
204
260
 
205
261
            if not (self.allow_pointless
207
263
                    or self.new_inv != self.basis_inv):
208
264
                raise PointlessCommit()
209
265
 
 
266
            if len(list(self.work_tree.iter_conflicts()))>0:
 
267
                raise ConflictsInTree
 
268
 
210
269
            self._record_inventory()
211
 
            self._record_ancestry()
212
270
            self._make_revision()
213
 
            note('committed r%d {%s}', (self.branch.revno() + 1),
214
 
                 self.rev_id)
215
271
            self.branch.append_revision(self.rev_id)
216
272
            self.branch.set_pending_merges([])
 
273
            self.reporter.completed(self.branch.revno()+1, self.rev_id)
 
274
            if self.config.post_commit() is not None:
 
275
                hooks = self.config.post_commit().split(' ')
 
276
                # this would be nicer with twisted.python.reflect.namedAny
 
277
                for hook in hooks:
 
278
                    result = eval(hook + '(branch, rev_id)',
 
279
                                  {'branch':self.branch,
 
280
                                   'bzrlib':bzrlib,
 
281
                                   'rev_id':self.rev_id})
217
282
        finally:
218
283
            self.branch.unlock()
219
284
 
220
 
 
221
 
 
222
285
    def _record_inventory(self):
223
286
        """Store the inventory for the new revision."""
224
287
        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)
225
288
        self.inv_sha1 = sha_string(inv_text)
226
 
        self.weave_store.add_text(INVENTORY_FILEID, self.rev_id,
227
 
                                         split_lines(inv_text), self.parents)
228
 
 
229
 
 
230
 
    def _record_ancestry(self):
231
 
        """Append merged revision ancestry to the ancestry file.
232
 
 
233
 
        This should be the merged ancestry of all parents, plus the
234
 
        new revision id."""
235
 
        w = self.weave_store.get_weave_or_empty(ANCESTRY_FILEID)
236
 
        lines = self._merge_ancestry_lines(w)
237
 
        w.add(self.rev_id, self.parents, lines)
238
 
        self.weave_store.put_weave(ANCESTRY_FILEID, w)
239
 
 
240
 
 
241
 
    def _merge_ancestry_lines(self, ancestry_weave):
242
 
        """Return merged ancestry lines.
243
 
 
244
 
        The lines are revision-ids followed by newlines."""
245
 
        seen = set()
246
 
        ancs = []
247
 
        for parent_id in self.parents:
248
 
            for line in ancestry_weave.get(parent_id):
249
 
                assert line[-1] == '\n'
250
 
                if line not in seen:
251
 
                    ancs.append(line)
252
 
                    seen.add(line)
253
 
        r = self.rev_id + '\n'
254
 
        assert r not in ancs
255
 
        ancs.append(r)
256
 
        mutter('merged ancestry of {%s}:\n%s', self.rev_id, ''.join(ancs))
257
 
        return ancs
258
 
 
 
289
        s = self.branch.control_weaves
 
290
        s.add_text('inventory', self.rev_id,
 
291
                   split_lines(inv_text), self.present_parents,
 
292
                   self.branch.get_transaction())
 
293
 
 
294
    def _escape_commit_message(self):
 
295
        """Replace xml-incompatible control characters."""
 
296
        # Python strings can include characters that can't be
 
297
        # represented in well-formed XML; escape characters that
 
298
        # aren't listed in the XML specification
 
299
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
300
        if isinstance(self.message, unicode):
 
301
            char_pattern = u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]'
 
302
        else:
 
303
            # Use a regular 'str' as pattern to avoid having re.subn
 
304
            # return 'unicode' results.
 
305
            char_pattern = '[^x09\x0A\x0D\x20-\xFF]'
 
306
        self.message, escape_count = re.subn(
 
307
            char_pattern,
 
308
            lambda match: match.group(0).encode('unicode_escape'),
 
309
            self.message)
 
310
        if escape_count:
 
311
            self.reporter.escaped(escape_count, self.message)
259
312
 
260
313
    def _gather_parents(self):
 
314
        """Record the parents of a merge for merge detection."""
261
315
        pending_merges = self.branch.pending_merges()
262
316
        self.parents = []
263
 
        self.parent_trees = []
 
317
        self.parent_invs = []
 
318
        self.present_parents = []
264
319
        precursor_id = self.branch.last_revision()
265
320
        if precursor_id:
266
321
            self.parents.append(precursor_id)
267
 
            self.parent_trees.append(self.basis_tree)
268
322
        self.parents += pending_merges
269
 
        self.parent_trees.extend(map(self.branch.revision_tree, pending_merges))
270
 
 
 
323
        for revision in self.parents:
 
324
            if self.branch.has_revision(revision):
 
325
                self.parent_invs.append(self.branch.get_inventory(revision))
 
326
                self.present_parents.append(revision)
271
327
 
272
328
    def _check_parents_present(self):
273
329
        for parent_id in self.parents:
274
330
            mutter('commit parent revision {%s}', parent_id)
275
331
            if not self.branch.has_revision(parent_id):
276
 
                warning("can't commit a merge from an absent parent")
277
 
                raise HistoryMissing(self.branch, 'revision', parent_id)
278
 
 
 
332
                if parent_id == self.branch.last_revision():
 
333
                    warning("parent is missing %r", parent_id)
 
334
                    raise HistoryMissing(self.branch, 'revision', parent_id)
 
335
                else:
 
336
                    mutter("commit will ghost revision %r", parent_id)
279
337
            
280
338
    def _make_revision(self):
281
339
        """Record a new revision object for this commit."""
284
342
                            committer=self.committer,
285
343
                            message=self.message,
286
344
                            inventory_sha1=self.inv_sha1,
287
 
                            revision_id=self.rev_id)
288
 
        self.rev.parents = map(RevisionReference, self.parents)
 
345
                            revision_id=self.rev_id,
 
346
                            properties=self.revprops)
 
347
        self.rev.parent_ids = self.parents
289
348
        rev_tmp = StringIO()
290
349
        serializer_v5.write_revision(self.rev, rev_tmp)
291
350
        rev_tmp.seek(0)
 
351
        if self.config.signature_needed():
 
352
            plaintext = Testament(self.rev, self.new_inv).as_short_text()
 
353
            self.branch.store_revision_signature(gpg.GPGStrategy(self.config),
 
354
                                                 plaintext, self.rev_id)
292
355
        self.branch.revision_store.add(rev_tmp, self.rev_id)
293
356
        mutter('new revision_id is {%s}', self.rev_id)
294
357
 
295
 
 
296
358
    def _remove_deleted(self):
297
359
        """Remove deleted files from the working inventories.
298
360
 
310
372
            if specific and not is_inside_any(specific, path):
311
373
                continue
312
374
            if not self.work_tree.has_filename(path):
313
 
                note('missing %s', path)
314
 
                deleted_ids.append(ie.file_id)
 
375
                self.reporter.missing(path)
 
376
                deleted_ids.append((path, ie.file_id))
315
377
        if deleted_ids:
316
 
            for file_id in deleted_ids:
 
378
            deleted_ids.sort(reverse=True)
 
379
            for path, file_id in deleted_ids:
317
380
                del self.work_inv[file_id]
318
381
            self.branch._write_inventory(self.work_inv)
319
382
 
320
 
 
321
 
    def _find_file_parents(self, file_id):
322
 
        """Return the text versions and hashes for all file parents.
323
 
 
324
 
        Returned as a map from text version to inventory entry.
325
 
 
326
 
        This is a set containing the file versions in all parents
327
 
        revisions containing the file.  If the file is new, the set
328
 
        will be empty."""
329
 
        r = {}
330
 
        for tree in self.parent_trees:
331
 
            if file_id in tree.inventory:
332
 
                ie = tree.inventory[file_id]
333
 
                assert ie.kind == 'file'
334
 
                assert ie.file_id == file_id
335
 
                if ie.text_version in r:
336
 
                    assert r[ie.text_version] == ie
337
 
                else:
338
 
                    r[ie.text_version] = ie
339
 
        return r            
340
 
 
341
 
 
342
 
    def _store_entries(self):
343
 
        """Build revision inventory and store modified files.
344
 
 
345
 
        This is called with new_inv a new empty inventory.  Depending on
346
 
        which files are selected for commit, and which ones have
347
 
        been modified or merged, new inventory entries are built
348
 
        based on the working and parent inventories.
349
 
 
350
 
        As a side-effect this stores new text versions for committed
351
 
        files with text changes or merges.
352
 
 
353
 
        Each entry can have one of several things happen:
354
 
 
355
 
        carry_file -- carried from the previous version (if not
356
 
            selected for commit)
357
 
 
358
 
        commit_nonfile -- no text to worry about
359
 
 
360
 
        commit_old_text -- same text, may have moved
361
 
 
362
 
        commit_file -- new text version
363
 
        """
 
383
    def _store_snapshot(self):
 
384
        """Pass over inventory and record a snapshot.
 
385
 
 
386
        Entries get a new revision when they are modified in 
 
387
        any way, which includes a merge with a new set of
 
388
        parents that have the same entry. 
 
389
        """
 
390
        # XXX: Need to think more here about when the user has
 
391
        # made a specific decision on a particular value -- c.f.
 
392
        # mark-merge.  
 
393
        for path, ie in self.new_inv.iter_entries():
 
394
            previous_entries = ie.find_previous_heads(
 
395
                self.parent_invs, 
 
396
                self.weave_store.get_weave_or_empty(ie.file_id,
 
397
                    self.branch.get_transaction()))
 
398
            if ie.revision is None:
 
399
                change = ie.snapshot(self.rev_id, path, previous_entries,
 
400
                                     self.work_tree, self.weave_store,
 
401
                                     self.branch.get_transaction())
 
402
            else:
 
403
                change = "unchanged"
 
404
            self.reporter.snapshot_change(change, path)
 
405
 
 
406
    def _populate_new_inv(self):
 
407
        """Build revision inventory.
 
408
 
 
409
        This creates a new empty inventory. Depending on
 
410
        which files are selected for commit, and what is present in the
 
411
        current tree, the new inventory is populated. inventory entries 
 
412
        which are candidates for modification have their revision set to
 
413
        None; inventory entries that are carried over untouched have their
 
414
        revision set to their prior value.
 
415
        """
 
416
        mutter("Selecting files for commit with filter %s", self.specific_files)
 
417
        self.new_inv = Inventory()
364
418
        for path, new_ie in self.work_inv.iter_entries():
365
419
            file_id = new_ie.file_id
366
420
            mutter('check %s {%s}', path, new_ie.file_id)
367
421
            if self.specific_files:
368
422
                if not is_inside_any(self.specific_files, path):
369
423
                    mutter('%s not selected for commit', path)
370
 
                    self._carry_file(file_id)
371
 
                    continue
372
 
            if new_ie.kind != 'file':
373
 
                self._commit_nonfile(file_id)
374
 
                continue
375
 
            
376
 
            file_parents = self._find_file_parents(file_id)
377
 
            if len(file_parents) == 1:
378
 
                parent_ie = file_parents.values()[0]
379
 
                wc_sha1 = self.work_tree.get_file_sha1(file_id)
380
 
                if parent_ie.text_sha1 == wc_sha1:
381
 
                    # text not changed or merged
382
 
                    self._commit_old_text(file_id, parent_ie)
383
 
                    continue
384
 
 
385
 
            mutter('parents of %s are %r', path, file_parents)
386
 
 
387
 
            # file is either new, or a file merge; need to record
388
 
            # a new version
389
 
            if len(file_parents) > 1:
390
 
                note('merged %s', path)
391
 
            elif len(file_parents) == 0:
392
 
                note('added %s', path)
393
 
            else:
394
 
                note('modified %s', path)
395
 
            self._commit_file(new_ie, file_id, file_parents)
396
 
 
397
 
 
398
 
    def _commit_nonfile(self, file_id):
399
 
        self.new_inv.add(self.work_inv[file_id].copy())
400
 
 
401
 
 
402
 
    def _carry_file(self, file_id):
 
424
                    self._carry_entry(file_id)
 
425
                    continue
 
426
                else:
 
427
                    # this is selected, ensure its parents are too.
 
428
                    parent_id = new_ie.parent_id
 
429
                    while parent_id != ROOT_ID:
 
430
                        if not self.new_inv.has_id(parent_id):
 
431
                            ie = self._select_entry(self.work_inv[parent_id])
 
432
                            mutter('%s selected for commit because of %s',
 
433
                                   self.new_inv.id2path(parent_id), path)
 
434
 
 
435
                        ie = self.new_inv[parent_id]
 
436
                        if ie.revision is not None:
 
437
                            ie.revision = None
 
438
                            mutter('%s selected for commit because of %s',
 
439
                                   self.new_inv.id2path(parent_id), path)
 
440
                        parent_id = ie.parent_id
 
441
            mutter('%s selected for commit', path)
 
442
            self._select_entry(new_ie)
 
443
 
 
444
    def _select_entry(self, new_ie):
 
445
        """Make new_ie be considered for committing."""
 
446
        ie = new_ie.copy()
 
447
        ie.revision = None
 
448
        self.new_inv.add(ie)
 
449
        return ie
 
450
 
 
451
    def _carry_entry(self, file_id):
403
452
        """Carry the file unchanged from the basis revision."""
404
453
        if self.basis_inv.has_id(file_id):
405
454
            self.new_inv.add(self.basis_inv[file_id].copy())
406
455
 
407
 
 
408
 
    def _commit_old_text(self, file_id, parent_ie):
409
 
        """Keep the same text as last time, but possibly a different name."""
410
 
        ie = self.work_inv[file_id].copy()
411
 
        ie.text_version = parent_ie.text_version
412
 
        ie.text_size = parent_ie.text_size
413
 
        ie.text_sha1 = parent_ie.text_sha1
414
 
        self.new_inv.add(ie)
415
 
 
416
 
 
417
456
    def _report_deletes(self):
418
457
        for file_id in self.basis_inv:
419
458
            if file_id not in self.new_inv:
420
 
                note('deleted %s', self.basis_inv.id2path(file_id))
421
 
 
422
 
 
423
 
    def _commit_file(self, new_ie, file_id, file_parents):                    
424
 
        mutter('store new text for {%s} in revision {%s}',
425
 
               file_id, self.rev_id)
426
 
        new_lines = self.work_tree.get_file(file_id).readlines()
427
 
        self._add_text_to_weave(file_id, new_lines, file_parents)
428
 
        new_ie.text_version = self.rev_id
429
 
        new_ie.text_sha1 = sha_strings(new_lines)
430
 
        new_ie.text_size = sum(map(len, new_lines))
431
 
        self.new_inv.add(new_ie)
432
 
 
433
 
 
434
 
    def _add_text_to_weave(self, file_id, new_lines, parents):
435
 
        if file_id.startswith('__'):
436
 
            raise ValueError('illegal file-id %r for text file' % file_id)
437
 
        self.weave_store.add_text(file_id, self.rev_id, new_lines, parents)
438
 
 
439
 
 
440
 
def _gen_revision_id(branch, when):
 
459
                self.reporter.deleted(self.basis_inv.id2path(file_id))
 
460
 
 
461
def _gen_revision_id(config, when):
441
462
    """Return new revision-id."""
442
 
    s = '%s-%s-' % (user_email(branch), compact_date(when))
 
463
    s = '%s-%s-' % (config.user_email(), compact_date(when))
443
464
    s += hexlify(rand_bytes(8))
444
465
    return s
445
 
 
446
 
 
447
 
 
448