← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/server.py

  • Committer: Ian Clatworthy
  • Date: 2007-08-13 14:16:53 UTC
  • mto: (2733.1.1 ianc-integration)
  • mto: This revision was merged to the branch mainline in revision 2734.
  • Revision ID: ian.clatworthy@internode.on.net-20070813141653-3cbrp00xowq58zv1
Added mini tutorial

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, 2007 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
20
import socket
21
 
import sys
22
21
import threading
23
22
 
24
 
from bzrlib.hooks import HookPoint, Hooks
 
23
from bzrlib.hooks import Hooks
25
24
from bzrlib import (
26
25
    errors,
27
26
    trace,
28
27
    transport,
29
28
)
30
 
from bzrlib.lazy_import import lazy_import
31
 
lazy_import(globals(), """
32
 
from bzrlib.smart import medium
33
 
""")
 
29
from bzrlib.smart.medium import SmartServerSocketStreamMedium
34
30
 
35
31
 
36
32
class SmartTCPServer(object):
42
38
    hooks: An instance of SmartServerHooks.
43
39
    """
44
40
 
45
 
    def __init__(self, backing_transport, host='127.0.0.1', port=0,
46
 
                 root_client_path='/'):
 
41
    def __init__(self, backing_transport, host='127.0.0.1', port=0):
47
42
        """Construct a new server.
48
43
 
49
44
        To actually start it running, call either start_background_thread or
50
45
        serve.
51
46
 
52
 
        :param backing_transport: The transport to serve.
53
47
        :param host: Name of the interface to listen on.
54
48
        :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
49
        """
58
50
        # let connections timeout so that we get a chance to terminate
59
51
        # Keep a reference to the exceptions we want to catch because the socket
62
54
        from socket import error as socket_error
63
55
        self._socket_error = socket_error
64
56
        self._socket_timeout = socket_timeout
65
 
        addrs = socket.getaddrinfo(host, port, socket.AF_UNSPEC,
66
 
            socket.SOCK_STREAM, 0, socket.AI_PASSIVE)[0]
67
 
 
68
 
        (family, socktype, proto, canonname, sockaddr) = addrs
69
 
 
70
 
        self._server_socket = socket.socket(family, socktype, proto)
71
 
        # SO_REUSERADDR has a different meaning on Windows
72
 
        if sys.platform != 'win32':
73
 
            self._server_socket.setsockopt(socket.SOL_SOCKET,
74
 
                socket.SO_REUSEADDR, 1)
75
 
        try:
76
 
            self._server_socket.bind(sockaddr)
77
 
        except self._socket_error, message:
78
 
            raise errors.CannotBindAddress(host, port, message)
 
57
        self._server_socket = socket.socket()
 
58
        self._server_socket.bind((host, port))
79
59
        self._sockname = self._server_socket.getsockname()
80
60
        self.port = self._sockname[1]
81
61
        self._server_socket.listen(1)
83
63
        self.backing_transport = backing_transport
84
64
        self._started = threading.Event()
85
65
        self._stopped = threading.Event()
86
 
        self.root_client_path = root_client_path
87
66
 
88
 
    def serve(self, thread_name_suffix=''):
 
67
    def serve(self):
89
68
        self._should_terminate = False
90
69
        # for hooks we are letting code know that a server has started (and
91
70
        # later stopped).
98
77
        # We need all three because:
99
78
        #  * other machines see the first
100
79
        #  * local commits on this machine should be able to be mapped to
101
 
        #    this server
 
80
        #    this server 
102
81
        #  * commits the server does itself need to be mapped across to this
103
82
        #    server.
104
83
        # The latter two urls are different aliases to the servers url,
105
 
        # so we group those in a list - as there might be more aliases
 
84
        # so we group those in a list - as there might be more aliases 
106
85
        # in the future.
107
86
        backing_urls = [self.backing_transport.base]
108
87
        try:
111
90
            pass
112
91
        for hook in SmartTCPServer.hooks['server_started']:
113
92
            hook(backing_urls, self.get_url())
114
 
        for hook in SmartTCPServer.hooks['server_started_ex']:
115
 
            hook(backing_urls, self)
116
93
        self._started.set()
117
94
        try:
118
95
            try:
129
106
                        if e.args[0] != errno.EBADF:
130
107
                            trace.warning("listening socket error: %s", e)
131
108
                    else:
132
 
                        self.serve_conn(conn, thread_name_suffix)
 
109
                        self.serve_conn(conn)
133
110
            except KeyboardInterrupt:
134
111
                # dont log when CTRL-C'd.
135
112
                raise
152
129
        """Return the url of the server"""
153
130
        return "bzr://%s:%d/" % self._sockname
154
131
 
155
 
    def serve_conn(self, conn, thread_name_suffix):
 
132
    def serve_conn(self, conn):
156
133
        # For WIN32, where the timeout value from the listening socket
157
 
        # propagates to the newly accepted socket.
 
134
        # propogates to the newly accepted socket.
158
135
        conn.setblocking(True)
159
136
        conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
160
 
        handler = medium.SmartServerSocketStreamMedium(
161
 
            conn, self.backing_transport, self.root_client_path)
162
 
        thread_name = 'smart-server-child' + thread_name_suffix
163
 
        connection_thread = threading.Thread(
164
 
            None, handler.serve, name=thread_name)
 
137
        handler = SmartServerSocketStreamMedium(conn, self.backing_transport)
 
138
        connection_thread = threading.Thread(None, handler.serve, name='smart-server-child')
165
139
        connection_thread.setDaemon(True)
166
140
        connection_thread.start()
167
141
 
168
 
    def start_background_thread(self, thread_name_suffix=''):
 
142
    def start_background_thread(self):
169
143
        self._started.clear()
170
144
        self._server_thread = threading.Thread(None,
171
 
                self.serve, args=(thread_name_suffix,),
 
145
                self.serve,
172
146
                name='server-' + self.get_url())
173
147
        self._server_thread.setDaemon(True)
174
148
        self._server_thread.start()
180
154
        self._should_terminate = True
181
155
        # close the socket - gives error to connections from here on in,
182
156
        # rather than a connection reset error to connections made during
183
 
        # the period between setting _should_terminate = True and
 
157
        # the period between setting _should_terminate = True and 
184
158
        # the current request completing/aborting. It may also break out the
185
159
        # main loop if it was currently in accept() (on some platforms).
186
160
        try:
210
184
        notified.
211
185
        """
212
186
        Hooks.__init__(self)
213
 
        self.create_hook(HookPoint('server_started',
214
 
            "Called by the bzr server when it starts serving a directory. "
215
 
            "server_started is called with (backing urls, public url), "
216
 
            "where backing_url is a list of URLs giving the "
217
 
            "server-specific directory locations, and public_url is the "
218
 
            "public URL for the directory being served.", (0, 16), None))
219
 
        self.create_hook(HookPoint('server_started_ex',
220
 
            "Called by the bzr server when it starts serving a directory. "
221
 
            "server_started is called with (backing_urls, server_obj).",
222
 
            (1, 17), None))
223
 
        self.create_hook(HookPoint('server_stopped',
224
 
            "Called by the bzr server when it stops serving a directory. "
225
 
            "server_stopped is called with the same parameters as the "
226
 
            "server_started hook: (backing_urls, public_url).", (0, 16), None))
 
187
        # Introduced in 0.16:
 
188
        # invoked whenever the server starts serving a directory.
 
189
        # The api signature is (backing urls, public url).
 
190
        self['server_started'] = []
 
191
        # Introduced in 0.16:
 
192
        # invoked whenever the server stops serving a directory.
 
193
        # The api signature is (backing urls, public url).
 
194
        self['server_stopped'] = []
227
195
 
228
196
SmartTCPServer.hooks = SmartServerHooks()
229
197
 
230
198
 
231
199
class SmartTCPServer_for_testing(SmartTCPServer):
232
200
    """Server suitable for use by transport tests.
233
 
 
 
201
    
234
202
    This server is backed by the process's cwd.
235
203
    """
236
204
 
237
 
    def __init__(self, thread_name_suffix=''):
 
205
    def __init__(self):
238
206
        SmartTCPServer.__init__(self, None)
239
 
        self.client_path_extra = None
240
 
        self.thread_name_suffix = thread_name_suffix
241
 
 
 
207
        
242
208
    def get_backing_transport(self, backing_transport_server):
243
209
        """Get a backing transport from a server we are decorating."""
244
210
        return transport.get_transport(backing_transport_server.get_url())
245
211
 
246
 
    def setUp(self, backing_transport_server=None,
247
 
              client_path_extra='/extra/'):
248
 
        """Set up server for testing.
249
 
 
250
 
        :param backing_transport_server: backing server to use.  If not
251
 
            specified, a LocalURLServer at the current working directory will
252
 
            be used.
253
 
        :param client_path_extra: a path segment starting with '/' to append to
254
 
            the root URL for this server.  For instance, a value of '/foo/bar/'
255
 
            will mean the root of the backing transport will be published at a
256
 
            URL like `bzr://127.0.0.1:nnnn/foo/bar/`, rather than
257
 
            `bzr://127.0.0.1:nnnn/`.  Default value is `extra`, so that tests
258
 
            by default will fail unless they do the necessary path translation.
259
 
        """
260
 
        if not client_path_extra.startswith('/'):
261
 
            raise ValueError(client_path_extra)
 
212
    def setUp(self, backing_transport_server=None):
 
213
        """Set up server for testing"""
262
214
        from bzrlib.transport.chroot import ChrootServer
263
215
        if backing_transport_server is None:
264
216
            from bzrlib.transport.local import LocalURLServer
268
220
        self.chroot_server.setUp()
269
221
        self.backing_transport = transport.get_transport(
270
222
            self.chroot_server.get_url())
271
 
        self.root_client_path = self.client_path_extra = client_path_extra
272
 
        self.start_background_thread(self.thread_name_suffix)
 
223
        self.start_background_thread()
273
224
 
274
225
    def tearDown(self):
275
226
        self.stop_background_thread()
276
227
        self.chroot_server.tearDown()
277
228
 
278
 
    def get_url(self):
279
 
        url = super(SmartTCPServer_for_testing, self).get_url()
280
 
        return url[:-1] + self.client_path_extra
281
 
 
282
229
    def get_bogus_url(self):
283
230
        """Return a URL which will fail to connect"""
284
231
        return 'bzr://127.0.0.1:1/'
292
239
        url = 'readonly+' + backing_transport_server.get_url()
293
240
        return transport.get_transport(url)
294
241
 
295
 
 
296
 
class SmartTCPServer_for_testing_v2_only(SmartTCPServer_for_testing):
297
 
    """A variation of SmartTCPServer_for_testing that limits the client to
298
 
    using RPCs in protocol v2 (i.e. bzr <= 1.5).
299
 
    """
300
 
 
301
 
    def get_url(self):
302
 
        url = super(SmartTCPServer_for_testing_v2_only, self).get_url()
303
 
        url = 'bzr-v2://' + url[len('bzr://'):]
304
 
        return url
305
 
 
306
 
 
307
 
class ReadonlySmartTCPServer_for_testing_v2_only(SmartTCPServer_for_testing_v2_only):
308
 
    """Get a readonly server for testing."""
309
 
 
310
 
    def get_backing_transport(self, backing_transport_server):
311
 
        """Get a backing transport from a server we are decorating."""
312
 
        url = 'readonly+' + backing_transport_server.get_url()
313
 
        return transport.get_transport(url)
314
 
 
315
 
 
316
 
def serve_bzr(transport, host=None, port=None, inet=False):
317
 
    from bzrlib import lockdir, ui
318
 
    from bzrlib.transport import get_transport
319
 
    from bzrlib.transport.chroot import ChrootServer
320
 
    chroot_server = ChrootServer(transport)
321
 
    chroot_server.setUp()
322
 
    transport = get_transport(chroot_server.get_url())
323
 
    if inet:
324
 
        smart_server = medium.SmartServerPipeStreamMedium(
325
 
            sys.stdin, sys.stdout, transport)
326
 
    else:
327
 
        if host is None:
328
 
            host = medium.BZR_DEFAULT_INTERFACE
329
 
        if port is None:
330
 
            port = medium.BZR_DEFAULT_PORT
331
 
        smart_server = SmartTCPServer(transport, host=host, port=port)
332
 
        trace.note('listening on port: %s' % smart_server.port)
333
 
    # For the duration of this server, no UI output is permitted. note
334
 
    # that this may cause problems with blackbox tests. This should be
335
 
    # changed with care though, as we dont want to use bandwidth sending
336
 
    # progress over stderr to smart server clients!
337
 
    old_factory = ui.ui_factory
338
 
    old_lockdir_timeout = lockdir._DEFAULT_TIMEOUT_SECONDS
339
 
    try:
340
 
        ui.ui_factory = ui.SilentUIFactory()
341
 
        lockdir._DEFAULT_TIMEOUT_SECONDS = 0
342
 
        smart_server.serve()
343
 
    finally:
344
 
        ui.ui_factory = old_factory
345
 
        lockdir._DEFAULT_TIMEOUT_SECONDS = old_lockdir_timeout
346