/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/remote.py

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

Show diffs side-by-side

added

removed

bzrlib/remote.py

42

42

    deprecated_method,

43

43

    zero_ninetyone,

44

44

    )

45

 

from bzrlib.revision import NULL_REVISION

 

45

from bzrlib.revision import ensure_null, NULL_REVISION

46

46

from bzrlib.trace import mutter, note, warning

47

47

 

48

48

# Note: RemoteBzrDirFormat is in bzrdir.py

149

149

    def open_repository(self):

150

150

        path = self._path_for_remote_call(self._client)

151

151

        verb = 'BzrDir.find_repositoryV2'

152

 

        response = self._client.call(verb, path)

153

 

        if (response == ('error', "Generic bzr smart protocol error: "

154

 

                "bad request '%s'" % verb) or

155

 

              response == ('error', "Generic bzr smart protocol error: "

156

 

                "bad request u'%s'" % verb)):

 

152

        try:

 

153

            response = self._client.call(verb, path)

 

154

        except errors.UnknownSmartMethod:

157

155

            verb = 'BzrDir.find_repository'

158

156

            response = self._client.call(verb, path)

159

157

        assert response[0] in ('ok', 'norepository'), \

634

632

        """

635

633

        import tempfile

636

634

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

637

 

        response, protocol = self._client.call_expecting_body(

638

 

            'Repository.tarball', path, compression)

 

635

        try:

 

636

            response, protocol = self._client.call_expecting_body(

 

637

                'Repository.tarball', path, compression)

 

638

        except errors.UnknownSmartMethod:

 

639

            protocol.cancel_read_body()

 

640

            return None

639

641

        if response[0] == 'ok':

640

642

            # Extract the tarball and return it

641

643

            t = tempfile.NamedTemporaryFile()

643

645

            t.write(protocol.read_body_bytes())

644

646

            t.seek(0)

645

647

            return t

646

 

        if (response == ('error', "Generic bzr smart protocol error: "

647

 

                "bad request 'Repository.tarball'") or

648

 

              response == ('error', "Generic bzr smart protocol error: "

649

 

                "bad request u'Repository.tarball'")):

650

 

            protocol.cancel_read_body()

651

 

            return None

652

648

        raise errors.UnexpectedSmartServerResponse(response)

653

649

 

654

650

    def sprout(self, to_bzrdir, revision_id=None):

718

714

        return self._real_repository.clone(a_bzrdir, revision_id=revision_id)

719

715

 

720

716

    def make_working_trees(self):

721

 

        """RemoteRepositories never create working trees by default."""

722

 

        return False

 

717

        """See Repository.make_working_trees"""

 

718

        self._ensure_real()

 

719

        return self._real_repository.make_working_trees()

723

720

 

724

721

    def revision_ids_to_search_result(self, result_set):

725

722

        """Convert a set of revision ids to a graph SearchResult."""

815

812

                100.0 * len(self._requested_parents) / len(ancestry))

816

813

        return dict((k, ancestry[k]) for k in present_keys)

817

814

 

818

 

    def _response_is_unknown_method(self, response, verb):

819

 

        """Return True if response is an unknonwn method response to verb.

820

 

        

821

 

        :param response: The response from a smart client call_expecting_body

822

 

            call.

823

 

        :param verb: The verb used in that call.

824

 

        :return: True if an unknown method was encountered.

825

 

        """

826

 

        # This might live better on

827

 

        # bzrlib.smart.protocol.SmartClientRequestProtocolOne

828

 

        if (response[0] == ('error', "Generic bzr smart protocol error: "

829

 

                "bad request '%s'" % verb) or

830

 

              response[0] == ('error', "Generic bzr smart protocol error: "

831

 

                "bad request u'%s'" % verb)):

832

 

           response[1].cancel_read_body()

833

 

           return True

834

 

        return False

835

 

 

836

815

    def _get_parent_map(self, keys):

837

816

        """Helper for get_parent_map that performs the RPC."""

838

817

        medium = self._client._medium

883

862

            assert type(key) is str

884

863

        verb = 'Repository.get_parent_map'

885

864

        args = (path,) + tuple(keys)

886

 

        response = self._client.call_with_body_bytes_expecting_body(

887

 

            verb, args, self._serialise_search_recipe(recipe))

888

 

        if self._response_is_unknown_method(response, verb):

 

865

        try:

 

866

            response = self._client.call_with_body_bytes_expecting_body(

 

867

                verb, args, self._serialise_search_recipe(recipe))

 

868

        except errors.UnknownSmartMethod:

889

869

            # Server does not support this method, so get the whole graph.

890

870

            # Worse, we have to force a disconnection, because the server now

891

871

            # doesn't realise it has a body on the wire to consume, so the

897

877

            # To avoid having to disconnect repeatedly, we keep track of the

898

878

            # fact the server doesn't understand remote methods added in 1.2.

899

879

            medium._remote_is_at_least_1_2 = False

900

 

            return self._get_revision_graph(None)

901

 

        elif response[0][0] not in ['ok']:

902

 

            reponse[1].cancel_read_body()

 

880

            return self.get_revision_graph(None)

 

881

        if response[0][0] not in ['ok']:

 

882

            response[1].cancel_read_body()

903

883

            raise errors.UnexpectedSmartServerResponse(response[0])

904

884

        if response[0][0] == 'ok':

905

885

            coded = bz2.decompress(response[1].read_body_bytes())

1015

995

        return self._real_repository.pack()

1016

996

 

1017

997

    def set_make_working_trees(self, new_value):

1018

 

        raise NotImplementedError(self.set_make_working_trees)

 

998

        self._ensure_real()

 

999

        self._real_repository.set_make_working_trees(new_value)

1019

1000

 

1020

1001

    @needs_write_lock

1021

1002

    def sign_revision(self, revision_id, gpg_strategy):

1061

1042

        REQUEST_NAME = 'Repository.stream_revisions_chunked'

1062

1043

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

1063

1044

        body = self._serialise_search_recipe(search.get_recipe())

1064

 

        response, protocol = self._client.call_with_body_bytes_expecting_body(

1065

 

            REQUEST_NAME, (path,), body)

1066

 

 

1067

 

        if self._response_is_unknown_method((response, protocol), REQUEST_NAME):

 

1045

        try:

 

1046

            result = self._client.call_with_body_bytes_expecting_body(

 

1047

                REQUEST_NAME, (path,), body)

 

1048

            response, protocol = result

 

1049

        except errors.UnknownSmartMethod:

1068

1050

            # Server does not support this method, so fall back to VFS.

1069

1051

            # Worse, we have to force a disconnection, because the server now

1070

1052

            # doesn't realise it has a body on the wire to consume, so the

1248

1230

        self._control_files = None

1249

1231

        self._lock_mode = None

1250

1232

        self._lock_token = None

 

1233

        self._repo_lock_token = None

1251

1234

        self._lock_count = 0

1252

1235

        self._leave_lock = False

1253

1236

 

1508

1491

    def is_locked(self):

1509

1492

        return self._lock_count >= 1

1510

1493

 

 

1494

    @needs_write_lock

1511

1495

    def set_last_revision_info(self, revno, revision_id):

1512

 

        self._ensure_real()

1513

 

        self._clear_cached_state()

1514

 

        return self._real_branch.set_last_revision_info(revno, revision_id)

 

1496

        assert type(revno) is int

 

1497

        revision_id = ensure_null(revision_id)

 

1498

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

 

1499

        try:

 

1500

            response = self._client.call('Branch.set_last_revision_info',

 

1501

                path, self._lock_token, self._repo_lock_token, str(revno), revision_id)

 

1502

        except errors.UnknownSmartMethod:

 

1503

            self._ensure_real()

 

1504

            self._clear_cached_state()

 

1505

            return self._real_branch.set_last_revision_info(revno, revision_id)

 

1506

        if response == ('ok',):

 

1507

            self._clear_cached_state()

 

1508

        elif response[0] == 'NoSuchRevision':

 

1509

            raise NoSuchRevision(self, response[1])

 

1510

        else:

 

1511

            raise errors.UnexpectedSmartServerResponse(response)

1515

1512

 

1516

1513

    def generate_revision_history(self, revision_id, last_rev=None,

1517

1514

                                  other_branch=None):

• Older »

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