/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

• browse files at revision 5222.2.6
• compare with another revision
• compare with revision 5200.3.2
• download diff
• download tarball
• view history from revision 5222.2.6

Show diffs side-by-side

added

removed

bzrlib/remote.py

33

33

    static_tuple,

34

34

    symbol_versioning,

35

35

)

36

 

from bzrlib.branch import BranchReferenceFormat

 

36

from bzrlib.branch import BranchReferenceFormat, BranchWriteLockResult

37

37

from bzrlib.bzrdir import BzrDir, RemoteBzrDirFormat

38

38

from bzrlib.decorators import needs_read_lock, needs_write_lock, only_raises

39

39

from bzrlib.errors import (

43

43

from bzrlib.lockable_files import LockableFiles

44

44

from bzrlib.smart import client, vfs, repository as smart_repo

45

45

from bzrlib.revision import ensure_null, NULL_REVISION

 

46

from bzrlib.repository import RepositoryWriteLockResult

46

47

from bzrlib.trace import mutter, note, warning

47

48

 

48

49

 

898

899

    def _has_same_fallbacks(self, other_repo):

899

900

        """Returns true if the repositories have the same fallbacks."""

900

901

        # XXX: copied from Repository; it should be unified into a base class

901

 

        # <https://bugs.edge.launchpad.net/bzr/+bug/401622>

 

902

        # <https://bugs.launchpad.net/bzr/+bug/401622>

902

903

        my_fb = self._fallback_repositories

903

904

        other_fb = other_repo._fallback_repositories

904

905

        if len(my_fb) != len(other_fb):

1000

1001

        pass

1001

1002

 

1002

1003

    def lock_read(self):

 

1004

        """Lock the repository for read operations.

 

1005

 

 

1006

        :return: A bzrlib.lock.LogicalLockResult.

 

1007

        """

1003

1008

        # wrong eventually - want a local lock cache context

1004

1009

        if not self._lock_mode:

1005

1010

            self._note_lock('r')

1012

1017

                repo.lock_read()

1013

1018

        else:

1014

1019

            self._lock_count += 1

 

1020

        return lock.LogicalLockResult(self.unlock)

1015

1021

 

1016

1022

    def _remote_lock_write(self, token):

1017

1023

        path = self.bzrdir._path_for_remote_call(self._client)

1057

1063

            raise errors.ReadOnlyError(self)

1058

1064

        else:

1059

1065

            self._lock_count += 1

1060

 

        return self._lock_token or None

 

1066

        return RepositoryWriteLockResult(self.unlock, self._lock_token or None)

1061

1067

 

1062

1068

    def leave_lock_in_place(self):

1063

1069

        if not self._lock_token:

1974

1980

        if response_tuple[0] != 'ok':

1975

1981

            raise errors.UnexpectedSmartServerResponse(response_tuple)

1976

1982

        byte_stream = response_handler.read_streamed_body()

1977

 

        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream)

 

1983

        src_format, stream = smart_repo._byte_stream_to_stream(byte_stream,

 

1984

            self._record_counter)

1978

1985

        if src_format.network_name() != repo._format.network_name():

1979

1986

            raise AssertionError(

1980

1987

                "Mismatched RemoteRepository and stream src %r, %r" % (

2390

2397

            self._vfs_set_tags_bytes(bytes)

2391

2398

 

2392

2399

    def lock_read(self):

 

2400

        """Lock the branch for read operations.

 

2401

 

 

2402

        :return: A bzrlib.lock.LogicalLockResult.

 

2403

        """

2393

2404

        self.repository.lock_read()

2394

2405

        if not self._lock_mode:

2395

2406

            self._note_lock('r')

2399

2410

                self._real_branch.lock_read()

2400

2411

        else:

2401

2412

            self._lock_count += 1

 

2413

        return lock.LogicalLockResult(self.unlock)

2402

2414

 

2403

2415

    def _remote_lock_write(self, token):

2404

2416

        if token is None:

2405

2417

            branch_token = repo_token = ''

2406

2418

        else:

2407

2419

            branch_token = token

2408

 

            repo_token = self.repository.lock_write()

 

2420

            repo_token = self.repository.lock_write().repository_token

2409

2421

            self.repository.unlock()

2410

2422

        err_context = {'token': token}

2411

 

        response = self._call(

2412

 

            'Branch.lock_write', self._remote_path(), branch_token,

2413

 

            repo_token or '', **err_context)

 

2423

        try:

 

2424

            response = self._call(

 

2425

                'Branch.lock_write', self._remote_path(), branch_token,

 

2426

                repo_token or '', **err_context)

 

2427

        except errors.LockContention, e:

 

2428

            # The LockContention from the server doesn't have any

 

2429

            # information about the lock_url. We re-raise LockContention

 

2430

            # with valid lock_url.

 

2431

            raise errors.LockContention('(remote lock)',

 

2432

                self.repository.base.split('.bzr/')[0])

2414

2433

        if response[0] != 'ok':

2415

2434

            raise errors.UnexpectedSmartServerResponse(response)

2416

2435

        ok, branch_token, repo_token = response

2437

2456

            self._lock_mode = 'w'

2438

2457

            self._lock_count = 1

2439

2458

        elif self._lock_mode == 'r':

2440

 

            raise errors.ReadOnlyTransaction

 

2459

            raise errors.ReadOnlyError(self)

2441

2460

        else:

2442

2461

            if token is not None:

2443

2462

                # A token was given to lock_write, and we're relocking, so

2448

2467

            self._lock_count += 1

2449

2468

            # Re-lock the repository too.

2450

2469

            self.repository.lock_write(self._repo_lock_token)

2451

 

        return self._lock_token or None

 

2470

        return BranchWriteLockResult(self.unlock, self._lock_token or None)

2452

2471

 

2453

2472

    def _unlock(self, branch_token, repo_token):

2454

2473

        err_context = {'token': str((branch_token, repo_token))}

2777

2796

        medium = self._branch._client._medium

2778

2797

        if medium._is_remote_before((1, 14)):

2779

2798

            return self._vfs_set_option(value, name, section)

 

2799

        if isinstance(value, dict):

 

2800

            if medium._is_remote_before((2, 2)):

 

2801

                return self._vfs_set_option(value, name, section)

 

2802

            return self._set_config_option_dict(value, name, section)

 

2803

        else:

 

2804

            return self._set_config_option(value, name, section)

 

2805

 

 

2806

    def _set_config_option(self, value, name, section):

2780

2807

        try:

2781

2808

            path = self._branch._remote_path()

2782

2809

            response = self._branch._client.call('Branch.set_config_option',

2783

2810

                path, self._branch._lock_token, self._branch._repo_lock_token,

2784

2811

                value.encode('utf8'), name, section or '')

2785

2812

        except errors.UnknownSmartMethod:

 

2813

            medium = self._branch._client._medium

2786

2814

            medium._remember_remote_is_before((1, 14))

2787

2815

            return self._vfs_set_option(value, name, section)

2788

2816

        if response != ():

2789

2817

            raise errors.UnexpectedSmartServerResponse(response)

2790

2818

 

 

2819

    def _serialize_option_dict(self, option_dict):

 

2820

        utf8_dict = {}

 

2821

        for key, value in option_dict.items():

 

2822

            if isinstance(key, unicode):

 

2823

                key = key.encode('utf8')

 

2824

            if isinstance(value, unicode):

 

2825

                value = value.encode('utf8')

 

2826

            utf8_dict[key] = value

 

2827

        return bencode.bencode(utf8_dict)

 

2828

 

 

2829

    def _set_config_option_dict(self, value, name, section):

 

2830

        try:

 

2831

            path = self._branch._remote_path()

 

2832

            serialised_dict = self._serialize_option_dict(value)

 

2833

            response = self._branch._client.call(

 

2834

                'Branch.set_config_option_dict',

 

2835

                path, self._branch._lock_token, self._branch._repo_lock_token,

 

2836

                serialised_dict, name, section or '')

 

2837

        except errors.UnknownSmartMethod:

 

2838

            medium = self._branch._client._medium

 

2839

            medium._remember_remote_is_before((2, 2))

 

2840

            return self._vfs_set_option(value, name, section)

 

2841

        if response != ():

 

2842

            raise errors.UnexpectedSmartServerResponse(response)

 

2843

 

2791

2844

    def _real_object(self):

2792

2845

        self._branch._ensure_real()

2793

2846

        return self._branch._real_branch

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0