/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/transport/log.py

  • Committer: Gustav Hartvigsson
  • Date: 2021-01-09 21:36:27 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210109213627-h1xwcutzy9m7a99b
Added 'Case Preserving Working Tree Use Cases' from Canonical Wiki

* Addod a page from the Canonical Bazaar wiki
  with information on the scmeatics of case
  perserving filesystems an a case insensitive
  filesystem works.
  
  * Needs re-work, but this will do as it is the
    same inforamoton as what was on the linked
    page in the currint documentation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/transport/log.py
 
1
# Copyright (C) 2008, 2009, 2010 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Transport decorator that logs transport operations to brz.log."""
 
18
 
 
19
# see also the transportstats plugin, which gives you some summary information
 
20
# in a machine-readable dump
 
21
 
 
22
import time
 
23
import types
 
24
 
 
25
from ..trace import mutter
 
26
from ..transport import decorator
 
27
 
 
28
 
 
29
class TransportLogDecorator(decorator.TransportDecorator):
 
30
    """Decorator for Transports that logs interesting operations to brz.log.
 
31
 
 
32
    In general we want to log things that usually take a network round trip
 
33
    and may be slow.
 
34
 
 
35
    Not all operations are logged yet.
 
36
 
 
37
    See also TransportTraceDecorator, that records a machine-readable log in
 
38
    memory for eg testing.
 
39
    """
 
40
 
 
41
    def __init__(self, *args, **kw):
 
42
        super(TransportLogDecorator, self).__init__(*args, **kw)
 
43
 
 
44
        def _make_hook(hookname):
 
45
            def _hook(relpath, *args, **kw):
 
46
                return self._log_and_call(hookname, relpath, *args, **kw)
 
47
            return _hook
 
48
        # GZ 2017-05-21: Not all methods take relpath as first argument, for
 
49
        # instance copy_to takes list of relpaths. Also, unclear on url vs
 
50
        # filesystem path split. Needs tidying up.
 
51
        for methodname in (
 
52
                'append_bytes',
 
53
                'append_file',
 
54
                'copy_to',
 
55
                'delete',
 
56
                'get',
 
57
                'has',
 
58
                'open_write_stream',
 
59
                'mkdir',
 
60
                'move',
 
61
                'put_bytes', 'put_bytes_non_atomic', 'put_file put_file_non_atomic',
 
62
                'list_dir', 'lock_read', 'lock_write',
 
63
                'readv', 'rename', 'rmdir',
 
64
                'stat',
 
65
                'ulock',
 
66
                ):
 
67
            setattr(self, methodname, _make_hook(methodname))
 
68
 
 
69
    @classmethod
 
70
    def _get_url_prefix(self):
 
71
        return 'log+'
 
72
 
 
73
    def iter_files_recursive(self):
 
74
        # needs special handling because it does not have a relpath parameter
 
75
        mutter("%s %s"
 
76
               % ('iter_files_recursive', self._decorated.base))
 
77
        return self._call_and_log_result('iter_files_recursive', (), {})
 
78
 
 
79
    def _log_and_call(self, methodname, relpath, *args, **kwargs):
 
80
        if kwargs:
 
81
            kwargs_str = dict(kwargs)
 
82
        else:
 
83
            kwargs_str = ''
 
84
        mutter("%s %s %s %s"
 
85
               % (methodname, relpath,
 
86
                  self._shorten(self._strip_tuple_parens(args)),
 
87
                  kwargs_str))
 
88
        return self._call_and_log_result(methodname, (relpath,) + args, kwargs)
 
89
 
 
90
    def _call_and_log_result(self, methodname, args, kwargs):
 
91
        before = time.time()
 
92
        try:
 
93
            result = getattr(self._decorated, methodname)(*args, **kwargs)
 
94
        except Exception as e:
 
95
            mutter("  --> %s" % e)
 
96
            mutter("      %.03fs" % (time.time() - before))
 
97
            raise
 
98
        return self._show_result(before, methodname, result)
 
99
 
 
100
    def _show_result(self, before, methodname, result):
 
101
        result_len = None
 
102
        if isinstance(result, types.GeneratorType):
 
103
            # We now consume everything from the generator so that we can show
 
104
            # the results and the time it took to get them.  However, to keep
 
105
            # compatibility with callers that may specifically expect a result
 
106
            # (see <https://launchpad.net/bugs/340347>) we also return a new
 
107
            # generator, reset to the starting position.
 
108
            result = list(result)
 
109
            return_result = iter(result)
 
110
        else:
 
111
            return_result = result
 
112
        # Is this an io object with a getvalue() method?
 
113
        getvalue = getattr(result, 'getvalue', None)
 
114
        if getvalue is not None:
 
115
            val = repr(getvalue())
 
116
            result_len = len(val)
 
117
            shown_result = "%s(%s) (%d bytes)" % (result.__class__.__name__,
 
118
                                                  self._shorten(val), result_len)
 
119
        elif methodname == 'readv':
 
120
            num_hunks = len(result)
 
121
            total_bytes = sum((len(d) for o, d in result))
 
122
            shown_result = "readv response, %d hunks, %d total bytes" % (
 
123
                num_hunks, total_bytes)
 
124
            result_len = total_bytes
 
125
        else:
 
126
            shown_result = self._shorten(self._strip_tuple_parens(result))
 
127
        mutter("  --> %s" % shown_result)
 
128
        # The log decorator no longer shows the elapsed time or transfer rate
 
129
        # because they're available in the log prefixes and the transport
 
130
        # activity display respectively.
 
131
        if False:
 
132
            elapsed = time.time() - before
 
133
            if result_len and elapsed > 0:
 
134
                # this is the rate of higher-level data, not the raw network
 
135
                # speed using base-10 units (see HACKING.txt).
 
136
                mutter("      %9.03fs %8dkB/s"
 
137
                       % (elapsed, result_len / elapsed / 1000))
 
138
            else:
 
139
                mutter("      %9.03fs" % (elapsed))
 
140
        return return_result
 
141
 
 
142
    def _shorten(self, x):
 
143
        if len(x) > 70:
 
144
            x = x[:67] + '...'
 
145
        return x
 
146
 
 
147
    def _strip_tuple_parens(self, t):
 
148
        t = repr(t)
 
149
        if t[0] == '(' and t[-1] == ')':
 
150
            t = t[1:-1]
 
151
        return t
 
152
 
 
153
 
 
154
def get_test_permutations():
 
155
    """Return the permutations to be used in testing."""
 
156
    from ..tests import test_server
 
157
    return [(TransportLogDecorator, test_server.LogDecoratorServer)]