def _match_token(self, token, data, ini):
pos = ini
if self.parse_state[token] >= 0:
end = len(BogusDeserializer.tokens[token])
if end > len(data) - ini + self.parse_state[token]:
end = len(data) - ini + self.parse_state[token]
text = BogusDeserializer.tokens[token][self.parse_state[token]:end]
if data[ini:ini + end - self.parse_state[token]] == text:
pos = ini + end - self.parse_state[token]
self.parse_state[token] = end
if self.parse_state[token] == \
len(BogusDeserializer.tokens[token]):
self.parse_state = [-1, -1, -1]
self.parse_state[token] = -2
else:
self.parse_state[token] = -1
if token == 0 and self.parse_state[0] == -2:
end = data.find('\n', pos)
if end == -1:
self.param_data += data[pos:]
else:
self.param_data += data[pos:end]
parts = self.param_data.split('/')
self.reset()
return int(parts[0]), float(parts[1])
elif token == 1 and self.parse_state[1] == -2:
self.reset()
self.consumed_data = pos
return events.Command('', 'ztreamy-command',
'Event-Source-Finished')
elif token == 2 and self.parse_state[2] == -2:
self.reset()
self.consumed_data = pos
return events.Command('', 'ztreamy-command', 'Set-Compression')
return None
def _send_closing_event(self):
# time.sleep(0.5)
event = events.Command(self.source_id, 'ztreamy-command',
'Event-Source-Finished')
pub = EventPublisher(event, self.publishers, add_timestamp=False)
self._pending_events.append(pub)
pub.publish()
def _send_init_event(self):
event = events.Command(self.source_id, 'ztreamy-command',
'Event-Source-Started')
pub = EventPublisher(event, self.publishers, add_timestamp=False)
self._pending_events.append(pub)
self.io_loop.add_timeout(time.time() + self.initial_delay, pub.publish)
def dispatch(self, evs):
num_clients = (len(self.streaming_clients) +
len(self.one_time_clients) +
len(self.unsynced_compressed_streaming_clients) +
len(self.compressed_streaming_clients) +
len(self.local_clients))
logging.info('Sending %r events to %r clients', len(evs), num_clients)
self.recent_events.append_events(evs)
self._next_client_cleanup -= 1
if self._next_client_cleanup == 0:
self.clean_closed_clients()
if isinstance(evs, list):
if evs == []:
self._periods_since_last_event += 1
if self._periods_since_last_event > 20 and self._auto_finish:
logger.logger.server_closed(num_clients)
self.close()
self.ioloop.stop()
# Use the following line for the experiments
## if False:
elif ((num_clients > 0 or len(self.priority_clients) > 0)
and self._periods_since_last_event > 20):
logging.info('Sending Test-Connection event')
evs = [
events.Command('', 'ztreamy-command',
'Test-Connection')
]
self._periods_since_last_event = 0
self.dispatch_priority(evs)
else:
return
else:
raise ZtreamyException('Bad event type', 'send_event')
self._periods_since_last_event = 0
if len(self.unsynced_compressed_streaming_clients) > 0:
if (len(self.compressed_streaming_clients) == 0
or self._num_events_since_sync > param_max_events_sync):
self._sync_compressor()
if num_clients > 0:
logging.info('Compressed clients: %d synced; %d unsynced'%\
(len(self.compressed_streaming_clients),
len(self.unsynced_compressed_streaming_clients)))
serialized = ztreamy.serialize_events(evs)
for client in self.streaming_clients:
self._send(serialized, client)
for client in self.unsynced_compressed_streaming_clients:
self._send(serialized, client)
for client in self.local_clients:
if not client.closed:
client._send_events(evs)
for client in self.one_time_clients:
self._send(serialized, client)
client.close()
if len(self.compressed_streaming_clients) > 0:
compressed_data = (self._compressor.compress(serialized) +
self._compressor.flush(zlib.Z_SYNC_FLUSH))
for client in self.compressed_streaming_clients:
self._send(compressed_data, client)
for e in evs:
logger.logger.event_dispatched(e)
self.one_time_clients = []
self._num_events_since_sync += len(evs)