class SegmentedStreamReader(StreamIO):
__worker__ = SegmentedStreamWorker
__writer__ = SegmentedStreamWriter
def __init__(self, stream, timeout=None):
super().__init__()
self.session = stream.session
self.stream = stream
self.timeout = timeout or self.session.options.get("stream-timeout")
buffer_size = self.session.get_option("ringbuffer-size")
self.buffer = RingBuffer(buffer_size)
self.writer = self.__writer__(self)
self.worker = self.__worker__(self)
def open(self):
self.writer.start()
self.worker.start()
def close(self):
self.worker.close()
self.writer.close()
self.buffer.close()
def read(self, size):
return self.buffer.read(
size,
block=self.writer.is_alive(),
timeout=self.timeout
)
class TwitCastingReader(StreamIO):
def __init__(self, stream: "TwitCastingStream", timeout=None):
super().__init__()
self.session = stream.session
self.stream = stream
self.timeout = timeout or self.session.options.get("stream-timeout")
buffer_size = self.session.get_option("ringbuffer-size")
self.buffer = RingBuffer(buffer_size)
self.wsclient = TwitCastingWsClient(self.buffer,
stream.session,
stream.url,
origin="https://twitcasting.tv/")
def open(self):
self.wsclient.start()
def close(self):
self.wsclient.close()
self.buffer.close()
def read(self, size):
return self.buffer.read(size,
block=self.wsclient.is_alive(),
timeout=self.timeout)
class TwitCastingReader(StreamIO):
def __init__(self, stream, timeout=None, **kwargs):
StreamIO.__init__(self)
self.stream = stream
self.session = stream.session
self.timeout = timeout if timeout else self.session.options.get("stream-timeout")
self.buffer = None
if logger.root.level <= logger.DEBUG:
websocket.enableTrace(True, log)
def open(self):
# Prepare buffer
buffer_size = self.session.get_option("ringbuffer-size")
self.buffer = RingBuffer(buffer_size)
log.debug("Starting WebSocket client")
self.client = TwitCastingWsClient(
self.stream.url,
buffer=self.buffer,
proxy=self.session.get_option("http-proxy")
)
self.client.setDaemon(True)
self.client.start()
def close(self):
self.client.stop()
self.buffer.close()
def read(self, size):
if not self.buffer:
return b""
return self.buffer.read(size, block=(not self.client.stopped.wait(0)),
timeout=self.timeout)
class TestRingBuffer(unittest.TestCase):
BUFFER_SIZE = 8192*4
def setUp(self):
self.buffer = RingBuffer(size=self.BUFFER_SIZE)
def test_write(self):
self.buffer.write(b"1" * 8192)
self.buffer.write(b"2" * 4096)
self.assertEqual(self.buffer.length, 8192 + 4096)
def test_read(self):
self.buffer.write(b"1" * 8192)
self.buffer.write(b"2" * 4096)
self.assertEqual(self.buffer.length, 8192 + 4096)
self.assertEqual(self.buffer.read(4096), b"1" * 4096)
self.assertEqual(self.buffer.read(4096), b"1" * 4096)
self.assertEqual(self.buffer.read(), b"2" * 4096)
self.assertEqual(self.buffer.length, 0)
def test_read_timeout(self):
self.assertRaises(
IOError,
self.buffer.read, timeout=0.1)
def test_write_after_close(self):
self.buffer.close()
self.buffer.write(b"1" * 8192)
self.assertEqual(self.buffer.length, 0)
self.assertTrue(self.buffer.closed)
def test_resize(self):
self.assertEqual(self.buffer.buffer_size, self.BUFFER_SIZE)
self.buffer.resize(self.BUFFER_SIZE*2)
self.assertEqual(self.buffer.buffer_size, self.BUFFER_SIZE*2)
def test_free(self):
self.assertEqual(self.buffer.free, self.BUFFER_SIZE)
self.buffer.write(b'1' * 100)
self.assertEqual(self.buffer.free, self.BUFFER_SIZE-100)
class TestRingBuffer(unittest.TestCase):
BUFFER_SIZE = 8192 * 4
def setUp(self):
self.buffer = RingBuffer(size=self.BUFFER_SIZE)
def test_write(self):
self.buffer.write(b"1" * 8192)
self.buffer.write(b"2" * 4096)
self.assertEqual(self.buffer.length, 8192 + 4096)
def test_read(self):
self.buffer.write(b"1" * 8192)
self.buffer.write(b"2" * 4096)
self.assertEqual(self.buffer.length, 8192 + 4096)
self.assertEqual(self.buffer.read(4096), b"1" * 4096)
self.assertEqual(self.buffer.read(4096), b"1" * 4096)
self.assertEqual(self.buffer.read(), b"2" * 4096)
self.assertEqual(self.buffer.length, 0)
def test_read_timeout(self):
self.assertRaises(
IOError,
self.buffer.read, timeout=0.1)
def test_write_after_close(self):
self.buffer.close()
self.buffer.write(b"1" * 8192)
self.assertEqual(self.buffer.length, 0)
self.assertTrue(self.buffer.closed)
def test_resize(self):
self.assertEqual(self.buffer.buffer_size, self.BUFFER_SIZE)
self.buffer.resize(self.BUFFER_SIZE * 2)
self.assertEqual(self.buffer.buffer_size, self.BUFFER_SIZE * 2)
def test_free(self):
self.assertEqual(self.buffer.free, self.BUFFER_SIZE)
self.buffer.write(b'1' * 100)
self.assertEqual(self.buffer.free, self.BUFFER_SIZE - 100)
class SegmentedStreamReader(StreamIO):
__worker__ = SegmentedStreamWorker
__writer__ = SegmentedStreamWriter
def __init__(self, stream, timeout=None):
StreamIO.__init__(self)
self.session = stream.session
self.stream = stream
if not timeout:
timeout = self.session.options.get("stream-timeout")
self.timeout = timeout
def open(self):
buffer_size = self.session.get_option("ringbuffer-size")
self.buffer = RingBuffer(buffer_size)
self.writer = self.__writer__(self)
self.worker = self.__worker__(self)
self.writer.start()
self.worker.start()
def close(self):
self.worker.close()
self.writer.close()
self.buffer.close()
current = current_thread()
if current is not self.worker: # pragma: no branch
self.worker.join(timeout=self.timeout)
if current is not self.writer: # pragma: no branch
self.writer.join(timeout=self.timeout)
def read(self, size):
if not self.buffer:
return b""
return self.buffer.read(size, block=self.writer.is_alive(),
timeout=self.timeout)
