← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/request.py

  • Committer: John Arbash Meinel
  • Author(s): Mark Hammond
  • Date: 2008-09-09 17:02:21 UTC
  • mto: This revision was merged to the branch mainline in revision 3697.
  • Revision ID: john@arbash-meinel.com-20080909170221-svim3jw2mrz0amp3
An updated transparent icon for bzr.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/request.py
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
16
 
17
 
"""Basic server-side logic for dealing with requests."""
18
 
 
 
17
"""Basic server-side logic for dealing with requests.
 
18
 
 
19
**XXX**:
 
20
 
 
21
The class names are a little confusing: the protocol will instantiate a
 
22
SmartServerRequestHandler, whose dispatch_command method creates an instance of
 
23
a SmartServerRequest subclass.
 
24
 
 
25
The request_handlers registry tracks SmartServerRequest classes (rather than
 
26
SmartServerRequestHandler).
 
27
"""
19
28
 
20
29
import tempfile
21
30
 
24
33
    errors,
25
34
    registry,
26
35
    revision,
 
36
    urlutils,
27
37
    )
28
38
from bzrlib.bundle.serializer import write_bundle
29
39
 
30
40
 
31
41
class SmartServerRequest(object):
32
 
    """Base class for request handlers."""
 
42
    """Base class for request handlers.
 
43
    
 
44
    To define a new request, subclass this class and override the `do` method
 
45
    (and if appropriate, `do_body` as well).  Request implementors should take
 
46
    care to call `translate_client_path` and `transport_from_client_path` as
 
47
    appropriate when dealing with paths received from the client.
 
48
    """
 
49
    # XXX: rename this class to BaseSmartServerRequestHandler ?  A request
 
50
    # *handler* is a different concept to the request.
33
51
 
34
 
    def __init__(self, backing_transport):
 
52
    def __init__(self, backing_transport, root_client_path='/'):
35
53
        """Constructor.
36
54
 
37
55
        :param backing_transport: the base transport to be used when performing
38
56
            this request.
 
57
        :param root_client_path: the client path that maps to the root of
 
58
            backing_transport.  This is used to interpret relpaths received
 
59
            from the client.  Clients will not be able to refer to paths above
 
60
            this root.  If root_client_path is None, then no translation will
 
61
            be performed on client paths.  Default is '/'.
39
62
        """
40
63
        self._backing_transport = backing_transport
 
64
        if root_client_path is not None:
 
65
            if not root_client_path.startswith('/'):
 
66
                root_client_path = '/' + root_client_path
 
67
            if not root_client_path.endswith('/'):
 
68
                root_client_path += '/'
 
69
        self._root_client_path = root_client_path
41
70
 
42
71
    def _check_enabled(self):
43
72
        """Raises DisabledMethod if this method is disabled."""
66
95
 
67
96
    def do_body(self, body_bytes):
68
97
        """Called if the client sends a body with the request.
 
98
 
 
99
        The do() method is still called, and must have returned None.
69
100
        
70
101
        Must return a SmartServerResponse.
71
102
        """
72
 
        # TODO: if a client erroneously sends a request that shouldn't have a
73
 
        # body, what to do?  Probably SmartServerRequestHandler should catch
74
 
        # this NotImplementedError and translate it into a 'bad request' error
75
 
        # to send to the client.
76
103
        raise NotImplementedError(self.do_body)
77
104
 
 
105
    def do_chunk(self, chunk_bytes):
 
106
        """Called with each body chunk if the request has a streamed body.
 
107
 
 
108
        The do() method is still called, and must have returned None.
 
109
        """
 
110
        raise NotImplementedError(self.do_chunk)
 
111
 
 
112
    def do_end(self):
 
113
        """Called when the end of the request has been received."""
 
114
        pass
 
115
    
 
116
    def translate_client_path(self, client_path):
 
117
        """Translate a path received from a network client into a local
 
118
        relpath.
 
119
 
 
120
        All paths received from the client *must* be translated.
 
121
 
 
122
        :param client_path: the path from the client.
 
123
        :returns: a relpath that may be used with self._backing_transport
 
124
            (unlike the untranslated client_path, which must not be used with
 
125
            the backing transport).
 
126
        """
 
127
        if self._root_client_path is None:
 
128
            # no translation necessary!
 
129
            return client_path
 
130
        if not client_path.startswith('/'):
 
131
            client_path = '/' + client_path
 
132
        if client_path.startswith(self._root_client_path):
 
133
            path = client_path[len(self._root_client_path):]
 
134
            relpath = urlutils.joinpath('/', path)
 
135
            if not relpath.startswith('/'):
 
136
                raise ValueError(relpath)
 
137
            return '.' + relpath
 
138
        else:
 
139
            raise errors.PathNotChild(client_path, self._root_client_path)
 
140
 
 
141
    def transport_from_client_path(self, client_path):
 
142
        """Get a backing transport corresponding to the location referred to by
 
143
        a network client.
 
144
 
 
145
        :seealso: translate_client_path
 
146
        :returns: a transport cloned from self._backing_transport
 
147
        """
 
148
        relpath = self.translate_client_path(client_path)
 
149
        return self._backing_transport.clone(relpath)
 
150
 
78
151
 
79
152
class SmartServerResponse(object):
80
153
    """A response to a client request.
83
156
    SuccessfulSmartServerResponse and FailedSmartServerResponse as appropriate.
84
157
    """
85
158
 
86
 
    def __init__(self, args, body=None):
 
159
    def __init__(self, args, body=None, body_stream=None):
 
160
        """Constructor.
 
161
 
 
162
        :param args: tuple of response arguments.
 
163
        :param body: string of a response body.
 
164
        :param body_stream: iterable of bytestrings to be streamed to the
 
165
            client.
 
166
        """
87
167
        self.args = args
 
168
        if body is not None and body_stream is not None:
 
169
            raise errors.BzrError(
 
170
                "'body' and 'body_stream' are mutually exclusive.")
88
171
        self.body = body
 
172
        self.body_stream = body_stream
89
173
 
90
174
    def __eq__(self, other):
91
175
        if other is None:
92
176
            return False
93
 
        return other.args == self.args and other.body == self.body
 
177
        return (other.args == self.args and
 
178
                other.body == self.body and
 
179
                other.body_stream is self.body_stream)
94
180
 
95
181
    def __repr__(self):
96
 
        return "<SmartServerResponse args=%r body=%r>" % (
 
182
        status = {True: 'OK', False: 'ERR'}[self.is_successful()]
 
183
        return "<SmartServerResponse status=%s args=%r body=%r>" % (status,
97
184
            self.args, self.body)
98
185
 
99
186
 
130
217
    # TODO: Better way of representing the body for commands that take it,
131
218
    # and allow it to be streamed into the server.
132
219
 
133
 
    def __init__(self, backing_transport, commands):
 
220
    def __init__(self, backing_transport, commands, root_client_path):
134
221
        """Constructor.
135
222
 
136
223
        :param backing_transport: a Transport to handle requests for.
138
225
            subclasses. e.g. bzrlib.transport.smart.vfs.vfs_commands.
139
226
        """
140
227
        self._backing_transport = backing_transport
 
228
        self._root_client_path = root_client_path
141
229
        self._commands = commands
142
230
        self._body_bytes = ''
143
231
        self.response = None
166
254
        try:
167
255
            command = self._commands.get(cmd)
168
256
        except LookupError:
169
 
            raise errors.SmartProtocolError("bad request %r" % (cmd,))
170
 
        self._command = command(self._backing_transport)
 
257
            raise errors.UnknownSmartMethod(cmd)
 
258
        self._command = command(self._backing_transport, self._root_client_path)
171
259
        self._run_handler_code(self._command.execute, args, {})
172
260
 
173
261
    def _run_handler_code(self, callable, args, kwargs):
219
307
            else:
220
308
                raise
221
309
 
 
310
    def headers_received(self, headers):
 
311
        # Just a no-op at the moment.
 
312
        pass
 
313
 
 
314
    def args_received(self, args):
 
315
        cmd = args[0]
 
316
        args = args[1:]
 
317
        try:
 
318
            command = self._commands.get(cmd)
 
319
        except LookupError:
 
320
            raise errors.UnknownSmartMethod(cmd)
 
321
        self._command = command(self._backing_transport)
 
322
        self._run_handler_code(self._command.execute, args, {})
 
323
 
 
324
    def prefixed_body_received(self, body_bytes):
 
325
        """No more body data will be received."""
 
326
        self._run_handler_code(self._command.do_body, (body_bytes,), {})
 
327
        # cannot read after this.
 
328
        self.finished_reading = True
 
329
 
 
330
    def body_chunk_received(self, chunk_bytes):
 
331
        self._run_handler_code(self._command.do_chunk, (chunk_bytes,), {})
 
332
 
 
333
    def end_received(self):
 
334
        self._run_handler_code(self._command.do_end, (), {})
 
335
 
222
336
 
223
337
class HelloRequest(SmartServerRequest):
224
338
    """Answer a version request with the highest protocol version this server
234
348
 
235
349
    def do(self, path, revision_id):
236
350
        # open transport relative to our base
237
 
        t = self._backing_transport.clone(path)
 
351
        t = self.transport_from_client_path(path)
238
352
        control, extra_path = bzrdir.BzrDir.open_containing_from_transport(t)
239
353
        repo = control.open_repository()
240
354
        tmpf = tempfile.TemporaryFile()
269
383
request_handlers.register_lazy(
270
384
    'Branch.set_last_revision', 'bzrlib.smart.branch', 'SmartServerBranchRequestSetLastRevision')
271
385
request_handlers.register_lazy(
 
386
    'Branch.set_last_revision_info', 'bzrlib.smart.branch',
 
387
    'SmartServerBranchRequestSetLastRevisionInfo')
 
388
request_handlers.register_lazy(
 
389
    'Branch.set_last_revision_ex', 'bzrlib.smart.branch',
 
390
    'SmartServerBranchRequestSetLastRevisionEx')
 
391
request_handlers.register_lazy(
272
392
    'Branch.unlock', 'bzrlib.smart.branch', 'SmartServerBranchRequestUnlock')
273
393
request_handlers.register_lazy(
274
 
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepository')
 
394
    'BzrDir.find_repository', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepositoryV1')
 
395
request_handlers.register_lazy(
 
396
    'BzrDir.find_repositoryV2', 'bzrlib.smart.bzrdir', 'SmartServerRequestFindRepositoryV2')
275
397
request_handlers.register_lazy(
276
398
    'BzrDirFormat.initialize', 'bzrlib.smart.bzrdir', 'SmartServerRequestInitializeBzrDir')
277
399
request_handlers.register_lazy(
305
427
request_handlers.register_lazy('Repository.gather_stats',
306
428
                               'bzrlib.smart.repository',
307
429
                               'SmartServerRepositoryGatherStats')
308
 
request_handlers.register_lazy(
309
 
    'Repository.stream_knit_data_for_revisions', 'bzrlib.smart.repository',
310
 
    'SmartServerRepositoryStreamKnitDataForRevisions')
 
430
request_handlers.register_lazy('Repository.get_parent_map',
 
431
                               'bzrlib.smart.repository',
 
432
                               'SmartServerRepositoryGetParentMap')
311
433
request_handlers.register_lazy(
312
434
    'Repository.get_revision_graph', 'bzrlib.smart.repository', 'SmartServerRepositoryGetRevisionGraph')
313
435
request_handlers.register_lazy(