本文整理汇总了Python中pyamf.util.BufferedByteStream.remaining方法的典型用法代码示例。如果您正苦于以下问题:Python BufferedByteStream.remaining方法的具体用法?Python BufferedByteStream.remaining怎么用?Python BufferedByteStream.remaining使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类pyamf.util.BufferedByteStream
的用法示例。
在下文中一共展示了BufferedByteStream.remaining方法的3个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: RTMPDisassembler
# 需要导入模块: from pyamf.util import BufferedByteStream [as 别名]
# 或者: from pyamf.util.BufferedByteStream import remaining [as 别名]
class RTMPDisassembler(object):
"""
Disassembling bytestream into RTMP packets.
RTMP stream slices packets into chunks of L{chunkSize}. This class
processes incoming stream of RTMP protocol data (after initial handshake)
and decodes RTMP packets.
Communication goes independently for each object_id. Last received
headers are stored for each object_id in L{lastHeaders}. L{pool} holds
incomplete packet contents also for each object_id.
@ivar lastHeaders: last received header for object_id
@type lastHeaders: C{dict}, object_id -> L{RTMPHeader}
@ivar pool: incomplete packet data for object_id
@type pool: C{dict}, object_id -> L{BufferedByteStream}
@ivar chunkSize: size of chunk for this stream
@type chunkSize: C{int}
@ivar buffer: incoming buffer with data received from protocol
@type buffer: L{BufferedByteStream}
"""
def __init__(self, chunkSize):
"""
Constructor.
@param chunkSize: initial size of chunk
@type chunkSize: C{int}
"""
self.lastHeaders = {}
self.pool = {}
self.chunkSize = chunkSize
self.buffer = BufferedByteStream()
def push_data(self, data):
"""
Push more incoming data.
@param data: data received
@type data: C{str}
"""
self.buffer.seek(0, 2)
self.buffer.write(data)
return self
def disassemble(self):
"""
Disassemble L{buffer} into packets.
Returns first decoded packet or None, if no packet could
be decoded at the moment.
@return: decoded packet
@rtype: L{Packet}
"""
self.buffer.seek(0)
while self.buffer.remaining() > 0:
try:
# try to parse header from stream
header = RTMPHeader.read(self.buffer)
except NeedBytes, (bytes,):
# not enough bytes, return what we've already parsed
return None
# fill header with extra data from previous headers received
# with same object_id
header.fill(self.lastHeaders.get(header.object_id, RTMPHeader()))
# get buffer for data of this packet
buf = self.pool.get(header.object_id, BufferedByteStream())
# this chunk size is minimum of regular chunk size in this
# disassembler and what we have left here
thisChunk = min(header.length - len(buf), self.chunkSize)
if self.buffer.remaining() < thisChunk:
# we have not enough bytes to read this chunk of data
return None
# we got complete chunk
buf.write(self.buffer.read(thisChunk))
# store packet header for this object_id
self.lastHeaders[header.object_id] = header
# skip data left in input buffer
self.buffer.consume()
# this chunk completes full packet?
if len(buf) < header.length:
# no, store buffer for further chunks
self.pool[header.object_id] = buf
else:
# parse packet from header and data
buf.seek(0, 0)
# delete stored data for this packet
if header.object_id in self.pool:
del self.pool[header.object_id]
#.........这里部分代码省略.........
示例2: BaseNegotiator
# 需要导入模块: from pyamf.util import BufferedByteStream [as 别名]
# 或者: from pyamf.util.BufferedByteStream import remaining [as 别名]
class BaseNegotiator(object):
"""
Base functionality for negotiating an RTMP handshake.
Call L{start} to begin negotiations.
@ivar observer: An observer for handshake negotiations.
@type observer: L{IHandshakeObserver}
@ivar started: Whether negotiations have begun.
@type started: C{bool}
@ivar _buffer: Any data that has been received but not yet been consumed.
@type _buffer: L{BufferedByteStream}
"""
started = False
nearRequest = None
nearResponse = None
farRequest = None
farResponse = None
protocolVersion = 3
farProtocolVersion = None
def __init__(self, observer, output):
self.observer = observer
self.output = output
def start(self, uptime=0, version=0):
"""
Called to start the handshaking negotiations.
"""
if self.started:
raise AlreadyStarted('Handshake negotiator cannot be restarted')
self.started = True
self.uptime = uptime
self.version = version
self._buffer = BufferedByteStream()
def readPacket(self):
if self._buffer.remaining() < HANDSHAKE_LENGTH:
# we're expecting more data
return
packet = self._buffer.read(HANDSHAKE_LENGTH)
self._buffer.consume()
return packet
def dataReceived(self, data):
"""
Called when handshake data has been received.
"""
if not self.started:
raise HandshakeError('Data received, but negotiator not started')
self._buffer.append(data)
if self.farProtocolVersion is None:
self.farProtocolVersion = self._buffer.read_uchar()
packet = self.readPacket()
if not packet:
return
if not self.farRequest:
self.farRequest = self.buildFarRequest()
self.farRequest.decode(packet)
self.farRequestReceived(self.farRequest)
packet = self.readPacket()
if not packet:
return
if not self.farResponse:
self.farResponse = self.buildFarResponse()
self.farResponse.decode(packet)
self.farResponseReceived(self.farResponse)
def buildFarRequest(self):
"""
"""
return RequestPacket()
#.........这里部分代码省略.........
示例3: BaseNegotiator
# 需要导入模块: from pyamf.util import BufferedByteStream [as 别名]
# 或者: from pyamf.util.BufferedByteStream import remaining [as 别名]
class BaseNegotiator(object):
"""
Base functionality for negotiating an RTMP handshake.
@ivar observer: An observer for handshake negotiations.
@type observer: L{IHandshakeObserver}
@ivar buffer: Any data that has not yet been consumed.
@type buffer: L{BufferedByteStream}
@ivar started: Determines whether negotiations have already begun.
@type started: C{bool}
@ivar my_syn: The initial handshake packet that will be sent by this
negotiator.
@type my_syn: L{Packet}
@ivar my_ack: The handshake packet that will be sent after the peer has sent
its syn.
@ivar peer_syn: The initial L{Packet} received from the peer.
@ivar peer_ack: The L{Packet} received in acknowledgement of my syn.
@ivar peer_version: The handshake version that the peer understands.
"""
implements(IHandshakeNegotiator)
def __init__(self, observer, transport):
self.observer = observer
self.transport = transport
self.started = False
def start(self, uptime=None, version=None):
"""
Called to start the handshaking negotiations.
"""
if self.started:
raise HandshakeError('Handshake negotiator cannot be restarted')
self.started = True
self.buffer = BufferedByteStream()
self.peer_version = None
self.my_syn = Packet(uptime, version)
self.my_ack = None
self.peer_syn = None
self.peer_ack = None
self.buildSynPayload(self.my_syn)
self._writePacket(self.my_syn)
def getPeerPacket(self):
"""
Attempts to decode a L{Packet} from the buffer. If there is not enough
data in the buffer then C{None} is returned.
"""
if self.buffer.remaining() < HANDSHAKE_LENGTH:
# we're expecting more data
return
packet = Packet()
packet.decode(self.buffer)
return packet
def _writePacket(self, packet, stream=None):
stream = stream or BufferedByteStream()
packet.encode(stream)
self.transport.write(stream.getvalue())
def dataReceived(self, data):
"""
Called when handshake data has been received. If an error occurs
whilst negotiating the handshake then C{self.observer.handshakeFailure}
will be called, citing the reason.
3 stages of data are received. The handshake version, the syn packet and
then the ack packet.
"""
if not self.started:
raise HandshakeError('Data was received, but negotiator was '
'not started')
self.buffer.append(data)
self._process()
def _process(self):
if not self.peer_syn:
self.peer_syn = self.getPeerPacket()
if not self.peer_syn:
return
#.........这里部分代码省略.........