← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/smart/protocol.py

  • Committer: John Arbash Meinel
  • Date: 2007-07-31 20:31:01 UTC
  • mto: This revision was merged to the branch mainline in revision 2688.
  • Revision ID: john@arbash-meinel.com-20070731203101-p7h45wm6v4x6nb18
Update to include a bit better formatting
And include logging of number of bytes transmitted.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/smart/protocol.py
80
80
        self.has_dispatched = False
81
81
        self.request = None
82
82
        self._body_decoder = None
83
 
        self._write_func = write_func
84
83
 
85
84
    def accept_bytes(self, bytes):
86
85
        """Take bytes, and advance the internal state machine appropriately.
303
302
 
304
303
    def call(self, *args):
305
304
        if 'hpss' in debug.debug_flags:
306
 
            mutter('hpss call:   %r', args)
 
305
            mutter('hpss call:   %s', repr(args)[1:-1])
307
306
            self._request_start_time = time.time()
308
307
        self._write_args(args)
309
308
        self._request.finished_writing()
314
313
        After calling this, call read_response_tuple to find the result out.
315
314
        """
316
315
        if 'hpss' in debug.debug_flags:
317
 
            mutter('hpss call w/body: %r (%r...)', args, body[:20])
318
 
            start = time.time()
 
316
            mutter('hpss call w/body: %s (%r...)', repr(args)[1:-1], body[:20])
 
317
            mutter('         %8d bytes', len(body))
 
318
            self._request_start_time = time.time()
319
319
        self._write_args(args)
320
320
        bytes = self._encode_bulk_data(body)
321
321
        self._request.accept_bytes(bytes)
322
322
        self._request.finished_writing()
323
 
        if 'hpss' in debug.debug_flags:
324
 
            # This gives us the time it took to send the information
325
 
            # decoupled from the time it takes the server to respond to it.
326
 
            mutter('hpss write time: %6.3fs', time.time() - start)
327
 
            self._request_start_time = time.time()
328
323
 
329
324
    def call_with_body_readv_array(self, args, body):
330
325
        """Make a remote call with a readv array.
333
328
        each pair are separated by a comma, and no trailing \n is emitted.
334
329
        """
335
330
        if 'hpss' in debug.debug_flags:
336
 
            mutter('hpss call w/readv: %r', args)
337
 
            start = time.time()
 
331
            mutter('hpss call w/readv: %s', repr(args)[1:-1])
 
332
            self._request_start_time = time.time()
338
333
        self._write_args(args)
339
334
        readv_bytes = self._serialise_offsets(body)
340
335
        bytes = self._encode_bulk_data(readv_bytes)
341
336
        self._request.accept_bytes(bytes)
342
337
        self._request.finished_writing()
343
338
        if 'hpss' in debug.debug_flags:
344
 
            mutter('hpss write time: %6.3fs', time.time() - start)
345
 
            self._request_start_time = time.time()
 
339
            mutter('         %8d bytes', len(readv_bytes))
346
340
 
347
341
    def cancel_read_body(self):
348
342
        """After expecting a body, a response code may indicate one otherwise.
361
355
        result = self._recv_tuple()
362
356
        if 'hpss' in debug.debug_flags:
363
357
            if self._request_start_time is not None:
364
 
                mutter('hpss result: %6.3fs %r',
 
358
                mutter('   result:   %6.3fs  %s',
365
359
                       time.time() - self._request_start_time,
366
 
                       result)
 
360
                       repr(result)[1:-1])
367
361
                self._request_start_time = None
368
362
            else:
369
 
                mutter('hpss result: %r', result)
 
363
                mutter('   result:   %s', repr(result)[1:-1])
 
364
            mutter('         %8d bytes written',
 
365
                   self._request._bytes_written)
370
366
        if not expect_body:
371
367
            self._request.finished_reading()
372
368
        return result
388
384
        self._request.finished_reading()
389
385
        self._body_buffer = StringIO(_body_decoder.read_pending_data())
390
386
        # XXX: TODO check the trailer result.
 
387
        if 'hpss' in debug.debug_flags:
 
388
            mutter('         %8d body bytes read',
 
389
                   len(self._body_buffer.getvalue()))
391
390
        return self._body_buffer.read(count)
392
391
 
393
392
    def _recv_tuple(self):