~bzr-pqm/bzr/bzr.dev : contents of bzrlib/smart/client.py at revision 3193.6.8

~bzr-pqm/bzr/bzr.dev : (revision 3193.6.8)

# Copyright (C) 2006 Canonical Ltd
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

import urllib
from urlparse import urlparse

from bzrlib.smart import protocol
from bzrlib import urlutils


class _SmartClient(object):

    def __init__(self, shared_connection):
        """Constructor.

        :param shared_connection: a bzrlib.transport._SharedConnection
        """
        self._shared_connection = shared_connection

    def get_smart_medium(self):
        return self._shared_connection.connection

    def call(self, method, *args):
        """Call a method on the remote server."""
        result, protocol = self.call_expecting_body(method, *args)
        protocol.cancel_read_body()
        return result

    def call_expecting_body(self, method, *args):
        """Call a method and return the result and the protocol object.
        
        The body can be read like so::

            result, smart_protocol = smart_client.call_expecting_body(...)
            body = smart_protocol.read_body_bytes()
        """
        request = self.get_smart_medium().get_request()
        smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
        smart_protocol.call(method, *args)
        return smart_protocol.read_response_tuple(expect_body=True), smart_protocol

    def call_with_body_bytes(self, method, args, body):
        """Call a method on the remote server with body bytes."""
        if type(method) is not str:
            raise TypeError('method must be a byte string, not %r' % (method,))
        for arg in args:
            if type(arg) is not str:
                raise TypeError('args must be byte strings, not %r' % (args,))
        if type(body) is not str:
            raise TypeError('body must be byte string, not %r' % (body,))
        request = self.get_smart_medium().get_request()
        smart_protocol = protocol.SmartClientRequestProtocolOne(request)
        smart_protocol.call_with_body_bytes((method, ) + args, body)
        return smart_protocol.read_response_tuple()

    def call_with_body_bytes_expecting_body(self, method, args, body):
        """Call a method on the remote server with body bytes."""
        if type(method) is not str:
            raise TypeError('method must be a byte string, not %r' % (method,))
        for arg in args:
            if type(arg) is not str:
                raise TypeError('args must be byte strings, not %r' % (args,))
        if type(body) is not str:
            raise TypeError('body must be byte string, not %r' % (body,))
        request = self.get_smart_medium().get_request()
        smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
        smart_protocol.call_with_body_bytes((method, ) + args, body)
        return smart_protocol.read_response_tuple(expect_body=True), smart_protocol

    def remote_path_from_transport(self, transport):
        """Convert transport into a path suitable for using in a request.
        
        Note that the resulting remote path doesn't encode the host name or
        anything but path, so it is only safe to use it in requests sent over
        the medium from the matching transport.
        """
        if self._shared_connection.base.startswith('bzr+http://'):
            medium_base = self._shared_connection.base
        else:
            medium_base = urlutils.join(self._shared_connection.base, '/')
            
        rel_url = urlutils.relative_url(medium_base, transport.base)
        return urllib.unquote(rel_url)

2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	1	# Copyright (C) 2006 Canonical Ltd
	2	#
	3	# This program is free software; you can redistribute it and/or modify
	4	# it under the terms of the GNU General Public License as published by
	5	# the Free Software Foundation; either version 2 of the License, or
	6	# (at your option) any later version.
	7	#
	8	# This program is distributed in the hope that it will be useful,
	9	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	10	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	11	# GNU General Public License for more details.
	12	#
	13	# You should have received a copy of the GNU General Public License
	14	# along with this program; if not, write to the Free Software
	15	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	16
3192.2.2 by Andrew Bennetts Just use urllib.unquote, as suggested by John's review.	17	import urllib
2414.1.1 by Andrew Bennetts Add some unicode-related tests from the hpss branch, and a few other nits (also from the hpss branch).	18	from urlparse import urlparse
	19
2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	20	from bzrlib.smart import protocol
3104.4.2 by Andrew Bennetts All tests passing.	21	from bzrlib import urlutils
2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	22
	23
2414.1.4 by Andrew Bennetts Rename SmartClient to _SmartClient.	24	class _SmartClient(object):
2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	25
3104.4.4 by Andrew Bennetts Rename parameter to _SmartClient.__init__ to be less confusing.	26	def __init__(self, shared_connection):
	27	"""Constructor.
	28
	29	:param shared_connection: a bzrlib.transport._SharedConnection
	30	"""
	31	self._shared_connection = shared_connection
2485.8.54 by Vincent Ladeuil Refactor medium uses by making a distinction betweem shared and real medium.	32
	33	def get_smart_medium(self):
3104.4.4 by Andrew Bennetts Rename parameter to _SmartClient.__init__ to be less confusing.	34	return self._shared_connection.connection
2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	35
	36	def call(self, method, *args):
	37	"""Call a method on the remote server."""
2414.1.2 by Andrew Bennetts Deal with review comments.	38	result, protocol = self.call_expecting_body(method, *args)
2414.1.1 by Andrew Bennetts Add some unicode-related tests from the hpss branch, and a few other nits (also from the hpss branch).	39	protocol.cancel_read_body()
	40	return result
	41
2414.1.2 by Andrew Bennetts Deal with review comments.	42	def call_expecting_body(self, method, *args):
	43	"""Call a method and return the result and the protocol object.
	44
	45	The body can be read like so::
	46
	47	result, smart_protocol = smart_client.call_expecting_body(...)
	48	body = smart_protocol.read_body_bytes()
	49	"""
2485.8.54 by Vincent Ladeuil Refactor medium uses by making a distinction betweem shared and real medium.	50	request = self.get_smart_medium().get_request()
2535.4.2 by Andrew Bennetts Nasty hackery to make stream_knit_data_for_revisions response use streaming.	51	smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	52	smart_protocol.call(method, *args)
2414.1.1 by Andrew Bennetts Add some unicode-related tests from the hpss branch, and a few other nits (also from the hpss branch).	53	return smart_protocol.read_response_tuple(expect_body=True), smart_protocol
2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	54
	55	def call_with_body_bytes(self, method, args, body):
	56	"""Call a method on the remote server with body bytes."""
2018.5.131 by Andrew Bennetts Be strict about unicode passed to transport.put_{bytes,file} and SmartClient.call_with_body_bytes, fixing part of TestLockableFiles_RemoteLockDir.test_read_write.	57	if type(method) is not str:
	58	raise TypeError('method must be a byte string, not %r' % (method,))
	59	for arg in args:
	60	if type(arg) is not str:
	61	raise TypeError('args must be byte strings, not %r' % (args,))
	62	if type(body) is not str:
	63	raise TypeError('body must be byte string, not %r' % (body,))
2485.8.54 by Vincent Ladeuil Refactor medium uses by making a distinction betweem shared and real medium.	64	request = self.get_smart_medium().get_request()
2018.5.26 by Andrew Bennetts Extract a simple SmartClient class from RemoteTransport, and a hack to avoid VFS operations when probing for a bzrdir over a smart transport.	65	smart_protocol = protocol.SmartClientRequestProtocolOne(request)
	66	smart_protocol.call_with_body_bytes((method, ) + args, body)
	67	return smart_protocol.read_response_tuple()
2414.1.1 by Andrew Bennetts Add some unicode-related tests from the hpss branch, and a few other nits (also from the hpss branch).	68
3184.1.10 by Robert Collins Change the smart server verb for Repository.stream_revisions_chunked to use SearchResults as the request mechanism for downloads.	69	def call_with_body_bytes_expecting_body(self, method, args, body):
	70	"""Call a method on the remote server with body bytes."""
	71	if type(method) is not str:
	72	raise TypeError('method must be a byte string, not %r' % (method,))
	73	for arg in args:
	74	if type(arg) is not str:
	75	raise TypeError('args must be byte strings, not %r' % (args,))
	76	if type(body) is not str:
	77	raise TypeError('body must be byte string, not %r' % (body,))
	78	request = self.get_smart_medium().get_request()
	79	smart_protocol = protocol.SmartClientRequestProtocolTwo(request)
	80	smart_protocol.call_with_body_bytes((method, ) + args, body)
	81	return smart_protocol.read_response_tuple(expect_body=True), smart_protocol
	82
2414.1.1 by Andrew Bennetts Add some unicode-related tests from the hpss branch, and a few other nits (also from the hpss branch).	83	def remote_path_from_transport(self, transport):
2414.1.2 by Andrew Bennetts Deal with review comments.	84	"""Convert transport into a path suitable for using in a request.
	85
	86	Note that the resulting remote path doesn't encode the host name or
	87	anything but path, so it is only safe to use it in requests sent over
	88	the medium from the matching transport.
	89	"""
3104.4.4 by Andrew Bennetts Rename parameter to _SmartClient.__init__ to be less confusing.	90	if self._shared_connection.base.startswith('bzr+http://'):
	91	medium_base = self._shared_connection.base
3104.4.2 by Andrew Bennetts All tests passing.	92	else:
3104.4.4 by Andrew Bennetts Rename parameter to _SmartClient.__init__ to be less confusing.	93	medium_base = urlutils.join(self._shared_connection.base, '/')
3104.4.2 by Andrew Bennetts All tests passing.	94
3192.2.1 by Andrew Bennetts Don't transmit URL-escaped relpaths in the smart protocol, which is back to how things worked in bzr 1.1 and earlier.	95	rel_url = urlutils.relative_url(medium_base, transport.base)
3192.2.2 by Andrew Bennetts Just use urllib.unquote, as suggested by John's review.	96	return urllib.unquote(rel_url)