← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/server.py

  • Committer: Vincent Ladeuil
  • Date: 2008-09-11 19:36:38 UTC
  • mfrom: (3703 +trunk)
  • mto: (3705.1.1 trunk2)
  • mto: This revision was merged to the branch mainline in revision 3708.
  • Revision ID: v.ladeuil+lp@free.fr-20080911193638-wtjyc1kcmacc6t1f
merge bzr.dev

Show diffs side-by-side

added added

removed removed

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