/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

  • Committer: Robert Collins
  • Date: 2007-11-27 20:35:02 UTC
  • mfrom: (3036 +trunk)
  • mto: This revision was merged to the branch mainline in revision 3038.
  • Revision ID: robertc@robertcollins.net-20071127203502-280mxe1zvdlagrpe
Merge with bzr.dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
305
305
            #self._real_repository = self.bzrdir._real_bzrdir.open_repository()
306
306
            self._set_real_repository(self.bzrdir._real_bzrdir.open_repository())
307
307
 
 
308
    def find_text_key_references(self):
 
309
        """Find the text key references within the repository.
 
310
 
 
311
        :return: a dictionary mapping (file_id, revision_id) tuples to altered file-ids to an iterable of
 
312
        revision_ids. Each altered file-ids has the exact revision_ids that
 
313
        altered it listed explicitly.
 
314
        :return: A dictionary mapping text keys ((fileid, revision_id) tuples)
 
315
            to whether they were referred to by the inventory of the
 
316
            revision_id that they contain. The inventory texts from all present
 
317
            revision ids are assessed to generate this report.
 
318
        """
 
319
        self._ensure_real()
 
320
        return self._real_repository.find_text_key_references()
 
321
 
 
322
    def _generate_text_key_index(self):
 
323
        """Generate a new text key index for the repository.
 
324
 
 
325
        This is an expensive function that will take considerable time to run.
 
326
 
 
327
        :return: A dict mapping (file_id, revision_id) tuples to a list of
 
328
            parents, also (file_id, revision_id) tuples.
 
329
        """
 
330
        self._ensure_real()
 
331
        return self._real_repository._generate_text_key_index()
 
332
 
308
333
    def get_revision_graph(self, revision_id=None):
309
334
        """See Repository.get_revision_graph()."""
310
335
        if revision_id is None:
387
412
 
388
413
    def get_physical_lock_status(self):
389
414
        """See Repository.get_physical_lock_status()."""
390
 
        return False
 
415
        # should be an API call to the server.
 
416
        self._ensure_real()
 
417
        return self._real_repository.get_physical_lock_status()
391
418
 
392
419
    def is_in_write_group(self):
393
420
        """Return True if there is an open write group.
440
467
    def lock_write(self, token=None):
441
468
        if not self._lock_mode:
442
469
            self._lock_token = self._remote_lock_write(token)
443
 
            assert self._lock_token, 'Remote server did not return a token!'
 
470
            # if self._lock_token is None, then this is something like packs or
 
471
            # svn where we don't get to lock the repo, or a weave style repository
 
472
            # where we cannot lock it over the wire and attempts to do so will
 
473
            # fail.
444
474
            if self._real_repository is not None:
445
475
                self._real_repository.lock_write(token=self._lock_token)
446
476
            if token is not None:
453
483
            raise errors.ReadOnlyError(self)
454
484
        else:
455
485
            self._lock_count += 1
456
 
        return self._lock_token
 
486
        return self._lock_token or None
457
487
 
458
488
    def leave_lock_in_place(self):
 
489
        if not self._lock_token:
 
490
            raise NotImplementedError(self.leave_lock_in_place)
459
491
        self._leave_lock = True
460
492
 
461
493
    def dont_leave_lock_in_place(self):
 
494
        if not self._lock_token:
 
495
            raise NotImplementedError(self.dont_leave_lock_in_place)
462
496
        self._leave_lock = False
463
497
 
464
498
    def _set_real_repository(self, repository):
489
523
 
490
524
    def _unlock(self, token):
491
525
        path = self.bzrdir._path_for_remote_call(self._client)
 
526
        if not token:
 
527
            # with no token the remote repository is not persistently locked.
 
528
            return
492
529
        response = self._client.call('Repository.unlock', path, token)
493
530
        if response == ('ok',):
494
531
            return
517
554
            if old_mode == 'w':
518
555
                # Only write-locked repositories need to make a remote method
519
556
                # call to perfom the unlock.
520
 
                assert self._lock_token, \
521
 
                    '%s is locked, but has no token' \
522
 
                    % self
523
557
                old_token = self._lock_token
524
558
                self._lock_token = None
525
559
                if not self._leave_lock:
579
613
        builder = self._real_repository.get_commit_builder(branch, parents,
580
614
                config, timestamp=timestamp, timezone=timezone,
581
615
                committer=committer, revprops=revprops, revision_id=revision_id)
582
 
        # Make the builder use this RemoteRepository rather than the real one.
583
 
        builder.repository = self
584
616
        return builder
585
617
 
586
618
    @needs_write_lock
796
828
        return self._real_repository.store_revision_signature(
797
829
            gpg_strategy, plaintext, revision_id)
798
830
 
 
831
    def add_signature_text(self, revision_id, signature):
 
832
        self._ensure_real()
 
833
        return self._real_repository.add_signature_text(revision_id, signature)
 
834
 
799
835
    def has_signature_for_revision_id(self, revision_id):
800
836
        self._ensure_real()
801
837
        return self._real_repository.has_signature_for_revision_id(revision_id)
1026
1062
            self.repository.unlock()
1027
1063
        path = self.bzrdir._path_for_remote_call(self._client)
1028
1064
        response = self._client.call('Branch.lock_write', path, branch_token,
1029
 
                                     repo_token)
 
1065
                                     repo_token or '')
1030
1066
        if response[0] == 'ok':
1031
1067
            ok, branch_token, repo_token = response
1032
1068
            return branch_token, repo_token
1079
1115
                if token != self._lock_token:
1080
1116
                    raise errors.TokenMismatch(token, self._lock_token)
1081
1117
            self._lock_count += 1
1082
 
        return self._lock_token
 
1118
        return self._lock_token or None
1083
1119
 
1084
1120
    def _unlock(self, branch_token, repo_token):
1085
1121
        path = self.bzrdir._path_for_remote_call(self._client)
1086
1122
        response = self._client.call('Branch.unlock', path, branch_token,
1087
 
                                     repo_token)
 
1123
                                     repo_token or '')
1088
1124
        if response == ('ok',):
1089
1125
            return
1090
1126
        elif response[0] == 'TokenMismatch':
1100
1136
            mode = self._lock_mode
1101
1137
            self._lock_mode = None
1102
1138
            if self._real_branch is not None:
1103
 
                if not self._leave_lock:
 
1139
                if (not self._leave_lock and mode == 'w' and
 
1140
                    self._repo_lock_token):
1104
1141
                    # If this RemoteBranch will remove the physical lock for the
1105
1142
                    # repository, make sure the _real_branch doesn't do it
1106
1143
                    # first.  (Because the _real_branch's repository is set to
1124
1161
        return self._real_branch.break_lock()
1125
1162
 
1126
1163
    def leave_lock_in_place(self):
 
1164
        if not self._lock_token:
 
1165
            raise NotImplementedError(self.leave_lock_in_place)
1127
1166
        self._leave_lock = True
1128
1167
 
1129
1168
    def dont_leave_lock_in_place(self):
 
1169
        if not self._lock_token:
 
1170
            raise NotImplementedError(self.dont_leave_lock_in_place)
1130
1171
        self._leave_lock = False
1131
1172
 
1132
1173
    def last_revision_info(self):