← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

  • Committer: John Arbash Meinel
  • Date: 2010-09-21 19:30:33 UTC
  • mto: This revision was merged to the branch mainline in revision 5451.
  • Revision ID: john@arbash-meinel.com-20100921193033-9ftw56og72mhlwo4
Change GroupCompressBlock to work in self._z_compress_chunks

This pushes down one of the peak memory locations. We still have a requirement
during commit of 1 fulltext + 2 compressed texts, but at least this code
path is now better about only using 1 fulltext and 1 compressed text.
We need to push this into more apis to get a bigger benefit.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/remote.py
21
21
    branch,
22
22
    bzrdir,
23
23
    config,
 
24
    controldir,
24
25
    debug,
25
26
    errors,
26
27
    graph,
213
214
        if len(branch_info) != 2:
214
215
            raise errors.UnexpectedSmartServerResponse(response)
215
216
        branch_ref, branch_name = branch_info
216
 
        format = bzrdir.network_format_registry.get(control_name)
 
217
        format = controldir.network_format_registry.get(control_name)
217
218
        if repo_name:
218
219
            format.repository_format = repository.network_format_registry.get(
219
220
                repo_name)
273
274
    def create_workingtree(self, revision_id=None, from_branch=None):
274
275
        raise errors.NotLocalUrl(self.transport.base)
275
276
 
276
 
    def find_branch_format(self):
 
277
    def find_branch_format(self, name=None):
277
278
        """Find the branch 'format' for this bzrdir.
278
279
 
279
280
        This might be a synthetic object for e.g. RemoteBranch and SVN.
280
281
        """
281
 
        b = self.open_branch()
 
282
        b = self.open_branch(name=name)
282
283
        return b._format
283
284
 
284
 
    def get_branch_reference(self):
 
285
    def get_branch_reference(self, name=None):
285
286
        """See BzrDir.get_branch_reference()."""
 
287
        if name is not None:
 
288
            # XXX JRV20100304: Support opening colocated branches
 
289
            raise errors.NoColocatedBranchSupport(self)
286
290
        response = self._get_branch_reference()
287
291
        if response[0] == 'ref':
288
292
            return response[1]
319
323
            raise errors.UnexpectedSmartServerResponse(response)
320
324
        return response
321
325
 
322
 
    def _get_tree_branch(self):
 
326
    def _get_tree_branch(self, name=None):
323
327
        """See BzrDir._get_tree_branch()."""
324
 
        return None, self.open_branch()
 
328
        return None, self.open_branch(name=name)
325
329
 
326
330
    def open_branch(self, name=None, unsupported=False,
327
331
                    ignore_fallbacks=False):
645
649
 
646
650
 
647
651
class RemoteRepository(_RpcHelper, lock._RelockDebugMixin,
648
 
    bzrdir.ControlComponent):
 
652
    controldir.ControlComponent):
649
653
    """Repository accessed over rpc.
650
654
 
651
655
    For the moment most operations are performed using local transport-backed
896
900
    def _has_same_fallbacks(self, other_repo):
897
901
        """Returns true if the repositories have the same fallbacks."""
898
902
        # XXX: copied from Repository; it should be unified into a base class
899
 
        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>
 
903
        # <https://bugs.launchpad.net/bzr/+bug/401622>
900
904
        my_fb = self._fallback_repositories
901
905
        other_fb = other_repo._fallback_repositories
902
906
        if len(my_fb) != len(other_fb):
1000
1004
    def lock_read(self):
1001
1005
        """Lock the repository for read operations.
1002
1006
 
1003
 
        :return: An object with an unlock method which will release the lock
1004
 
            obtained.
 
1007
        :return: A bzrlib.lock.LogicalLockResult.
1005
1008
        """
1006
1009
        # wrong eventually - want a local lock cache context
1007
1010
        if not self._lock_mode:
1015
1018
                repo.lock_read()
1016
1019
        else:
1017
1020
            self._lock_count += 1
1018
 
        return self
 
1021
        return lock.LogicalLockResult(self.unlock)
1019
1022
 
1020
1023
    def _remote_lock_write(self, token):
1021
1024
        path = self.bzrdir._path_for_remote_call(self._client)
1313
1316
        return self._real_repository.make_working_trees()
1314
1317
 
1315
1318
    def refresh_data(self):
1316
 
        """Re-read any data needed to to synchronise with disk.
 
1319
        """Re-read any data needed to synchronise with disk.
1317
1320
 
1318
1321
        This method is intended to be called after another repository instance
1319
1322
        (such as one used by a smart server) has inserted data into the
1320
 
        repository. It may not be called during a write group, but may be
1321
 
        called at any other time.
 
1323
        repository. On all repositories this will work outside of write groups.
 
1324
        Some repository formats (pack and newer for bzrlib native formats)
 
1325
        support refresh_data inside write groups. If called inside a write
 
1326
        group on a repository that does not support refreshing in a write group
 
1327
        IsInWriteGroupError will be raised.
1322
1328
        """
1323
 
        if self.is_in_write_group():
1324
 
            raise errors.InternalBzrError(
1325
 
                "May not refresh_data while in a write group.")
1326
1329
        if self._real_repository is not None:
1327
1330
            self._real_repository.refresh_data()
1328
1331
 
1978
1981
        if response_tuple[0] != 'ok':
1979
1982
            raise errors.UnexpectedSmartServerResponse(response_tuple)
1980
1983
        byte_stream = response_handler.read_streamed_body()
1981
 
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)
 
1984
        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,
 
1985
            self._record_counter)
1982
1986
        if src_format.network_name() != repo._format.network_name():
1983
1987
            raise AssertionError(
1984
1988
                "Mismatched RemoteRepository and stream src %r, %r" % (
2396
2400
    def lock_read(self):
2397
2401
        """Lock the branch for read operations.
2398
2402
 
2399
 
        :return: An object with an unlock method which will release the lock
2400
 
            obtained.
 
2403
        :return: A bzrlib.lock.LogicalLockResult.
2401
2404
        """
2402
2405
        self.repository.lock_read()
2403
2406
        if not self._lock_mode:
2408
2411
                self._real_branch.lock_read()
2409
2412
        else:
2410
2413
            self._lock_count += 1
2411
 
        return self
 
2414
        return lock.LogicalLockResult(self.unlock)
2412
2415
 
2413
2416
    def _remote_lock_write(self, token):
2414
2417
        if token is None:
2418
2421
            repo_token = self.repository.lock_write().repository_token
2419
2422
            self.repository.unlock()
2420
2423
        err_context = {'token': token}
2421
 
        response = self._call(
2422
 
            'Branch.lock_write', self._remote_path(), branch_token,
2423
 
            repo_token or '', **err_context)
 
2424
        try:
 
2425
            response = self._call(
 
2426
                'Branch.lock_write', self._remote_path(), branch_token,
 
2427
                repo_token or '', **err_context)
 
2428
        except errors.LockContention, e:
 
2429
            # The LockContention from the server doesn't have any
 
2430
            # information about the lock_url. We re-raise LockContention
 
2431
            # with valid lock_url.
 
2432
            raise errors.LockContention('(remote lock)',
 
2433
                self.repository.base.split('.bzr/')[0])
2424
2434
        if response[0] != 'ok':
2425
2435
            raise errors.UnexpectedSmartServerResponse(response)
2426
2436
        ok, branch_token, repo_token = response
2447
2457
            self._lock_mode = 'w'
2448
2458
            self._lock_count = 1
2449
2459
        elif self._lock_mode == 'r':
2450
 
            raise errors.ReadOnlyTransaction
 
2460
            raise errors.ReadOnlyError(self)
2451
2461
        else:
2452
2462
            if token is not None:
2453
2463
                # A token was given to lock_write, and we're relocking, so
2787
2797
        medium = self._branch._client._medium
2788
2798
        if medium._is_remote_before((1, 14)):
2789
2799
            return self._vfs_set_option(value, name, section)
 
2800
        if isinstance(value, dict):
 
2801
            if medium._is_remote_before((2, 2)):
 
2802
                return self._vfs_set_option(value, name, section)
 
2803
            return self._set_config_option_dict(value, name, section)
 
2804
        else:
 
2805
            return self._set_config_option(value, name, section)
 
2806
 
 
2807
    def _set_config_option(self, value, name, section):
2790
2808
        try:
2791
2809
            path = self._branch._remote_path()
2792
2810
            response = self._branch._client.call('Branch.set_config_option',
2793
2811
                path, self._branch._lock_token, self._branch._repo_lock_token,
2794
2812
                value.encode('utf8'), name, section or '')
2795
2813
        except errors.UnknownSmartMethod:
 
2814
            medium = self._branch._client._medium
2796
2815
            medium._remember_remote_is_before((1, 14))
2797
2816
            return self._vfs_set_option(value, name, section)
2798
2817
        if response != ():
2799
2818
            raise errors.UnexpectedSmartServerResponse(response)
2800
2819
 
 
2820
    def _serialize_option_dict(self, option_dict):
 
2821
        utf8_dict = {}
 
2822
        for key, value in option_dict.items():
 
2823
            if isinstance(key, unicode):
 
2824
                key = key.encode('utf8')
 
2825
            if isinstance(value, unicode):
 
2826
                value = value.encode('utf8')
 
2827
            utf8_dict[key] = value
 
2828
        return bencode.bencode(utf8_dict)
 
2829
 
 
2830
    def _set_config_option_dict(self, value, name, section):
 
2831
        try:
 
2832
            path = self._branch._remote_path()
 
2833
            serialised_dict = self._serialize_option_dict(value)
 
2834
            response = self._branch._client.call(
 
2835
                'Branch.set_config_option_dict',
 
2836
                path, self._branch._lock_token, self._branch._repo_lock_token,
 
2837
                serialised_dict, name, section or '')
 
2838
        except errors.UnknownSmartMethod:
 
2839
            medium = self._branch._client._medium
 
2840
            medium._remember_remote_is_before((2, 2))
 
2841
            return self._vfs_set_option(value, name, section)
 
2842
        if response != ():
 
2843
            raise errors.UnexpectedSmartServerResponse(response)
 
2844
 
2801
2845
    def _real_object(self):
2802
2846
        self._branch._ensure_real()
2803
2847
        return self._branch._real_branch