core.streams
index

# Copyright 2011 the original author or authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

 
Classes
       
__builtin__.object
Pump
ReadStream
WriteStream

 
class Pump(__builtin__.object)
    Pumps data from a ReadStream to a WriteStream and performs flow control where necessary to
prevent the write stream from getting overloaded.
 
Instances of this class read bytes from a ReadStream and write them to a WriteStream. If data
can be read faster than it can be written this could result in the write queue of the WriteStream growing
without bound, eventually causing it to exhaust all available RAM.
To prevent this, after each write, instances of this class check whether the write queue of the WriteStream
is full, and if so, the ReadStream is paused, and a WriteStreamdrain_handler is set on the WriteStream.
When the WriteStream has processed half of its backlog, the drain_handler will be called,
which results in the pump resuming the ReadStream.
 
This class can be used to pump from any ReadStream to any  WriteStream,
e.g. from an HttpServerRequest to an AsyncFile, or from NetSocket to a WebSocket.
 
  Methods defined here:
__init__(self, read_stream, write_stream)
set_write_queue_max_size(self, val)
Set the write queue max size
 
Keyword arguments:
@param val: The write queue max size
start(self)
Start the Pump. The Pump can be started and stopped multiple times.
stop(self)
Stop the Pump. The Pump can be started and stopped multiple times.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
bytes_pumped
return the total number of bytes pumped by this pump.
write_queue_max_size

 
class ReadStream(__builtin__.object)
    A mixin module which represents a stream of data that can be read from.
 
Any class that mixes in this module can be used by a  to pump data from a  to it.
 
  Methods defined here:
data_handler(self, handler)
Set a data handler. As data is read, the handler will be called with the data.
 
Keyword arguments:
@param handler: The data handler
end_handler(self, handler)
Set an end handler on the stream. Once the stream has ended, and there is no more data to be read, this handler will be called.
 
Keyword arguments:
@param handler: The exception handler
exception_handler(self, handler)
Set an execption handler on the stream.
param [Block] hndlr. The exception handler
pause(self)
Pause the ReadStream. After calling this, the ReadStream will aim to send no more data to the
resume(self)
Resume reading. If the ReadStream has been paused, reading will recommence on it.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

 
class WriteStream(__builtin__.object)
    A mixin module which represents a stream of data that can be written to.
 
Any class that mixes in this module can be used by a  to pump data from a  to it.
 
  Methods defined here:
drain_handler(self, handler)
Set a drain handler on the stream. If the write queue is full, then the handler will be called when the write
queue has been reduced to maxSize / 2. See  for an example of this being used.
 
Keyword arguments:
@param handler: The drain handler
exception_handler(self, handler)
Set an execption handler on the stream.
 
Keyword arguments:
@param handler: The exception handler
set_write_queue_max_size(self, size)
Set the maximum size of the write queue. You will still be able to write to the stream even
if there is more data than this in the write queue. This is used as an indicator by classes such as
to provide flow control.
 
Keyword arguments:
@param size: The maximum size, in bytes.
write_buffer(self, buff)
Write some data to the stream. The data is put on an internal write queue, and the write actually happens
asynchronously. To avoid running out of memory by putting too much on the write queue,
check the  method before writing. This is done automatically if using a .
param [Buffer]. The buffer to write.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
write_queue_full
Is the write queue full?
 
return True if there are more bytes in the write queue than the max write queue size.
write_queue_max_size

 
Data
        __author__ = 'Scott Horn'
__credits__ = 'Based entirely on work by Tim Fox http://tfox.org'
__email__ = 'scott@hornmicro.com'
org = <java package org 0x2>

 
Author
        Scott Horn

 
Credits
        Based entirely on work by Tim Fox http://tfox.org