← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Olaf Conradi
  • Date: 2006-03-28 23:30:02 UTC
  • mto: (1661.1.1 bzr.mbp.remember)
  • mto: This revision was merged to the branch mainline in revision 1663.
  • Revision ID: olaf@conradi.org-20060328233002-f6262df0e19c1963
Added testcases for using pull with --remember. Moved remember code to
beginning of cmd_pull. This remembers the location in case of a failure
during pull.

Show diffs side-by-side

added added

removed removed

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