← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/server.py

  • Committer: John Arbash Meinel
  • Date: 2008-09-09 15:09:12 UTC
  • mto: This revision was merged to the branch mainline in revision 3699.
  • Revision ID: john@arbash-meinel.com-20080909150912-wyttm8he1zsls2ck
Use the right timing function on win32

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/server.py
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
 
21
21
import sys
22
22
import threading
23
23
 
24
 
from bzrlib.hooks import HookPoint, Hooks
 
24
from bzrlib.hooks import Hooks
25
25
from bzrlib import (
26
26
    errors,
27
27
    trace,
28
28
    transport,
29
29
)
30
 
from bzrlib.lazy_import import lazy_import
31
 
lazy_import(globals(), """
32
 
from bzrlib.smart import medium
33
 
""")
 
30
from bzrlib.smart.medium import SmartServerSocketStreamMedium
34
31
 
35
32
 
36
33
class SmartTCPServer(object):
62
59
        from socket import error as socket_error
63
60
        self._socket_error = socket_error
64
61
        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)
 
62
        self._server_socket = socket.socket()
71
63
        # SO_REUSERADDR has a different meaning on Windows
72
64
        if sys.platform != 'win32':
73
65
            self._server_socket.setsockopt(socket.SOL_SOCKET,
74
66
                socket.SO_REUSEADDR, 1)
75
67
        try:
76
 
            self._server_socket.bind(sockaddr)
 
68
            self._server_socket.bind((host, port))
77
69
        except self._socket_error, message:
78
70
            raise errors.CannotBindAddress(host, port, message)
79
71
        self._sockname = self._server_socket.getsockname()
98
90
        # We need all three because:
99
91
        #  * other machines see the first
100
92
        #  * local commits on this machine should be able to be mapped to
101
 
        #    this server
 
93
        #    this server 
102
94
        #  * commits the server does itself need to be mapped across to this
103
95
        #    server.
104
96
        # 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
 
97
        # so we group those in a list - as there might be more aliases 
106
98
        # in the future.
107
99
        backing_urls = [self.backing_transport.base]
108
100
        try:
111
103
            pass
112
104
        for hook in SmartTCPServer.hooks['server_started']:
113
105
            hook(backing_urls, self.get_url())
114
 
        for hook in SmartTCPServer.hooks['server_started_ex']:
115
 
            hook(backing_urls, self)
116
106
        self._started.set()
117
107
        try:
118
108
            try:
154
144
 
155
145
    def serve_conn(self, conn, thread_name_suffix):
156
146
        # For WIN32, where the timeout value from the listening socket
157
 
        # propagates to the newly accepted socket.
 
147
        # propogates to the newly accepted socket.
158
148
        conn.setblocking(True)
159
149
        conn.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
160
 
        handler = medium.SmartServerSocketStreamMedium(
 
150
        handler = SmartServerSocketStreamMedium(
161
151
            conn, self.backing_transport, self.root_client_path)
162
152
        thread_name = 'smart-server-child' + thread_name_suffix
163
153
        connection_thread = threading.Thread(
180
170
        self._should_terminate = True
181
171
        # close the socket - gives error to connections from here on in,
182
172
        # rather than a connection reset error to connections made during
183
 
        # the period between setting _should_terminate = True and
 
173
        # the period between setting _should_terminate = True and 
184
174
        # the current request completing/aborting. It may also break out the
185
175
        # main loop if it was currently in accept() (on some platforms).
186
176
        try:
210
200
        notified.
211
201
        """
212
202
        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))
 
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'] = []
227
211
 
228
212
SmartTCPServer.hooks = SmartServerHooks()
229
213
 
230
214
 
231
215
class SmartTCPServer_for_testing(SmartTCPServer):
232
216
    """Server suitable for use by transport tests.
233
 
 
 
217
    
234
218
    This server is backed by the process's cwd.
235
219
    """
236
220
 
238
222
        SmartTCPServer.__init__(self, None)
239
223
        self.client_path_extra = None
240
224
        self.thread_name_suffix = thread_name_suffix
241
 
 
 
225
        
242
226
    def get_backing_transport(self, backing_transport_server):
243
227
        """Get a backing transport from a server we are decorating."""
244
228
        return transport.get_transport(backing_transport_server.get_url())
246
230
    def setUp(self, backing_transport_server=None,
247
231
              client_path_extra='/extra/'):
248
232
        """Set up server for testing.
249
 
 
 
233
        
250
234
        :param backing_transport_server: backing server to use.  If not
251
235
            specified, a LocalURLServer at the current working directory will
252
236
            be used.
313
297
        return transport.get_transport(url)
314
298
 
315
299
 
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