← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/server.py

  • Committer: Patch Queue Manager
  • Date: 2011-09-22 13:22:18 UTC
  • mfrom: (6155.2.2 migrate-config-options)
  • Revision ID: pqm@pqm.ubuntu.com-20110922132218-nitl31j5slbcmnm2
(vila) Migrate dpush_strict,
 push_strict and send_strict options to the stack based config design,
 introducing get_config_stack for branches (Vincent Ladeuil)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/server.py
1
 
# Copyright (C) 2006, 2007, 2008 Canonical Ltd
 
1
# Copyright (C) 2006-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
17
"""Server for smart-server protocol."""
18
18
 
19
19
import errno
 
20
import os.path
20
21
import socket
21
22
import sys
22
23
import threading
23
24
 
24
 
from bzrlib.hooks import HookPoint, Hooks
 
25
from bzrlib.hooks import Hooks
25
26
from bzrlib import (
26
27
    errors,
27
28
    trace,
28
 
    transport,
 
29
    transport as _mod_transport,
29
30
)
 
31
from bzrlib.i18n import gettext
30
32
from bzrlib.lazy_import import lazy_import
31
33
lazy_import(globals(), """
32
34
from bzrlib.smart import medium
 
35
from bzrlib.transport import (
 
36
    chroot,
 
37
    pathfilter,
 
38
    )
 
39
from bzrlib import (
 
40
    urlutils,
 
41
    )
33
42
""")
34
43
 
35
44
 
42
51
    hooks: An instance of SmartServerHooks.
43
52
    """
44
53
 
45
 
    def __init__(self, backing_transport, host='127.0.0.1', port=0,
46
 
                 root_client_path='/'):
 
54
    def __init__(self, backing_transport, root_client_path='/'):
47
55
        """Construct a new server.
48
56
 
49
57
        To actually start it running, call either start_background_thread or
50
58
        serve.
51
59
 
52
60
        :param backing_transport: The transport to serve.
 
61
        :param root_client_path: The client path that will correspond to root
 
62
            of backing_transport.
 
63
        """
 
64
        self.backing_transport = backing_transport
 
65
        self.root_client_path = root_client_path
 
66
 
 
67
    def start_server(self, host, port):
 
68
        """Create the server listening socket.
 
69
 
53
70
        :param host: Name of the interface to listen on.
54
71
        :param port: TCP port to listen on, or 0 to allocate a transient port.
55
 
        :param root_client_path: The client path that will correspond to root
56
 
            of backing_transport.
57
72
        """
58
73
        # let connections timeout so that we get a chance to terminate
59
74
        # Keep a reference to the exceptions we want to catch because the socket
80
95
        self.port = self._sockname[1]
81
96
        self._server_socket.listen(1)
82
97
        self._server_socket.settimeout(1)
83
 
        self.backing_transport = backing_transport
84
98
        self._started = threading.Event()
85
99
        self._stopped = threading.Event()
86
 
        self.root_client_path = root_client_path
87
100
 
88
 
    def serve(self, thread_name_suffix=''):
89
 
        self._should_terminate = False
90
 
        # for hooks we are letting code know that a server has started (and
91
 
        # later stopped).
 
101
    def _backing_urls(self):
92
102
        # There are three interesting urls:
93
103
        # The URL the server can be contacted on. (e.g. bzr://host/)
94
104
        # The URL that a commit done on the same machine as the server will
95
105
        # have within the servers space. (e.g. file:///home/user/source)
96
106
        # The URL that will be given to other hooks in the same process -
97
 
        # the URL of the backing transport itself. (e.g. chroot+:///)
 
107
        # the URL of the backing transport itself. (e.g. filtered-36195:///)
98
108
        # We need all three because:
99
109
        #  * other machines see the first
100
110
        #  * local commits on this machine should be able to be mapped to
104
114
        # The latter two urls are different aliases to the servers url,
105
115
        # so we group those in a list - as there might be more aliases
106
116
        # in the future.
107
 
        backing_urls = [self.backing_transport.base]
 
117
        urls = [self.backing_transport.base]
108
118
        try:
109
 
            backing_urls.append(self.backing_transport.external_url())
 
119
            urls.append(self.backing_transport.external_url())
110
120
        except errors.InProcessTransport:
111
121
            pass
 
122
        return urls
 
123
 
 
124
    def run_server_started_hooks(self, backing_urls=None):
 
125
        if backing_urls is None:
 
126
            backing_urls = self._backing_urls()
112
127
        for hook in SmartTCPServer.hooks['server_started']:
113
128
            hook(backing_urls, self.get_url())
 
129
        for hook in SmartTCPServer.hooks['server_started_ex']:
 
130
            hook(backing_urls, self)
 
131
 
 
132
    def run_server_stopped_hooks(self, backing_urls=None):
 
133
        if backing_urls is None:
 
134
            backing_urls = self._backing_urls()
 
135
        for hook in SmartTCPServer.hooks['server_stopped']:
 
136
            hook(backing_urls, self.get_url())
 
137
 
 
138
    def serve(self, thread_name_suffix=''):
 
139
        self._should_terminate = False
 
140
        # for hooks we are letting code know that a server has started (and
 
141
        # later stopped).
 
142
        self.run_server_started_hooks()
114
143
        self._started.set()
115
144
        try:
116
145
            try:
127
156
                        if e.args[0] != errno.EBADF:
128
157
                            trace.warning("listening socket error: %s", e)
129
158
                    else:
 
159
                        if self._should_terminate:
 
160
                            break
130
161
                        self.serve_conn(conn, thread_name_suffix)
131
162
            except KeyboardInterrupt:
132
163
                # dont log when CTRL-C'd.
133
164
                raise
134
165
            except Exception, e:
135
 
                trace.error("Unhandled smart server error.")
136
 
                trace.log_exception_quietly()
 
166
                trace.report_exception(sys.exc_info(), sys.stderr)
137
167
                raise
138
168
        finally:
139
169
            self._stopped.set()
143
173
            except self._socket_error:
144
174
                # ignore errors on close
145
175
                pass
146
 
            for hook in SmartTCPServer.hooks['server_stopped']:
147
 
                hook(backing_urls, self.get_url())
 
176
            self.run_server_stopped_hooks()
148
177
 
149
178
    def get_url(self):
150
179
        """Return the url of the server"""
151
 
        return "bzr://%s:%d/" % self._sockname
 
180
        return "bzr://%s:%s/" % (self._sockname[0], self._sockname[1])
152
181
 
153
182
    def serve_conn(self, conn, thread_name_suffix):
154
183
        # For WIN32, where the timeout value from the listening socket
155
 
        # propogates to the newly accepted socket.
 
184
        # propagates to the newly accepted socket.
156
185
        conn.setblocking(True)
157
186
        conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
158
187
        handler = medium.SmartServerSocketStreamMedium(
160
189
        thread_name = 'smart-server-child' + thread_name_suffix
161
190
        connection_thread = threading.Thread(
162
191
            None, handler.serve, name=thread_name)
 
192
        # FIXME: This thread is never joined, it should at least be collected
 
193
        # somewhere so that tests that want to check for leaked threads can get
 
194
        # rid of them -- vila 20100531
163
195
        connection_thread.setDaemon(True)
164
196
        connection_thread.start()
 
197
        return connection_thread
165
198
 
166
199
    def start_background_thread(self, thread_name_suffix=''):
167
200
        self._started.clear()
207
240
        These are all empty initially, because by default nothing should get
208
241
        notified.
209
242
        """
210
 
        Hooks.__init__(self)
211
 
        self.create_hook(HookPoint('server_started',
 
243
        Hooks.__init__(self, "bzrlib.smart.server", "SmartTCPServer.hooks")
 
244
        self.add_hook('server_started',
212
245
            "Called by the bzr server when it starts serving a directory. "
213
246
            "server_started is called with (backing urls, public url), "
214
247
            "where backing_url is a list of URLs giving the "
215
248
            "server-specific directory locations, and public_url is the "
216
 
            "public URL for the directory being served.", (0, 16), None))
217
 
        self.create_hook(HookPoint('server_stopped',
 
249
            "public URL for the directory being served.", (0, 16))
 
250
        self.add_hook('server_started_ex',
 
251
            "Called by the bzr server when it starts serving a directory. "
 
252
            "server_started is called with (backing_urls, server_obj).",
 
253
            (1, 17))
 
254
        self.add_hook('server_stopped',
218
255
            "Called by the bzr server when it stops serving a directory. "
219
256
            "server_stopped is called with the same parameters as the "
220
 
            "server_started hook: (backing_urls, public_url).", (0, 16), None))
 
257
            "server_started hook: (backing_urls, public_url).", (0, 16))
 
258
        self.add_hook('server_exception',
 
259
            "Called by the bzr server when an exception occurs. "
 
260
            "server_exception is called with the sys.exc_info() tuple "
 
261
            "return true for the hook if the exception has been handled, "
 
262
            "in which case the server will exit normally.", (2, 4))
221
263
 
222
264
SmartTCPServer.hooks = SmartServerHooks()
223
265
 
224
266
 
225
 
class SmartTCPServer_for_testing(SmartTCPServer):
226
 
    """Server suitable for use by transport tests.
227
 
 
228
 
    This server is backed by the process's cwd.
 
267
def _local_path_for_transport(transport):
 
268
    """Return a local path for transport, if reasonably possible.
 
269
    
 
270
    This function works even if transport's url has a "readonly+" prefix,
 
271
    unlike local_path_from_url.
 
272
    
 
273
    This essentially recovers the --directory argument the user passed to "bzr
 
274
    serve" from the transport passed to serve_bzr.
229
275
    """
230
 
 
231
 
    def __init__(self, thread_name_suffix=''):
232
 
        SmartTCPServer.__init__(self, None)
233
 
        self.client_path_extra = None
234
 
        self.thread_name_suffix = thread_name_suffix
235
 
 
236
 
    def get_backing_transport(self, backing_transport_server):
237
 
        """Get a backing transport from a server we are decorating."""
238
 
        return transport.get_transport(backing_transport_server.get_url())
239
 
 
240
 
    def setUp(self, backing_transport_server=None,
241
 
              client_path_extra='/extra/'):
242
 
        """Set up server for testing.
243
 
 
244
 
        :param backing_transport_server: backing server to use.  If not
245
 
            specified, a LocalURLServer at the current working directory will
246
 
            be used.
247
 
        :param client_path_extra: a path segment starting with '/' to append to
248
 
            the root URL for this server.  For instance, a value of '/foo/bar/'
249
 
            will mean the root of the backing transport will be published at a
250
 
            URL like `bzr://127.0.0.1:nnnn/foo/bar/`, rather than
251
 
            `bzr://127.0.0.1:nnnn/`.  Default value is `extra`, so that tests
252
 
            by default will fail unless they do the necessary path translation.
 
276
    try:
 
277
        base_url = transport.external_url()
 
278
    except (errors.InProcessTransport, NotImplementedError):
 
279
        return None
 
280
    else:
 
281
        # Strip readonly prefix
 
282
        if base_url.startswith('readonly+'):
 
283
            base_url = base_url[len('readonly+'):]
 
284
        try:
 
285
            return urlutils.local_path_from_url(base_url)
 
286
        except errors.InvalidURL:
 
287
            return None
 
288
 
 
289
 
 
290
class BzrServerFactory(object):
 
291
    """Helper class for serve_bzr."""
 
292
 
 
293
    def __init__(self, userdir_expander=None, get_base_path=None):
 
294
        self.cleanups = []
 
295
        self.base_path = None
 
296
        self.backing_transport = None
 
297
        if userdir_expander is None:
 
298
            userdir_expander = os.path.expanduser
 
299
        self.userdir_expander = userdir_expander
 
300
        if get_base_path is None:
 
301
            get_base_path = _local_path_for_transport
 
302
        self.get_base_path = get_base_path
 
303
 
 
304
    def _expand_userdirs(self, path):
 
305
        """Translate /~/ or /~user/ to e.g. /home/foo, using
 
306
        self.userdir_expander (os.path.expanduser by default).
 
307
 
 
308
        If the translated path would fall outside base_path, or the path does
 
309
        not start with ~, then no translation is applied.
 
310
 
 
311
        If the path is inside, it is adjusted to be relative to the base path.
 
312
 
 
313
        e.g. if base_path is /home, and the expanded path is /home/joe, then
 
314
        the translated path is joe.
253
315
        """
254
 
        if not client_path_extra.startswith('/'):
255
 
            raise ValueError(client_path_extra)
256
 
        from bzrlib.transport.chroot import ChrootServer
257
 
        if backing_transport_server is None:
258
 
            from bzrlib.transport.local import LocalURLServer
259
 
            backing_transport_server = LocalURLServer()
260
 
        self.chroot_server = ChrootServer(
261
 
            self.get_backing_transport(backing_transport_server))
262
 
        self.chroot_server.setUp()
263
 
        self.backing_transport = transport.get_transport(
264
 
            self.chroot_server.get_url())
265
 
        self.root_client_path = self.client_path_extra = client_path_extra
266
 
        self.start_background_thread(self.thread_name_suffix)
267
 
 
268
 
    def tearDown(self):
269
 
        self.stop_background_thread()
270
 
        self.chroot_server.tearDown()
271
 
 
272
 
    def get_url(self):
273
 
        url = super(SmartTCPServer_for_testing, self).get_url()
274
 
        return url[:-1] + self.client_path_extra
275
 
 
276
 
    def get_bogus_url(self):
277
 
        """Return a URL which will fail to connect"""
278
 
        return 'bzr://127.0.0.1:1/'
279
 
 
280
 
 
281
 
class ReadonlySmartTCPServer_for_testing(SmartTCPServer_for_testing):
282
 
    """Get a readonly server for testing."""
283
 
 
284
 
    def get_backing_transport(self, backing_transport_server):
285
 
        """Get a backing transport from a server we are decorating."""
286
 
        url = 'readonly+' + backing_transport_server.get_url()
287
 
        return transport.get_transport(url)
288
 
 
289
 
 
290
 
class SmartTCPServer_for_testing_v2_only(SmartTCPServer_for_testing):
291
 
    """A variation of SmartTCPServer_for_testing that limits the client to
292
 
    using RPCs in protocol v2 (i.e. bzr <= 1.5).
 
316
        result = path
 
317
        if path.startswith('~'):
 
318
            expanded = self.userdir_expander(path)
 
319
            if not expanded.endswith('/'):
 
320
                expanded += '/'
 
321
            if expanded.startswith(self.base_path):
 
322
                result = expanded[len(self.base_path):]
 
323
        return result
 
324
 
 
325
    def _make_expand_userdirs_filter(self, transport):
 
326
        return pathfilter.PathFilteringServer(transport, self._expand_userdirs)
 
327
 
 
328
    def _make_backing_transport(self, transport):
 
329
        """Chroot transport, and decorate with userdir expander."""
 
330
        self.base_path = self.get_base_path(transport)
 
331
        chroot_server = chroot.ChrootServer(transport)
 
332
        chroot_server.start_server()
 
333
        self.cleanups.append(chroot_server.stop_server)
 
334
        transport = _mod_transport.get_transport_from_url(chroot_server.get_url())
 
335
        if self.base_path is not None:
 
336
            # Decorate the server's backing transport with a filter that can
 
337
            # expand homedirs.
 
338
            expand_userdirs = self._make_expand_userdirs_filter(transport)
 
339
            expand_userdirs.start_server()
 
340
            self.cleanups.append(expand_userdirs.stop_server)
 
341
            transport = _mod_transport.get_transport_from_url(expand_userdirs.get_url())
 
342
        self.transport = transport
 
343
 
 
344
    def _make_smart_server(self, host, port, inet):
 
345
        if inet:
 
346
            smart_server = medium.SmartServerPipeStreamMedium(
 
347
                sys.stdin, sys.stdout, self.transport)
 
348
        else:
 
349
            if host is None:
 
350
                host = medium.BZR_DEFAULT_INTERFACE
 
351
            if port is None:
 
352
                port = medium.BZR_DEFAULT_PORT
 
353
            smart_server = SmartTCPServer(self.transport)
 
354
            smart_server.start_server(host, port)
 
355
            trace.note(gettext('listening on port: %s') % smart_server.port)
 
356
        self.smart_server = smart_server
 
357
 
 
358
    def _change_globals(self):
 
359
        from bzrlib import lockdir, ui
 
360
        # For the duration of this server, no UI output is permitted. note
 
361
        # that this may cause problems with blackbox tests. This should be
 
362
        # changed with care though, as we dont want to use bandwidth sending
 
363
        # progress over stderr to smart server clients!
 
364
        old_factory = ui.ui_factory
 
365
        old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
 
366
        def restore_default_ui_factory_and_lockdir_timeout():
 
367
            ui.ui_factory = old_factory
 
368
            lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
 
369
        self.cleanups.append(restore_default_ui_factory_and_lockdir_timeout)
 
370
        ui.ui_factory = ui.SilentUIFactory()
 
371
        lockdir._DEFAULT_TIMEOUT_SECONDS = 0
 
372
 
 
373
    def set_up(self, transport, host, port, inet):
 
374
        self._make_backing_transport(transport)
 
375
        self._make_smart_server(host, port, inet)
 
376
        self._change_globals()
 
377
 
 
378
    def tear_down(self):
 
379
        for cleanup in reversed(self.cleanups):
 
380
            cleanup()
 
381
 
 
382
def serve_bzr(transport, host=None, port=None, inet=False):
 
383
    """This is the default implementation of 'bzr serve'.
 
384
    
 
385
    It creates a TCP or pipe smart server on 'transport, and runs it.  The
 
386
    transport will be decorated with a chroot and pathfilter (using
 
387
    os.path.expanduser).
293
388
    """
294
 
 
295
 
    def get_url(self):
296
 
        url = super(SmartTCPServer_for_testing_v2_only, self).get_url()
297
 
        url = 'bzr-v2://' + url[len('bzr://'):]
298
 
        return url
299
 
 
300
 
 
301
 
class ReadonlySmartTCPServer_for_testing_v2_only(SmartTCPServer_for_testing_v2_only):
302
 
    """Get a readonly server for testing."""
303
 
 
304
 
    def get_backing_transport(self, backing_transport_server):
305
 
        """Get a backing transport from a server we are decorating."""
306
 
        url = 'readonly+' + backing_transport_server.get_url()
307
 
        return transport.get_transport(url)
308
 
 
309
 
 
 
389
    bzr_server = BzrServerFactory()
 
390
    try:
 
391
        bzr_server.set_up(transport, host, port, inet)
 
392
        bzr_server.smart_server.serve()
 
393
    except:
 
394
        hook_caught_exception = False
 
395
        for hook in SmartTCPServer.hooks['server_exception']:
 
396
            hook_caught_exception = hook(sys.exc_info())
 
397
        if not hook_caught_exception:
 
398
            raise
 
399
    finally:
 
400
        bzr_server.tear_down()