/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-11-04 23:27:47 UTC
  • Revision ID: robertc@robertcollins.net-20051104232747-5872c68d759bc7be
Bugfix the config test suite to not create .bazaar in the dir where it is run.

Show diffs side-by-side

added added

removed removed

Lines of Context:
72
72
from binascii import hexlify
73
73
from cStringIO import StringIO
74
74
 
75
 
from bzrlib.atomicfile import AtomicFile
76
75
from bzrlib.osutils import (local_time_offset,
77
76
                            rand_bytes, compact_date,
78
77
                            kind_marker, is_inside_any, quotefn,
79
 
                            sha_file, isdir, isfile,
 
78
                            sha_string, sha_strings, sha_file, isdir, isfile,
80
79
                            split_lines)
 
80
from bzrlib.branch import gen_file_id
81
81
import bzrlib.config
82
 
import bzrlib.errors as errors
83
82
from bzrlib.errors import (BzrError, PointlessCommit,
84
83
                           HistoryMissing,
85
84
                           ConflictsInTree,
86
85
                           StrictCommitFailed
87
86
                           )
 
87
import bzrlib.gpg as gpg
88
88
from bzrlib.revision import Revision
89
89
from bzrlib.testament import Testament
90
90
from bzrlib.trace import mutter, note, warning
91
91
from bzrlib.xml5 import serializer_v5
92
92
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)
 
93
from bzrlib.weave import Weave
 
94
from bzrlib.weavefile import read_weave, write_weave_v5
 
95
from bzrlib.atomicfile import AtomicFile
 
96
 
 
97
 
98
98
def commit(*args, **kwargs):
99
99
    """Commit a new revision to a branch.
100
100
 
124
124
    def missing(self, path):
125
125
        pass
126
126
 
127
 
 
128
127
class ReportCommitToLog(NullCommitReporter):
129
128
 
130
129
    def snapshot_change(self, change, path):
131
 
        if change == 'unchanged':
132
 
            return
133
130
        note("%s %s", change, path)
134
131
 
135
132
    def completed(self, revno, rev_id):
136
 
        note('Committed revision %d.', revno)
 
133
        note('committed r%d {%s}', revno, rev_id)
137
134
    
138
135
    def deleted(self, file_id):
139
136
        note('deleted %s', file_id)
144
141
    def missing(self, path):
145
142
        note('missing %s', path)
146
143
 
147
 
 
148
144
class Commit(object):
149
145
    """Task of committing a new revision.
150
146
 
170
166
            self.config = None
171
167
        
172
168
    def commit(self,
173
 
               branch=DEPRECATED_PARAMETER, message=None,
 
169
               branch, message,
174
170
               timestamp=None,
175
171
               timezone=None,
176
172
               committer=None,
179
175
               allow_pointless=True,
180
176
               strict=False,
181
177
               verbose=False,
182
 
               revprops=None,
183
 
               working_tree=None,
184
 
               local=False,
185
 
               reporter=None,
186
 
               config=None):
 
178
               revprops=None):
187
179
        """Commit working copy as a new revision.
188
180
 
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
181
        timestamp -- if not None, seconds-since-epoch for a
195
182
             postdated/predated commit.
196
183
 
209
196
            contains unknown files.
210
197
 
211
198
        revprops -- Properties for new revision
212
 
        :param local: Perform a local only commit.
213
199
        """
214
200
        mutter('preparing to commit')
215
201
 
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
 
202
        self.branch = branch
 
203
        self.weave_store = branch.weave_store
235
204
        self.rev_id = rev_id
236
205
        self.specific_files = specific_files
237
206
        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()
 
207
        self.revprops = revprops
 
208
 
 
209
        if strict:
 
210
            # raise an exception as soon as we find a single unknown.
 
211
            for unknown in branch.unknowns():
 
212
                raise StrictCommitFailed()
 
213
 
 
214
        if timestamp is None:
 
215
            self.timestamp = time.time()
 
216
        else:
 
217
            self.timestamp = long(timestamp)
 
218
            
 
219
        if self.config is None:
 
220
            self.config = bzrlib.config.BranchConfig(self.branch)
 
221
 
 
222
        if rev_id is None:
 
223
            self.rev_id = _gen_revision_id(self.config, self.timestamp)
 
224
        else:
 
225
            self.rev_id = rev_id
 
226
 
 
227
        if committer is None:
 
228
            self.committer = self.config.username()
 
229
        else:
 
230
            assert isinstance(committer, basestring), type(committer)
 
231
            self.committer = committer
 
232
 
 
233
        if timezone is None:
 
234
            self.timezone = local_time_offset()
 
235
        else:
 
236
            self.timezone = int(timezone)
 
237
 
 
238
        assert isinstance(message, basestring), type(message)
 
239
        self.message = message
 
240
        self._escape_commit_message()
 
241
 
 
242
        self.branch.lock_write()
248
243
        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
 
 
 
244
            self.work_tree = self.branch.working_tree()
293
245
            self.work_inv = self.work_tree.inventory
294
 
            self.basis_tree = self.work_tree.basis_tree()
 
246
            self.basis_tree = self.branch.basis_tree()
295
247
            self.basis_inv = self.basis_tree.inventory
296
248
 
297
249
            self._gather_parents()
309
261
                    or self.new_inv != self.basis_inv):
310
262
                raise PointlessCommit()
311
263
 
312
 
            if len(self.work_tree.conflicts())>0:
 
264
            if len(list(self.work_tree.iter_conflicts()))>0:
313
265
                raise ConflictsInTree
314
266
 
315
 
            self.inv_sha1 = self.branch.repository.add_inventory(
316
 
                self.rev_id,
317
 
                self.new_inv,
318
 
                self.present_parents
319
 
                )
 
267
            self._record_inventory()
320
268
            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.
334
269
            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)
 
270
            self.branch.set_pending_merges([])
 
271
            self.reporter.completed(self.branch.revno()+1, self.rev_id)
341
272
            if self.config.post_commit() is not None:
342
273
                hooks = self.config.post_commit().split(' ')
343
274
                # this would be nicer with twisted.python.reflect.namedAny
347
278
                                   'bzrlib':bzrlib,
348
279
                                   'rev_id':self.rev_id})
349
280
        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()
 
281
            self.branch.unlock()
 
282
 
 
283
    def _record_inventory(self):
 
284
        """Store the inventory for the new revision."""
 
285
        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)
 
286
        self.inv_sha1 = sha_string(inv_text)
 
287
        s = self.branch.control_weaves
 
288
        s.add_text('inventory', self.rev_id,
 
289
                   split_lines(inv_text), self.present_parents,
 
290
                   self.branch.get_transaction())
414
291
 
415
292
    def _escape_commit_message(self):
416
293
        """Replace xml-incompatible control characters."""
418
295
        # represented in well-formed XML; escape characters that
419
296
        # aren't listed in the XML specification
420
297
        # (http://www.w3.org/TR/REC-xml/#NT-Char).
 
298
        if isinstance(self.message, unicode):
 
299
            char_pattern = u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]'
 
300
        else:
 
301
            # Use a regular 'str' as pattern to avoid having re.subn
 
302
            # return 'unicode' results.
 
303
            char_pattern = '[^x09\x0A\x0D\x20-\xFF]'
421
304
        self.message, escape_count = re.subn(
422
 
            u'[^\x09\x0A\x0D\u0020-\uD7FF\uE000-\uFFFD]+',
 
305
            char_pattern,
423
306
            lambda match: match.group(0).encode('unicode_escape'),
424
307
            self.message)
425
308
        if escape_count:
427
310
 
428
311
    def _gather_parents(self):
429
312
        """Record the parents of a merge for merge detection."""
430
 
        pending_merges = self.work_tree.pending_merges()
 
313
        pending_merges = self.branch.pending_merges()
431
314
        self.parents = []
432
315
        self.parent_invs = []
433
316
        self.present_parents = []
436
319
            self.parents.append(precursor_id)
437
320
        self.parents += pending_merges
438
321
        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)
 
322
            if self.branch.has_revision(revision):
 
323
                self.parent_invs.append(self.branch.get_inventory(revision))
442
324
                self.present_parents.append(revision)
443
325
 
444
326
    def _check_parents_present(self):
445
327
        for parent_id in self.parents:
446
328
            mutter('commit parent revision {%s}', parent_id)
447
 
            if not self.branch.repository.has_revision(parent_id):
 
329
            if not self.branch.has_revision(parent_id):
448
330
                if parent_id == self.branch.last_revision():
449
331
                    warning("parent is missing %r", parent_id)
450
332
                    raise HistoryMissing(self.branch, 'revision', parent_id)
453
335
            
454
336
    def _make_revision(self):
455
337
        """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)
 
338
        self.rev = Revision(timestamp=self.timestamp,
 
339
                            timezone=self.timezone,
 
340
                            committer=self.committer,
 
341
                            message=self.message,
 
342
                            inventory_sha1=self.inv_sha1,
 
343
                            revision_id=self.rev_id,
 
344
                            properties=self.revprops)
 
345
        self.rev.parent_ids = self.parents
 
346
        rev_tmp = StringIO()
 
347
        serializer_v5.write_revision(self.rev, rev_tmp)
 
348
        rev_tmp.seek(0)
 
349
        if self.config.signature_needed():
 
350
            plaintext = Testament(self.rev, self.new_inv).as_short_text()
 
351
            self.branch.store_revision_signature(gpg.GPGStrategy(self.config),
 
352
                                                 plaintext, self.rev_id)
 
353
        self.branch.revision_store.add(rev_tmp, self.rev_id)
 
354
        mutter('new revision_id is {%s}', self.rev_id)
465
355
 
466
356
    def _remove_deleted(self):
467
357
        """Remove deleted files from the working inventories.
486
376
            deleted_ids.sort(reverse=True)
487
377
            for path, file_id in deleted_ids:
488
378
                del self.work_inv[file_id]
489
 
            self.work_tree._write_inventory(self.work_inv)
 
379
            self.branch._write_inventory(self.work_inv)
490
380
 
491
381
    def _store_snapshot(self):
492
382
        """Pass over inventory and record a snapshot.
500
390
        # mark-merge.  
501
391
        for path, ie in self.new_inv.iter_entries():
502
392
            previous_entries = ie.find_previous_heads(
503
 
                self.parent_invs,
504
 
                self.weave_store,
505
 
                self.branch.repository.get_transaction())
 
393
                self.parent_invs, 
 
394
                self.weave_store.get_weave_or_empty(ie.file_id,
 
395
                    self.branch.get_transaction()))
506
396
            if ie.revision is None:
507
397
                change = ie.snapshot(self.rev_id, path, previous_entries,
508
398
                                     self.work_tree, self.weave_store,
522
412
        revision set to their prior value.
523
413
        """
524
414
        mutter("Selecting files for commit with filter %s", self.specific_files)
525
 
        self.new_inv = Inventory(revision_id=self.rev_id)
 
415
        self.new_inv = Inventory()
526
416
        for path, new_ie in self.work_inv.iter_entries():
527
417
            file_id = new_ie.file_id
528
418
            mutter('check %s {%s}', path, new_ie.file_id)