/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/smart/medium.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
21
21
 
22
22
Media carry the bytes of the requests somehow (e.g. via TCP, wrapped in HTTP, or
23
23
over SSH), and pass them to and from the protocol logic.  See the overview in
24
 
bzrlib/transport/smart/__init__.py.
 
24
breezy/transport/smart/__init__.py.
25
25
"""
26
26
 
27
27
from __future__ import absolute_import
31
31
import sys
32
32
import time
33
33
 
34
 
import bzrlib
35
 
from bzrlib.lazy_import import lazy_import
 
34
import breezy
 
35
from ..lazy_import import lazy_import
36
36
lazy_import(globals(), """
37
37
import select
38
38
import socket
39
39
import thread
40
40
import weakref
41
41
 
42
 
from bzrlib import (
 
42
from breezy import (
43
43
    debug,
44
44
    errors,
45
45
    trace,
47
47
    ui,
48
48
    urlutils,
49
49
    )
50
 
from bzrlib.i18n import gettext
51
 
from bzrlib.smart import client, protocol, request, signals, vfs
52
 
from bzrlib.transport import ssh
 
50
from breezy.i18n import gettext
 
51
from breezy.smart import client, protocol, request, signals, vfs
 
52
from breezy.transport import ssh
53
53
""")
54
 
from bzrlib import osutils
 
54
from .. import osutils
55
55
 
56
56
# Throughout this module buffer size parameters are either limited to be at
57
57
# most _MAX_READ_SIZE, or are ignored and _MAX_READ_SIZE is used instead.
233
233
            while not self.finished:
234
234
                server_protocol = self._build_protocol()
235
235
                self._serve_one_request(server_protocol)
236
 
        except errors.ConnectionTimeout, e:
 
236
        except errors.ConnectionTimeout as e:
237
237
            trace.note('%s' % (e,))
238
238
            trace.log_exception_quietly()
239
239
            self._disconnect_client()
240
240
            # We reported it, no reason to make a big fuss.
241
241
            return
242
 
        except Exception, e:
 
242
        except Exception as e:
243
243
            stderr.write("%s terminating on exception %s\n" % (self, e))
244
244
            raise
245
245
        self._disconnect_client()
329
329
            self._serve_one_request_unguarded(protocol)
330
330
        except KeyboardInterrupt:
331
331
            raise
332
 
        except Exception, e:
 
332
        except Exception as e:
333
333
            self.terminate_due_to_error()
334
334
 
335
335
    def terminate_due_to_error(self):
663
663
    """An object that counts the HPSS calls made to each client medium.
664
664
 
665
665
    When a medium is garbage-collected, or failing that when
666
 
    bzrlib.global_state exits, the total number of calls made on that medium
 
666
    breezy.global_state exits, the total number of calls made on that medium
667
667
    are reported via trace.note.
668
668
    """
669
669
 
671
671
        self.counts = weakref.WeakKeyDictionary()
672
672
        client._SmartClient.hooks.install_named_hook(
673
673
            'call', self.increment_call_count, 'hpss call counter')
674
 
        bzrlib.global_state.cleanups.add_cleanup(self.flush_all)
 
674
        breezy.global_state.cleanups.add_cleanup(self.flush_all)
675
675
 
676
676
    def track(self, medium):
677
677
        """Start tracking calls made to a medium.
804
804
                client_protocol = protocol.SmartClientRequestProtocolOne(medium_request)
805
805
                client_protocol.query_version()
806
806
                self._done_hello = True
807
 
            except errors.SmartProtocolError, e:
 
807
            except errors.SmartProtocolError as e:
808
808
                # Cache the error, just like we would cache a successful
809
809
                # result.
810
810
                self._protocol_version_error = e
907
907
        """See SmartClientStreamMedium.accept_bytes."""
908
908
        try:
909
909
            self._writeable_pipe.write(bytes)
910
 
        except IOError, e:
 
910
        except IOError as e:
911
911
            if e.errno in (errno.EINVAL, errno.EPIPE):
912
912
                raise errors.ConnectionReset(
913
913
                    "Error trying to write to subprocess", e)
953
953
 
954
954
        :param ssh_params: A SSHParams instance.
955
955
        :param vendor: An optional override for the ssh vendor to use. See
956
 
            bzrlib.transport.ssh for details on ssh vendors.
 
956
            breezy.transport.ssh for details on ssh vendors.
957
957
        """
958
958
        self._real_medium = None
959
959
        self._ssh_params = ssh_params
1105
1105
        try:
1106
1106
            sockaddrs = socket.getaddrinfo(self._host, port, socket.AF_UNSPEC,
1107
1107
                socket.SOCK_STREAM, 0, 0)
1108
 
        except socket.gaierror, (err_num, err_msg):
 
1108
        except socket.gaierror as xxx_todo_changeme:
 
1109
            (err_num, err_msg) = xxx_todo_changeme.args
1109
1110
            raise errors.ConnectionError("failed to lookup %s:%d: %s" %
1110
1111
                    (self._host, port, err_msg))
1111
1112
        # Initialize err in case there are no addresses returned:
1116
1117
                self._socket.setsockopt(socket.IPPROTO_TCP,
1117
1118
                                        socket.TCP_NODELAY, 1)
1118
1119
                self._socket.connect(sockaddr)
1119
 
            except socket.error, err:
 
1120
            except socket.error as err:
1120
1121
                if self._socket is not None:
1121
1122
                    self._socket.close()
1122
1123
                self._socket = None
1125
1126
        if self._socket is None:
1126
1127
            # socket errors either have a (string) or (errno, string) as their
1127
1128
            # args.
1128
 
            if type(err.args) is str:
 
1129
            if isinstance(err.args, str):
1129
1130
                err_msg = err.args
1130
1131
            else:
1131
1132
                err_msg = err.args[1]