本文整理汇总了Python中pyamf.util.BufferedByteStream.append方法的典型用法代码示例。如果您正苦于以下问题:Python BufferedByteStream.append方法的具体用法?Python BufferedByteStream.append怎么用?Python BufferedByteStream.append使用的例子?那么, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类pyamf.util.BufferedByteStream
的用法示例。
在下文中一共展示了BufferedByteStream.append方法的4个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: ProducingChannel
# 需要导入模块: from pyamf.util import BufferedByteStream [as 别名]
# 或者: from pyamf.util.BufferedByteStream import append [as 别名]
class ProducingChannel(BaseChannel):
"""
Writes RTMP frames.
@ivar buffer: Any data waiting to be written to the underlying stream.
@type buffer: L{BufferedByteStream}
@ivar acquired: Whether this channel is acquired. See L{ChannelMuxer.
acquireChannel}
"""
def __init__(self, channelId, stream, frameSize):
BaseChannel.__init__(self, channelId, stream, frameSize)
self.buffer = BufferedByteStream()
self.acquired = False
self.callback = None
def setCallback(self, cb):
"""
Sets the callback that will be fired once this channel has been completely
encoded.
"""
self.callback = cb
def reset(self):
"""
Called when the channel has completed writing the buffer.
"""
BaseChannel.reset(self)
self.buffer.seek(0)
self.buffer.truncate()
self.header = None
def append(self, data):
"""
Appends data to the buffer in preparation of encoding in RTMP.
"""
self.buffer.append(data)
def marshallFrame(self, size):
"""
Writes a section of the buffer as part of the RTMP frame.
"""
self.stream.write(self.buffer.read(size))
示例2: BaseNegotiator
# 需要导入模块: from pyamf.util import BufferedByteStream [as 别名]
# 或者: from pyamf.util.BufferedByteStream import append [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: StateEngine
# 需要导入模块: from pyamf.util import BufferedByteStream [as 别名]
# 或者: from pyamf.util.BufferedByteStream import append [as 别名]
#.........这里部分代码省略.........
if self.state == self.STATE_VERSION:
self.version_dataReceived(data)
elif self.state == self.STATE_HANDSHAKE:
self.handshake_dataReceived(data)
elif self.state == self.STATE_STREAM:
BaseStreamer.dataReceived(self, data)
else:
raise RuntimeError('Invalid state!')
def startVersioning(self):
"""
Start protocol version negotiations.
"""
self.buffer = BufferedByteStream()
def stopVersioning(self, reason=None):
"""
Stop protocol version negotiations.
@param reason: A L{failure.Failure} object if protocol version
negotiations failed. C{None} means success.
"""
del self.buffer
def version_dataReceived(self, data):
"""
"""
if not data:
return
self.buffer.append(data)
self.peerProtocolVersion = self.buffer.read_uchar()
self.versionReceived(self.peerProtocolVersion)
def versionReceived(self, version):
"""
Called when the peers' protocol version has been received.
The default behaviour is to accept any known version. It is the
responsibility for any overriding subclass to call L{versionSuccess} for
negotiations to proceed.
"""
if version == self.protocolVersion:
self.versionSuccess()
return
raise UnknownProtocolVersion(
'Unhandled protocol version %d' % (version,))
def versionSuccess(self):
"""
Protocol version negotiations have been successful, now on to
handshaking.
"""
try:
data = self.buffer.read()
except IOError:
data = None
示例4: BaseNegotiator
# 需要导入模块: from pyamf.util import BufferedByteStream [as 别名]
# 或者: from pyamf.util.BufferedByteStream import append [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
#.........这里部分代码省略.........