~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/commit.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-03-06 00:49:26 UTC
  • mfrom: (1587.1.14 bound-branches)
  • Revision ID: pqm@pqm.ubuntu.com-20060306004926-6d7a10c990bc17d1
Merge in bound branches core support.

Show diffs side-by-side

added added

removed removed

Lines of Context:
180
180
               strict=False,
181
181
               verbose=False,
182
182
               revprops=None,
183
 
               working_tree=None):
 
183
               working_tree=None,
 
184
               local=False):
184
185
        """Commit working copy as a new revision.
185
186
 
186
187
        branch -- the deprecated branch to commit to. New callers should pass in 
206
207
            contains unknown files.
207
208
 
208
209
        revprops -- Properties for new revision
 
210
        :param local: Perform a local only commit.
209
211
        """
210
212
        mutter('preparing to commit')
211
213
 
224
226
            raise BzrError("The message keyword parameter is required for commit().")
225
227
 
226
228
        self.weave_store = self.branch.repository.weave_store
 
229
        self.bound_branch = None
 
230
        self.local = local
 
231
        self.master_branch = None
227
232
        self.rev_id = rev_id
228
233
        self.specific_files = specific_files
229
234
        self.allow_pointless = allow_pointless
231
236
        if revprops:
232
237
            self.revprops.update(revprops)
233
238
 
234
 
        # check for out of date working trees
235
 
        if self.work_tree.last_revision() != self.branch.last_revision():
236
 
            raise errors.OutOfDateTree(self.work_tree)
237
 
 
238
 
        if strict:
239
 
            # raise an exception as soon as we find a single unknown.
240
 
            for unknown in self.work_tree.unknowns():
241
 
                raise StrictCommitFailed()
242
 
 
243
 
        if timestamp is None:
244
 
            self.timestamp = time.time()
245
 
        else:
246
 
            self.timestamp = long(timestamp)
247
 
            
248
 
        if self.config is None:
249
 
            self.config = bzrlib.config.BranchConfig(self.branch)
250
 
 
251
 
        if rev_id is None:
252
 
            self.rev_id = _gen_revision_id(self.config, self.timestamp)
253
 
        else:
254
 
            self.rev_id = rev_id
255
 
 
256
 
        if committer is None:
257
 
            self.committer = self.config.username()
258
 
        else:
259
 
            assert isinstance(committer, basestring), type(committer)
260
 
            self.committer = committer
261
 
 
262
 
        if timezone is None:
263
 
            self.timezone = local_time_offset()
264
 
        else:
265
 
            self.timezone = int(timezone)
266
 
 
267
 
        if isinstance(message, str):
268
 
            message = message.decode(bzrlib.user_encoding)
269
 
        assert isinstance(message, unicode), type(message)
270
 
        self.message = message
271
 
        self._escape_commit_message()
272
 
 
273
 
        self.branch.lock_write()
 
239
        self.work_tree.lock_write()
274
240
        try:
 
241
            # setup the bound branch variables as needed.
 
242
            self._check_bound_branch()
 
243
 
 
244
            # check for out of date working trees
 
245
            # if we are bound, then self.branch is the master branch and this
 
246
            # test is thus all we need.
 
247
            if self.work_tree.last_revision() != self.master_branch.last_revision():
 
248
                raise errors.OutOfDateTree(self.work_tree)
 
249
    
 
250
            if strict:
 
251
                # raise an exception as soon as we find a single unknown.
 
252
                for unknown in self.work_tree.unknowns():
 
253
                    raise StrictCommitFailed()
 
254
    
 
255
            if timestamp is None:
 
256
                self.timestamp = time.time()
 
257
            else:
 
258
                self.timestamp = long(timestamp)
 
259
                
 
260
            if self.config is None:
 
261
                self.config = bzrlib.config.BranchConfig(self.branch)
 
262
    
 
263
            if rev_id is None:
 
264
                self.rev_id = _gen_revision_id(self.config, self.timestamp)
 
265
            else:
 
266
                self.rev_id = rev_id
 
267
    
 
268
            if committer is None:
 
269
                self.committer = self.config.username()
 
270
            else:
 
271
                assert isinstance(committer, basestring), type(committer)
 
272
                self.committer = committer
 
273
    
 
274
            if timezone is None:
 
275
                self.timezone = local_time_offset()
 
276
            else:
 
277
                self.timezone = int(timezone)
 
278
    
 
279
            if isinstance(message, str):
 
280
                message = message.decode(bzrlib.user_encoding)
 
281
            assert isinstance(message, unicode), type(message)
 
282
            self.message = message
 
283
            self._escape_commit_message()
 
284
 
275
285
            self.work_inv = self.work_tree.inventory
276
286
            self.basis_tree = self.work_tree.basis_tree()
277
287
            self.basis_inv = self.basis_tree.inventory
300
310
                self.present_parents
301
311
                )
302
312
            self._make_revision()
 
313
            # revision data is in the local branch now.
 
314
            
 
315
            # upload revision data to the master.
 
316
            # this will propogate merged revisions too if needed.
 
317
            if self.bound_branch:
 
318
                self.master_branch.repository.fetch(self.branch.repository,
 
319
                                                    revision_id=self.rev_id)
 
320
                # now the master has the revision data
 
321
                # 'commit' to the master first so a timeout here causes the local
 
322
                # branch to be out of date
 
323
                self.master_branch.append_revision(self.rev_id)
 
324
 
 
325
            # and now do the commit locally.
 
326
            self.branch.append_revision(self.rev_id)
 
327
 
303
328
            self.work_tree.set_pending_merges([])
304
 
            self.branch.append_revision(self.rev_id)
305
329
            if len(self.parents):
306
330
                precursor = self.parents[0]
307
331
            else:
308
332
                precursor = None
309
333
            self.work_tree.set_last_revision(self.rev_id, precursor)
 
334
            # now the work tree is up to date with the branch
 
335
            
310
336
            self.reporter.completed(self.branch.revno()+1, self.rev_id)
311
337
            if self.config.post_commit() is not None:
312
338
                hooks = self.config.post_commit().split(' ')
317
343
                                   'bzrlib':bzrlib,
318
344
                                   'rev_id':self.rev_id})
319
345
        finally:
320
 
            self.branch.unlock()
 
346
            self._cleanup_bound_branch()
 
347
            self.work_tree.unlock()
 
348
 
 
349
    def _check_bound_branch(self):
 
350
        """Check to see if the local branch is bound.
 
351
 
 
352
        If it is bound, then most of the commit will actually be
 
353
        done using the remote branch as the target branch.
 
354
        Only at the end will the local branch be updated.
 
355
        """
 
356
        if self.local and not self.branch.get_bound_location():
 
357
            raise errors.LocalRequiresBoundBranch()
 
358
 
 
359
        if not self.local:
 
360
            self.master_branch = self.branch.get_master_branch()
 
361
 
 
362
        if not self.master_branch:
 
363
            # make this branch the reference branch for out of date checks.
 
364
            self.master_branch = self.branch
 
365
            return
 
366
 
 
367
        # If the master branch is bound, we must fail
 
368
        master_bound_location = self.master_branch.get_bound_location()
 
369
        if master_bound_location:
 
370
            raise errors.CommitToDoubleBoundBranch(self.branch,
 
371
                    self.master_branch, master_bound_location)
 
372
 
 
373
        # TODO: jam 20051230 We could automatically push local
 
374
        #       commits to the remote branch if they would fit.
 
375
        #       But for now, just require remote to be identical
 
376
        #       to local.
 
377
        
 
378
        # Make sure the local branch is identical to the master
 
379
        master_rh = self.master_branch.revision_history()
 
380
        local_rh = self.branch.revision_history()
 
381
        if local_rh != master_rh:
 
382
            raise errors.BoundBranchOutOfDate(self.branch,
 
383
                    self.master_branch)
 
384
 
 
385
        # Now things are ready to change the master branch
 
386
        # so grab the lock
 
387
        self.bound_branch = self.branch
 
388
        self.master_branch.lock_write()
 
389
####        
 
390
####        # Check to see if we have any pending merges. If we do
 
391
####        # those need to be pushed into the master branch
 
392
####        pending_merges = self.work_tree.pending_merges()
 
393
####        if pending_merges:
 
394
####            for revision_id in pending_merges:
 
395
####                self.master_branch.repository.fetch(self.bound_branch.repository,
 
396
####                                                    revision_id=revision_id)
 
397
 
 
398
    def _cleanup_bound_branch(self):
 
399
        """Executed at the end of a try/finally to cleanup a bound branch.
 
400
 
 
401
        If the branch wasn't bound, this is a no-op.
 
402
        If it was, it resents self.branch to the local branch, instead
 
403
        of being the master.
 
404
        """
 
405
        if not self.bound_branch:
 
406
            return
 
407
        self.master_branch.unlock()
321
408
 
322
409
    def _escape_commit_message(self):
323
410
        """Replace xml-incompatible control characters."""