/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/remote.py

Merge bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
85
85
        self._real_bzrdir.create_repository(shared=shared)
86
86
        return self.open_repository()
87
87
 
 
88
    def destroy_repository(self):
 
89
        """See BzrDir.destroy_repository"""
 
90
        self._ensure_real()
 
91
        self._real_bzrdir.destroy_repository()
 
92
 
88
93
    def create_branch(self):
89
94
        self._ensure_real()
90
95
        real_branch = self._real_bzrdir.create_branch()
412
417
 
413
418
    def get_physical_lock_status(self):
414
419
        """See Repository.get_physical_lock_status()."""
415
 
        return False
 
420
        # should be an API call to the server.
 
421
        self._ensure_real()
 
422
        return self._real_repository.get_physical_lock_status()
416
423
 
417
424
    def is_in_write_group(self):
418
425
        """Return True if there is an open write group.
465
472
    def lock_write(self, token=None):
466
473
        if not self._lock_mode:
467
474
            self._lock_token = self._remote_lock_write(token)
468
 
            assert self._lock_token, 'Remote server did not return a token!'
 
475
            # if self._lock_token is None, then this is something like packs or
 
476
            # svn where we don't get to lock the repo, or a weave style repository
 
477
            # where we cannot lock it over the wire and attempts to do so will
 
478
            # fail.
469
479
            if self._real_repository is not None:
470
480
                self._real_repository.lock_write(token=self._lock_token)
471
481
            if token is not None:
478
488
            raise errors.ReadOnlyError(self)
479
489
        else:
480
490
            self._lock_count += 1
481
 
        return self._lock_token
 
491
        return self._lock_token or None
482
492
 
483
493
    def leave_lock_in_place(self):
 
494
        if not self._lock_token:
 
495
            raise NotImplementedError(self.leave_lock_in_place)
484
496
        self._leave_lock = True
485
497
 
486
498
    def dont_leave_lock_in_place(self):
 
499
        if not self._lock_token:
 
500
            raise NotImplementedError(self.dont_leave_lock_in_place)
487
501
        self._leave_lock = False
488
502
 
489
503
    def _set_real_repository(self, repository):
514
528
 
515
529
    def _unlock(self, token):
516
530
        path = self.bzrdir._path_for_remote_call(self._client)
 
531
        if not token:
 
532
            # with no token the remote repository is not persistently locked.
 
533
            return
517
534
        response = self._client.call('Repository.unlock', path, token)
518
535
        if response == ('ok',):
519
536
            return
542
559
            if old_mode == 'w':
543
560
                # Only write-locked repositories need to make a remote method
544
561
                # call to perfom the unlock.
545
 
                assert self._lock_token, \
546
 
                    '%s is locked, but has no token' \
547
 
                    % self
548
562
                old_token = self._lock_token
549
563
                self._lock_token = None
550
564
                if not self._leave_lock:
581
595
 
582
596
    def sprout(self, to_bzrdir, revision_id=None):
583
597
        # TODO: Option to control what format is created?
584
 
        dest_repo = to_bzrdir.create_repository()
 
598
        self._ensure_real()
 
599
        dest_repo = self._real_repository._format.initialize(to_bzrdir,
 
600
                                                             shared=False)
585
601
        dest_repo.fetch(self, revision_id=revision_id)
586
602
        return dest_repo
587
603
 
604
620
        builder = self._real_repository.get_commit_builder(branch, parents,
605
621
                config, timestamp=timestamp, timezone=timezone,
606
622
                committer=committer, revprops=revprops, revision_id=revision_id)
607
 
        # Make the builder use this RemoteRepository rather than the real one.
608
 
        builder.repository = self
609
623
        return builder
610
624
 
611
625
    @needs_write_lock
682
696
        self._ensure_real()
683
697
        return self._real_repository.fileids_altered_by_revision_ids(revision_ids)
684
698
 
685
 
    def get_versioned_file_checker(self, revisions, revision_versions_cache):
 
699
    def _get_versioned_file_checker(self, revisions, revision_versions_cache):
686
700
        self._ensure_real()
687
 
        return self._real_repository.get_versioned_file_checker(
 
701
        return self._real_repository._get_versioned_file_checker(
688
702
            revisions, revision_versions_cache)
689
703
        
690
704
    def iter_files_bytes(self, desired_files):
1055
1069
            self.repository.unlock()
1056
1070
        path = self.bzrdir._path_for_remote_call(self._client)
1057
1071
        response = self._client.call('Branch.lock_write', path, branch_token,
1058
 
                                     repo_token)
 
1072
                                     repo_token or '')
1059
1073
        if response[0] == 'ok':
1060
1074
            ok, branch_token, repo_token = response
1061
1075
            return branch_token, repo_token
1108
1122
                if token != self._lock_token:
1109
1123
                    raise errors.TokenMismatch(token, self._lock_token)
1110
1124
            self._lock_count += 1
1111
 
        return self._lock_token
 
1125
        return self._lock_token or None
1112
1126
 
1113
1127
    def _unlock(self, branch_token, repo_token):
1114
1128
        path = self.bzrdir._path_for_remote_call(self._client)
1115
1129
        response = self._client.call('Branch.unlock', path, branch_token,
1116
 
                                     repo_token)
 
1130
                                     repo_token or '')
1117
1131
        if response == ('ok',):
1118
1132
            return
1119
1133
        elif response[0] == 'TokenMismatch':
1129
1143
            mode = self._lock_mode
1130
1144
            self._lock_mode = None
1131
1145
            if self._real_branch is not None:
1132
 
                if not self._leave_lock:
 
1146
                if (not self._leave_lock and mode == 'w' and
 
1147
                    self._repo_lock_token):
1133
1148
                    # If this RemoteBranch will remove the physical lock for the
1134
1149
                    # repository, make sure the _real_branch doesn't do it
1135
1150
                    # first.  (Because the _real_branch's repository is set to
1153
1168
        return self._real_branch.break_lock()
1154
1169
 
1155
1170
    def leave_lock_in_place(self):
 
1171
        if not self._lock_token:
 
1172
            raise NotImplementedError(self.leave_lock_in_place)
1156
1173
        self._leave_lock = True
1157
1174
 
1158
1175
    def dont_leave_lock_in_place(self):
 
1176
        if not self._lock_token:
 
1177
            raise NotImplementedError(self.dont_leave_lock_in_place)
1159
1178
        self._leave_lock = False
1160
1179
 
1161
1180
    def last_revision_info(self):
1215
1234
        # format, because RemoteBranches can't be created at arbitrary URLs.
1216
1235
        # XXX: if to_bzrdir is a RemoteBranch, this should perhaps do
1217
1236
        # to_bzrdir.create_branch...
1218
 
        result = branch.BranchFormat.get_default_format().initialize(to_bzrdir)
 
1237
        self._ensure_real()
 
1238
        result = self._real_branch._format.initialize(to_bzrdir)
1219
1239
        self.copy_content_into(result, revision_id=revision_id)
1220
1240
        result.set_parent(self.bzrdir.root_transport.base)
1221
1241
        return result
1263
1283
        self._ensure_real()
1264
1284
        return self._real_branch.set_push_location(location)
1265
1285
 
1266
 
    def update_revisions(self, other, stop_revision=None):
 
1286
    def update_revisions(self, other, stop_revision=None, overwrite=False):
1267
1287
        self._ensure_real()
1268
1288
        return self._real_branch.update_revisions(
1269
 
            other, stop_revision=stop_revision)
 
1289
            other, stop_revision=stop_revision, overwrite=overwrite)
1270
1290
 
1271
1291
 
1272
1292
class RemoteBranchConfig(BranchConfig):