/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Robert Collins
  • Date: 2005-10-15 11:38:29 UTC
  • mfrom: (1185.16.40)
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051015113829-40226233fb246920
mergeĀ fromĀ martin

Show diffs side-by-side

added added

removed removed

Lines of Context:
56
56
# merges from, then it should still be reported as newly added
57
57
# relative to the basis revision.
58
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.
64
 
 
65
59
 
66
60
import os
67
61
import re
72
66
from binascii import hexlify
73
67
from cStringIO import StringIO
74
68
 
75
 
from bzrlib.atomicfile import AtomicFile
76
69
from bzrlib.osutils import (local_time_offset,
77
70
                            rand_bytes, compact_date,
78
71
                            kind_marker, is_inside_any, quotefn,
79
 
                            sha_file, isdir, isfile,
 
72
                            sha_string, sha_strings, sha_file, isdir, isfile,
80
73
                            split_lines)
 
74
from bzrlib.branch import gen_file_id
81
75
import bzrlib.config
82
 
import bzrlib.errors as errors
83
76
from bzrlib.errors import (BzrError, PointlessCommit,
84
77
                           HistoryMissing,
85
 
                           ConflictsInTree,
86
 
                           StrictCommitFailed
 
78
                           ConflictsInTree
87
79
                           )
88
80
from bzrlib.revision import Revision
89
 
from bzrlib.testament import Testament
90
81
from bzrlib.trace import mutter, note, warning
91
82
from bzrlib.xml5 import serializer_v5
92
83
from bzrlib.inventory import Inventory, ROOT_ID
93
 
from bzrlib.symbol_versioning import *
94
 
from bzrlib.workingtree import WorkingTree
95
 
 
96
 
 
97
 
@deprecated_function(zero_seven)
 
84
from bzrlib.weave import Weave
 
85
from bzrlib.weavefile import read_weave, write_weave_v5
 
86
from bzrlib.atomicfile import AtomicFile
 
87
 
 
88
 
98
89
def commit(*args, **kwargs):
99
90
    """Commit a new revision to a branch.
100
91
 
124
115
    def missing(self, path):
125
116
        pass
126
117
 
127
 
 
128
118
class ReportCommitToLog(NullCommitReporter):
129
119
 
130
120
    def snapshot_change(self, change, path):
131
 
        if change == 'unchanged':
132
 
            return
133
121
        note("%s %s", change, path)
134
122
 
135
123
    def completed(self, revno, rev_id):
136
 
        note('Committed revision %d.', revno)
 
124
        note('committed r%d {%s}', revno, rev_id)
137
125
    
138
126
    def deleted(self, file_id):
139
127
        note('deleted %s', file_id)
144
132
    def missing(self, path):
145
133
        note('missing %s', path)
146
134
 
147
 
 
148
135
class Commit(object):
149
136
    """Task of committing a new revision.
150
137
 
158
145
            working inventory.
159
146
    """
160
147
    def __init__(self,
161
 
                 reporter=None,
162
 
                 config=None):
 
148
                 reporter=None):
163
149
        if reporter is not None:
164
150
            self.reporter = reporter
165
151
        else:
166
152
            self.reporter = NullCommitReporter()
167
 
        if config is not None:
168
 
            self.config = config
169
 
        else:
170
 
            self.config = None
 
153
 
171
154
        
172
155
    def commit(self,
173
 
               branch=DEPRECATED_PARAMETER, message=None,
 
156
               branch, message,
174
157
               timestamp=None,
175
158
               timezone=None,
176
159
               committer=None,
177
160
               specific_files=None,
178
161
               rev_id=None,
179
162
               allow_pointless=True,
180
 
               strict=False,
181
163
               verbose=False,
182
 
               revprops=None,
183
 
               working_tree=None,
184
 
               local=False,
185
 
               reporter=None,
186
 
               config=None):
 
164
               revprops=None):
187
165
        """Commit working copy as a new revision.
188
166
 
189
 
        branch -- the deprecated branch to commit to. New callers should pass in 
190
 
                  working_tree instead
191
 
 
192
 
        message -- the commit message, a mandatory parameter
193
 
 
194
167
        timestamp -- if not None, seconds-since-epoch for a
195
168
             postdated/predated commit.
196
169
 
205
178
        allow_pointless -- If true (default), commit even if nothing
206
179
            has changed and no merges are recorded.
207
180
 
208
 
        strict -- If true, don't allow a commit if the working tree
209
 
            contains unknown files.
210
 
 
211
181
        revprops -- Properties for new revision
212
 
        :param local: Perform a local only commit.
213
182
        """
214
183
        mutter('preparing to commit')
215
184
 
216
 
        if deprecated_passed(branch):
217
 
            warn("Commit.commit (branch, ...): The branch parameter is "
218
 
                 "deprecated as of bzr 0.8. Please use working_tree= instead.",
219
 
                 DeprecationWarning, stacklevel=2)
220
 
            self.branch = branch
221
 
            self.work_tree = self.branch.bzrdir.open_workingtree()
222
 
        elif working_tree is None:
223
 
            raise BzrError("One of branch and working_tree must be passed into commit().")
224
 
        else:
225
 
            self.work_tree = working_tree
226
 
            self.branch = self.work_tree.branch
227
 
        if message is None:
228
 
            raise BzrError("The message keyword parameter is required for commit().")
229
 
 
230
 
        self.weave_store = self.branch.repository.weave_store
231
 
        self.bound_branch = None
232
 
        self.local = local
233
 
        self.master_branch = None
234
 
        self.master_locked = False
 
185
        self.branch = branch
 
186
        self.weave_store = branch.weave_store
235
187
        self.rev_id = rev_id
236
188
        self.specific_files = specific_files
237
189
        self.allow_pointless = allow_pointless
238
 
        self.revprops = {}
239
 
        if revprops is not None:
240
 
            self.revprops.update(revprops)
241
 
 
242
 
        if reporter is None and self.reporter is None:
243
 
            self.reporter = NullCommitReporter()
244
 
        elif reporter is not None:
245
 
            self.reporter = reporter
246
 
 
247
 
        self.work_tree.lock_write()
 
190
        self.revprops = revprops
 
191
 
 
192
        if timestamp is None:
 
193
            self.timestamp = time.time()
 
194
        else:
 
195
            self.timestamp = long(timestamp)
 
196
            
 
197
        config = bzrlib.config.BranchConfig(self.branch)
 
198
        if rev_id is None:
 
199
            self.rev_id = _gen_revision_id(config, self.timestamp)
 
200
        else:
 
201
            self.rev_id = rev_id
 
202
 
 
203
        if committer is None:
 
204
            self.committer = config.username()
 
205
        else:
 
206
            assert isinstance(committer, basestring), type(committer)
 
207
            self.committer = committer
 
208
 
 
209
        if timezone is None:
 
210
            self.timezone = local_time_offset()
 
211
        else:
 
212
            self.timezone = int(timezone)
 
213
 
 
214
        assert isinstance(message, basestring), type(message)
 
215
        self.message = message
 
216
        self._escape_commit_message()
 
217
 
 
218
        self.branch.lock_write()
248
219
        try:
249
 
            # setup the bound branch variables as needed.
250
 
            self._check_bound_branch()
251
 
 
252
 
            # check for out of date working trees
253
 
            # if we are bound, then self.branch is the master branch and this
254
 
            # test is thus all we need.
255
 
            if self.work_tree.last_revision() != self.master_branch.last_revision():
256
 
                raise errors.OutOfDateTree(self.work_tree)
257
 
    
258
 
            if strict:
259
 
                # raise an exception as soon as we find a single unknown.
260
 
                for unknown in self.work_tree.unknowns():
261
 
                    raise StrictCommitFailed()
262
 
    
263
 
            if timestamp is None:
264
 
                self.timestamp = time.time()
265
 
            else:
266
 
                self.timestamp = long(timestamp)
267
 
                
268
 
            if self.config is None:
269
 
                self.config = bzrlib.config.BranchConfig(self.branch)
270
 
    
271
 
            if rev_id is None:
272
 
                self.rev_id = _gen_revision_id(self.config, self.timestamp)
273
 
            else:
274
 
                self.rev_id = rev_id
275
 
    
276
 
            if committer is None:
277
 
                self.committer = self.config.username()
278
 
            else:
279
 
                assert isinstance(committer, basestring), type(committer)
280
 
                self.committer = committer
281
 
    
282
 
            if timezone is None:
283
 
                self.timezone = local_time_offset()
284
 
            else:
285
 
                self.timezone = int(timezone)
286
 
    
287
 
            if isinstance(message, str):
288
 
                message = message.decode(bzrlib.user_encoding)
289
 
            assert isinstance(message, unicode), type(message)
290
 
            self.message = message
291
 
            self._escape_commit_message()
292
 
 
 
220
            self.work_tree = self.branch.working_tree()
293
221
            self.work_inv = self.work_tree.inventory
294
 
            self.basis_tree = self.work_tree.basis_tree()
 
222
            self.basis_tree = self.branch.basis_tree()
295
223
            self.basis_inv = self.basis_tree.inventory
296
224
 
297
225
            self._gather_parents()
309
237
                    or self.new_inv != self.basis_inv):
310
238
                raise PointlessCommit()
311
239
 
312
 
            if len(self.work_tree.conflicts())>0:
 
240
            if len(list(self.work_tree.iter_conflicts()))>0:
313
241
                raise ConflictsInTree
314
242
 
315
 
            self.inv_sha1 = self.branch.repository.add_inventory(
316
 
                self.rev_id,
317
 
                self.new_inv,
318
 
                self.present_parents
319
 
                )
 
243
            self._record_inventory()
320
244
            self._make_revision()
321
 
            # revision data is in the local branch now.
322
 
            
323
 
            # upload revision data to the master.
324
 
            # this will propogate merged revisions too if needed.
325
 
            if self.bound_branch:
326
 
                self.master_branch.repository.fetch(self.branch.repository,
327
 
                                                    revision_id=self.rev_id)
328
 
                # now the master has the revision data
329
 
                # 'commit' to the master first so a timeout here causes the local
330
 
                # branch to be out of date
331
 
                self.master_branch.append_revision(self.rev_id)
332
 
 
333
 
            # and now do the commit locally.
 
245
            self.reporter.completed(self.branch.revno()+1, self.rev_id)
334
246
            self.branch.append_revision(self.rev_id)
335
 
 
336
 
            self.work_tree.set_pending_merges([])
337
 
            self.work_tree.set_last_revision(self.rev_id)
338
 
            # now the work tree is up to date with the branch
339
 
            
340
 
            self.reporter.completed(self.branch.revno(), self.rev_id)
341
 
            if self.config.post_commit() is not None:
342
 
                hooks = self.config.post_commit().split(' ')
343
 
                # this would be nicer with twisted.python.reflect.namedAny
344
 
                for hook in hooks:
345
 
                    result = eval(hook + '(branch, rev_id)',
346
 
                                  {'branch':self.branch,
347
 
                                   'bzrlib':bzrlib,
348
 
                                   'rev_id':self.rev_id})
 
247
            self.branch.set_pending_merges([])
349
248
        finally:
350
 
            self._cleanup_bound_branch()
351
 
            self.work_tree.unlock()
352
 
 
353
 
    def _check_bound_branch(self):
354
 
        """Check to see if the local branch is bound.
355
 
 
356
 
        If it is bound, then most of the commit will actually be
357
 
        done using the remote branch as the target branch.
358
 
        Only at the end will the local branch be updated.
359
 
        """
360
 
        if self.local and not self.branch.get_bound_location():
361
 
            raise errors.LocalRequiresBoundBranch()
362
 
 
363
 
        if not self.local:
364
 
            self.master_branch = self.branch.get_master_branch()
365
 
 
366
 
        if not self.master_branch:
367
 
            # make this branch the reference branch for out of date checks.
368
 
            self.master_branch = self.branch
369
 
            return
370
 
 
371
 
        # If the master branch is bound, we must fail
372
 
        master_bound_location = self.master_branch.get_bound_location()
373
 
        if master_bound_location:
374
 
            raise errors.CommitToDoubleBoundBranch(self.branch,
375
 
                    self.master_branch, master_bound_location)
376
 
 
377
 
        # TODO: jam 20051230 We could automatically push local
378
 
        #       commits to the remote branch if they would fit.
379
 
        #       But for now, just require remote to be identical
380
 
        #       to local.
381
 
        
382
 
        # Make sure the local branch is identical to the master
383
 
        master_rh = self.master_branch.revision_history()
384
 
        local_rh = self.branch.revision_history()
385
 
        if local_rh != master_rh:
386
 
            raise errors.BoundBranchOutOfDate(self.branch,
387
 
                    self.master_branch)
388
 
 
389
 
        # Now things are ready to change the master branch
390
 
        # so grab the lock
391
 
        self.bound_branch = self.branch
392
 
        self.master_branch.lock_write()
393
 
        self.master_locked = True
394
 
####        
395
 
####        # Check to see if we have any pending merges. If we do
396
 
####        # those need to be pushed into the master branch
397
 
####        pending_merges = self.work_tree.pending_merges()
398
 
####        if pending_merges:
399
 
####            for revision_id in pending_merges:
400
 
####                self.master_branch.repository.fetch(self.bound_branch.repository,
401
 
####                                                    revision_id=revision_id)
402
 
 
403
 
    def _cleanup_bound_branch(self):
404
 
        """Executed at the end of a try/finally to cleanup a bound branch.
405
 
 
406
 
        If the branch wasn't bound, this is a no-op.
407
 
        If it was, it resents self.branch to the local branch, instead
408
 
        of being the master.
409
 
        """
410
 
        if not self.bound_branch:
411
 
            return
412
 
        if self.master_locked:
413
 
            self.master_branch.unlock()
 
249
            self.branch.unlock()
 
250
 
 
251
    def _record_inventory(self):
 
252
        """Store the inventory for the new revision."""
 
253
        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)
 
254
        self.inv_sha1 = sha_string(inv_text)
 
255
        s = self.branch.control_weaves
 
256
        s.add_text('inventory', self.rev_id,
 
257
                   split_lines(inv_text), self.present_parents,
 
258
                   self.branch.get_transaction())
414
259
 
415
260
    def _escape_commit_message(self):
416
261
        """Replace xml-incompatible control characters."""
418
263
        # represented in well-formed XML; escape characters that
419
264
        # aren't listed in the XML specification
420
265
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
266
        if isinstance(self.message, unicode):
 
267
            char_pattern = u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]'
 
268
        else:
 
269
            # Use a regular 'str' as pattern to avoid having re.subn
 
270
            # return 'unicode' results.
 
271
            char_pattern = '[^x09\x0A\x0D\x20-\xFF]'
421
272
        self.message, escape_count = re.subn(
422
 
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
273
            char_pattern,
423
274
            lambda match: match.group(0).encode('unicode_escape'),
424
275
            self.message)
425
276
        if escape_count:
427
278
 
428
279
    def _gather_parents(self):
429
280
        """Record the parents of a merge for merge detection."""
430
 
        pending_merges = self.work_tree.pending_merges()
 
281
        pending_merges = self.branch.pending_merges()
431
282
        self.parents = []
432
283
        self.parent_invs = []
433
284
        self.present_parents = []
436
287
            self.parents.append(precursor_id)
437
288
        self.parents += pending_merges
438
289
        for revision in self.parents:
439
 
            if self.branch.repository.has_revision(revision):
440
 
                inventory = self.branch.repository.get_inventory(revision)
441
 
                self.parent_invs.append(inventory)
 
290
            if self.branch.has_revision(revision):
 
291
                self.parent_invs.append(self.branch.get_inventory(revision))
442
292
                self.present_parents.append(revision)
443
293
 
444
294
    def _check_parents_present(self):
445
295
        for parent_id in self.parents:
446
296
            mutter('commit parent revision {%s}', parent_id)
447
 
            if not self.branch.repository.has_revision(parent_id):
 
297
            if not self.branch.has_revision(parent_id):
448
298
                if parent_id == self.branch.last_revision():
449
299
                    warning("parent is missing %r", parent_id)
450
300
                    raise HistoryMissing(self.branch, 'revision', parent_id)
453
303
            
454
304
    def _make_revision(self):
455
305
        """Record a new revision object for this commit."""
456
 
        rev = Revision(timestamp=self.timestamp,
457
 
                       timezone=self.timezone,
458
 
                       committer=self.committer,
459
 
                       message=self.message,
460
 
                       inventory_sha1=self.inv_sha1,
461
 
                       revision_id=self.rev_id,
462
 
                       properties=self.revprops)
463
 
        rev.parent_ids = self.parents
464
 
        self.branch.repository.add_revision(self.rev_id, rev, self.new_inv, self.config)
 
306
        self.rev = Revision(timestamp=self.timestamp,
 
307
                            timezone=self.timezone,
 
308
                            committer=self.committer,
 
309
                            message=self.message,
 
310
                            inventory_sha1=self.inv_sha1,
 
311
                            revision_id=self.rev_id,
 
312
                            properties=self.revprops)
 
313
        self.rev.parent_ids = self.parents
 
314
        rev_tmp = StringIO()
 
315
        serializer_v5.write_revision(self.rev, rev_tmp)
 
316
        rev_tmp.seek(0)
 
317
        self.branch.revision_store.add(rev_tmp, self.rev_id)
 
318
        mutter('new revision_id is {%s}', self.rev_id)
465
319
 
466
320
    def _remove_deleted(self):
467
321
        """Remove deleted files from the working inventories.
486
340
            deleted_ids.sort(reverse=True)
487
341
            for path, file_id in deleted_ids:
488
342
                del self.work_inv[file_id]
489
 
            self.work_tree._write_inventory(self.work_inv)
 
343
            self.branch._write_inventory(self.work_inv)
490
344
 
491
345
    def _store_snapshot(self):
492
346
        """Pass over inventory and record a snapshot.
500
354
        # mark-merge.  
501
355
        for path, ie in self.new_inv.iter_entries():
502
356
            previous_entries = ie.find_previous_heads(
503
 
                self.parent_invs,
504
 
                self.weave_store,
505
 
                self.branch.repository.get_transaction())
 
357
                self.parent_invs, 
 
358
                self.weave_store.get_weave_or_empty(ie.file_id,
 
359
                    self.branch.get_transaction()))
506
360
            if ie.revision is None:
507
361
                change = ie.snapshot(self.rev_id, path, previous_entries,
508
362
                                     self.work_tree, self.weave_store,
522
376
        revision set to their prior value.
523
377
        """
524
378
        mutter("Selecting files for commit with filter %s", self.specific_files)
525
 
        self.new_inv = Inventory(revision_id=self.rev_id)
 
379
        self.new_inv = Inventory()
526
380
        for path, new_ie in self.work_inv.iter_entries():
527
381
            file_id = new_ie.file_id
528
382
            mutter('check %s {%s}', path, new_ie.file_id)