/brz/remove-bazaar

# Copyright (C) 2006-2011 Canonical Ltd

breezy/transport/smart/__init__.py.

from __future__ import absolute_import

 

import errno

import io

import time

import breezy

from ...lazy_import import lazy_import

import select

from breezy import (

    transport,

from breezy.i18n import gettext

from breezy.bzr.smart import client, protocol, request, signals, vfs

from breezy.transport import ssh

from ... import (

    errors,

    osutils,

    )

 

class HpssVfsRequestNotAllowed(errors.BzrError):

 

    _fmt = ("VFS requests over the smart server are not allowed. Encountered: "

            "%(method)s, %(arguments)s.")

 

    def __init__(self, method, arguments):

        self.method = method

        self.arguments = arguments

 

 

    bytes = b''

        if new_bytes == b'':

            return bytes, b''

        newline_pos = bytes.find(b'\n')

    line = bytes[:newline_pos + 1]

    excess = bytes[newline_pos + 1:]

    def _push_back(self, data):

        if not isinstance(data, bytes):

            raise TypeError(data)

        if data == b'':

        self._push_back_buffer = data

        if self._push_back_buffer == b'':

_bad_file_descriptor = (errno.EBADF,)

if sys.platform == 'win32':

    # Given on Windows if you pass a closed socket to select.select. Probably

    # also given if you pass a file handle to select.

    WSAENOTSOCK = 10038

    _bad_file_descriptor += (WSAENOTSOCK,)

 

 

    _timer = time.time

 

    def __init__(self, backing_transport, root_client_path='/', timeout=None):

        if timeout is None:

            raise AssertionError('You must supply a timeout.')

        self._client_timeout = timeout

        self._client_poll_timeout = min(timeout / 10.0, 1.0)

        except errors.ConnectionTimeout as e:

            trace.note('%s' % (e,))

            trace.log_exception_quietly()

            self._disconnect_client()

            # We reported it, no reason to make a big fuss.

            return

        except Exception as e:

        self._disconnect_client()

 

    def _stop_gracefully(self):

        """When we finish this message, stop looking for more."""

        trace.mutter('Stopping %s' % (self,))

        self.finished = True

 

    def _disconnect_client(self):

        """Close the current connection. We stopped due to a timeout/etc."""

        # The default implementation is a no-op, because that is all we used to

        # do when disconnecting from a client. I suppose we never had the

        # *server* initiate a disconnect, before

 

    def _wait_for_bytes_with_timeout(self, timeout_seconds):

        """Wait for more bytes to be read, but timeout if none available.

 

        This allows us to detect idle connections, and stop trying to read from

        them, without setting the socket itself to non-blocking. This also

        allows us to specify when we watch for idle timeouts.

 

        :return: Did we timeout? (True if we timed out, False if there is data

            to be read)

        """

        raise NotImplementedError(self._wait_for_bytes_with_timeout)

        self._wait_for_bytes_with_timeout(self._client_timeout)

        if self.finished:

            # We're stopping, so don't try to do any more work

            return None

    def _wait_on_descriptor(self, fd, timeout_seconds):

        """select() on a file descriptor, waiting for nonblocking read()

 

        This will raise a ConnectionTimeout exception if we do not get a

        readable handle before timeout_seconds.

        :return: None

        """

        t_end = self._timer() + timeout_seconds

        poll_timeout = min(timeout_seconds, self._client_poll_timeout)

        rs = xs = None

        while not rs and not xs and self._timer() < t_end:

            if self.finished:

                return

            try:

                rs, _, xs = select.select([fd], [], [fd], poll_timeout)

            except (select.error, socket.error) as e:

                err = getattr(e, 'errno', None)

                if err is None and getattr(e, 'args', None) is not None:

                    # select.error doesn't have 'errno', it just has args[0]

                    err = e.args[0]

                if err in _bad_file_descriptor:

                    return  # Not a socket indicates read() will fail

                elif err == errno.EINTR:

                    # Interrupted, keep looping.

                    continue

                raise

            except ValueError:

                return  # Socket may already be closed

        if rs or xs:

            return

        raise errors.ConnectionTimeout('disconnecting client after %.1f seconds'

                                       % (timeout_seconds,))

 

        if protocol is None:

            return

        except Exception as e:

    def __init__(self, sock, backing_transport, root_client_path='/',

                 timeout=None):

            self, backing_transport, root_client_path=root_client_path,

            timeout=timeout)

        # Get the getpeername now, as we might be closed later when we care.

        try:

            self._client_info = sock.getpeername()

        except socket.error:

            self._client_info = '<unknown>'

 

    def __str__(self):

        return '%s(client=%s)' % (self.__class__.__name__, self._client_info)

 

    def __repr__(self):

        return '%s.%s(client=%s)' % (self.__module__, self.__class__.__name__,

                                     self._client_info)

            if bytes == b'':

    def _disconnect_client(self):

        """Close the current connection. We stopped due to a timeout/etc."""

        self.socket.close()

 

    def _wait_for_bytes_with_timeout(self, timeout_seconds):

        """Wait for more bytes to be read, but timeout if none available.

 

        This allows us to detect idle connections, and stop trying to read from

        them, without setting the socket itself to non-blocking. This also

        allows us to specify when we watch for idle timeouts.

 

        :return: None, this will raise ConnectionTimeout if we time out before

            data is available.

        """

        return self._wait_on_descriptor(self.socket, timeout_seconds)

 

    def __init__(self, in_file, out_file, backing_transport, timeout=None):

        SmartServerStreamMedium.__init__(self, backing_transport,

                                         timeout=timeout)

    def serve(self):

        """See SmartServerStreamMedium.serve"""

        # This is the regular serve, except it adds signal trapping for soft

        # shutdown.

        stop_gracefully = self._stop_gracefully

        signals.register_on_hangup(id(self), stop_gracefully)

        try:

            return super(SmartServerPipeStreamMedium, self).serve()

        finally:

            signals.unregister_on_hangup(id(self))

 

            if bytes == b'':

    def _disconnect_client(self):

        self._in.close()

        self._out.flush()

        self._out.close()

 

    def _wait_for_bytes_with_timeout(self, timeout_seconds):

        """Wait for more bytes to be read, but timeout if none available.

 

        This allows us to detect idle connections, and stop trying to read from

        them, without setting the socket itself to non-blocking. This also

        allows us to specify when we watch for idle timeouts.

 

        :return: None, this will raise ConnectionTimeout if we time out before

            data is available.

        """

        if (getattr(self._in, 'fileno', None) is None

                or sys.platform == 'win32'):

            # You can't select() file descriptors on Windows.

            return

        try:

            return self._wait_on_descriptor(self._in, timeout_seconds)

        except io.UnsupportedOperation:

            return

 

        if not line.endswith(b'\n'):

class _VfsRefuser(object):

    """An object that refuses all VFS requests.

 

    """

 

    def __init__(self):

        client._SmartClient.hooks.install_named_hook(

            'call', self.check_vfs, 'vfs refuser')

 

    def check_vfs(self, params):

        try:

            request_method = request.request_handlers.get(params.method)

        except KeyError:

            # A method we don't know about doesn't count as a VFS method.

            return

        if issubclass(request_method, vfs.VfsRequest):

            raise HpssVfsRequestNotAllowed(params.method, params.args)

 

 

    When a medium is garbage-collected, or failing that when

    breezy.global_state exits, the total number of calls made on that medium

    are reported via trace.note.

        breezy.get_global_state().cleanups.add_cleanup(self.flush_all)

            trace.note(gettext('HPSS calls: {0} ({1} vfs) {2}').format(

                       count, vfs_count, medium_repr))

 

_vfs_refuser = None

        if 'hpss_client_no_vfs' in debug.debug_flags:

            global _vfs_refuser

            if _vfs_refuser is None:

                _vfs_refuser = _VfsRefuser()

                version_tuple > self._remote_version_is_before):

                "_remember_remote_is_before(%r) was called previously.", version_tuple, self._remote_version_is_before)

                client_protocol = protocol.SmartClientRequestProtocolOne(

                    medium_request)

            except errors.SmartProtocolError as e:

        return urlutils.unquote(rel_url)

    def reset(self):

        """We have been disconnected, reset current state.

 

        This resets things like _current_request and connected state.

        """

        self.disconnect()

        self._current_request = None

 

    def _accept_bytes(self, data):

        try:

            self._writeable_pipe.write(data)

        except IOError as e:

            if e.errno in (errno.EINVAL, errno.EPIPE):

                raise errors.ConnectionReset(

                    "Error trying to write to subprocess", e)

            raise

        self._report_activity(len(data), 'write')

        # Note: If flush were to fail, we'd like to raise ConnectionReset, etc.

        #       However, testing shows that even when the child process is

        #       gone, this doesn't error.

        bytes_to_read = min(count, _MAX_READ_SIZE)

        data = self._readable_pipe.read(bytes_to_read)

        self._report_activity(len(data), 'read')

        return data

 

 

class SSHParams(object):

    """A set of parameters for starting a remote bzr via SSH."""

                 bzr_remote_path='bzr'):

        self.host = host

        self.port = port

        self.username = username

        self.password = password

        self.bzr_remote_path = bzr_remote_path

 

 

class SmartSSHClientMedium(SmartClientStreamMedium):

    """A client medium using SSH.

 

    It delegates IO to a SmartSimplePipesClientMedium or

    SmartClientAlreadyConnectedSocketMedium (depending on platform).

    """

 

    def __init__(self, base, ssh_params, vendor=None):

        :param ssh_params: A SSHParams instance.

            breezy.transport.ssh for details on ssh vendors.