def recv_token(self, payload):
try:
r = self.port.queue.com_write(Token.decode(payload['token']), self.peer_id, payload['sequencenbr'])
if r == COMMIT_RESPONSE.handled:
# New token, trigger loop
self.trigger_loop()
if r == COMMIT_RESPONSE.invalid:
ok = False
else:
# Either old or new token, ack it
ok = True
_log.debug("recv_token %s %s: %d %s => %s %d" % (self.port.id, self.port.name, payload['sequencenbr'], payload['token'], "True" if ok else "False", r))
except QueueFull:
# Queue full just send NACK
ok = False
if self.pressure[(self.pressure_count - 1) % PRESSURE_LENGTH] != payload['sequencenbr']:
self.pressure[self.pressure_count % PRESSURE_LENGTH] = payload['sequencenbr']
self.pressure_count += 1
self.pressure_last = payload['sequencenbr']
reply = {
'cmd': 'TOKEN_REPLY',
'port_id': payload['port_id'],
'peer_port_id': payload['peer_port_id'],
'sequencenbr': payload['sequencenbr'],
'value': 'ACK' if ok else 'NACK'
}
self.tunnel.send(reply)
def recv_token(self, payload):
try:
r = self.port.queue.com_write(Token.decode(payload['token']), self.peer_id, payload['sequencenbr'])
if r == COMMIT_RESPONSE.handled:
# New token, trigger loop
self.scheduler.tunnel_rx(self)
if r == COMMIT_RESPONSE.invalid:
ok = False
else:
# Either old or new token, ack it
ok = True
_log.debug("recv_token %s %s: %d %s => %s %d" % (self.port.id, self.port.name, payload['sequencenbr'], payload['token'], "True" if ok else "False", r))
except QueueFull:
# Queue full just send NACK
_log.debug("REMOTE QUEUE FULL %d %s" % (self.pressure_count, self.port.id))
ok = False
if self.pressure[(self.pressure_count - 1) % PRESSURE_LENGTH][0] != payload['sequencenbr']:
# Log a QueueFull event
self.pressure[self.pressure_count % PRESSURE_LENGTH] = (payload['sequencenbr'], time.time())
self.pressure_count += 1
# Inform scheduler about potential pressure event
self.scheduler.trigger_pressure_event(self.port.owner.id)
self.pressure_last = payload['sequencenbr']
reply = {
'cmd': 'TOKEN_REPLY',
'port_id': payload['port_id'],
'peer_port_id': payload['peer_port_id'],
'sequencenbr': payload['sequencenbr'],
'value': 'ACK' if ok else 'NACK'
}
self.tunnel.send(reply)
def _set_state(self, state):
self._type = state.get('queuetype', "fanout_fifo")
self.fifo = [Token.decode(d) for d in state['fifo']]
self.N = state['N']
self.readers = set(state['readers'])
self.write_pos = state['write_pos']
self.read_pos = state['read_pos']
self.tentative_read_pos = state['tentative_read_pos']
def _set_state(self, state):
self._type = state.get('queuetype',"fanout_fifo")
self.fifo = [Token.decode(d) for d in state['fifo']]
self.N = state['N']
self.readers = set(state['readers'])
self.write_pos = state['write_pos']
self.read_pos = state['read_pos']
self.tentative_read_pos = state['tentative_read_pos']
def _set_state(self, state):
self._type = state.get('queuetype')
self.fifo = {p: [Token.decode(t) for t in tokens] for p, tokens in state['fifo'].items()}
self.N = state['N']
self.writers = state['writers']
self.write_pos = state['write_pos']
self.read_pos = state['read_pos']
self.tentative_read_pos = state['tentative_read_pos']
self.tags = state.get("tags", {})
self.tags_are_ordering = state.get("tags-are-ordering", False)
def _set_state(self, state):
self._type = state.get('queuetype')
self.fifo = {p: [Token.decode(t) for t in tokens] for p, tokens in state['fifo'].items()}
self.N = state['N']
self.readers = state['readers']
self.write_pos = state['write_pos']
self.read_pos = state['read_pos']
self.tentative_read_pos = state['tentative_read_pos']
if len(self.readers) > self.nbr_peers:
# If the peer has been replicated just set it to nbr connected
self.nbr_peers = len(self.readers)
def recv_token(self, payload):
ok =False
# Drop any tokens that we can't write to fifo or is out of sequence
if self.port.fifo.can_write() and self.port.fifo.write_pos == payload['sequencenbr']:
self.port.fifo.write(Token.decode(payload['token']))
self.trigger_loop()
ok = True
elif self.port.fifo.write_pos > payload['sequencenbr']:
# Other side resent a token we already have received (can happen after a reconnect if our previous ACK was lost), just ACK
ok = True
reply = {'cmd': 'TOKEN_REPLY', 'port_id':payload['port_id'], 'peer_port_id': payload['peer_port_id'], 'sequencenbr': payload['sequencenbr'], 'value': 'ACK' if ok else 'NACK'}
self.tunnel.send(reply)
def _set_state(self, state):
self._type = state.get("queuetype")
self.fifo = {p: [Token.decode(t) for t in self.fifo] for p, t in state["fifo"].items()}
self.N = state["N"]
self.readers = state["readers"]
self.write_pos = state["write_pos"]
self.read_pos = state["read_pos"]
self.tentative_read_pos = state["tentative_read_pos"]
self.token_state = state["token_state"]
self.reader_turn = state["reader_turn"]
self.turn_pos = state["turn_pos"]
self._set_turn()
def _set_state(self, state):
self._type = state.get('queuetype')
self.fifo = {
p: [Token.decode(t) for t in tokens]
for p, tokens in state['fifo'].items()
}
self.N = state['N']
self.writers = state['writers']
self.write_pos = state['write_pos']
self.read_pos = state['read_pos']
self.tentative_read_pos = state['tentative_read_pos']
self.tags = state.get("tags", {})
self.tags_are_ordering = state.get("tags-are-ordering", False)
def _set_state(self, state):
self._type = state.get('queuetype')
self.fifo = {
p: [Token.decode(t) for t in self.fifo]
for p, t in state['fifo'].items()
}
self.N = state['N']
self.readers = state['readers']
self.write_pos = state['write_pos']
self.read_pos = state['read_pos']
self.tentative_read_pos = state['tentative_read_pos']
self.token_state = state['token_state']
self.reader_turn = state["reader_turn"]
self.turn_pos = state["turn_pos"]
self._set_turn()
def recv_token(self, payload):
ok = False
# Drop any tokens that we can't write to fifo or is out of sequence
if self.port.fifo.can_write() and self.port.fifo.write_pos == payload["sequencenbr"]:
self.port.fifo.write(Token.decode(payload["token"]))
self.trigger_loop()
ok = True
elif self.port.fifo.write_pos > payload["sequencenbr"]:
# Other side resent a token we already have received (can happen after a reconnect if our previous ACK was lost), just ACK
ok = True
reply = {
"cmd": "TOKEN_REPLY",
"port_id": payload["port_id"],
"peer_port_id": payload["peer_port_id"],
"sequencenbr": payload["sequencenbr"],
"value": "ACK" if ok else "NACK",
}
self.tunnel.send(reply)
def recv_token(self, payload):
ok = False
# Drop any tokens that we can't write to fifo or is out of sequence
if self.port.fifo.can_write(
) and self.port.fifo.write_pos == payload['sequencenbr']:
self.port.fifo.write(Token.decode(payload['token']))
self.trigger_loop()
ok = True
elif self.port.fifo.write_pos > payload['sequencenbr']:
# Other side resent a token we already have received (can happen after a reconnect if our previous ACK was lost), just ACK
ok = True
reply = {
'cmd': 'TOKEN_REPLY',
'port_id': payload['port_id'],
'peer_port_id': payload['peer_port_id'],
'sequencenbr': payload['sequencenbr'],
'value': 'ACK' if ok else 'NACK'
}
self.tunnel.send(reply)
def recv_token(self, payload):
try:
r = self.port.queue.com_write(Token.decode(payload['token']),
self.peer_id, payload['sequencenbr'])
if r == COMMIT_RESPONSE.handled:
# New token, trigger loop
self.scheduler.tunnel_rx(self)
if r == COMMIT_RESPONSE.invalid:
ok = False
else:
# Either old or new token, ack it
ok = True
_log.debug("recv_token %s %s: %d %s => %s %d" %
(self.port.id, self.port.name, payload['sequencenbr'],
payload['token'], "True" if ok else "False", r))
except QueueFull:
# Queue full just send NACK
_log.debug("REMOTE QUEUE FULL %d %s" %
(self.pressure_count, self.port.id))
ok = False
if self.pressure[(self.pressure_count - 1) %
PRESSURE_LENGTH][0] != payload['sequencenbr']:
# Log a QueueFull event
self.pressure[self.pressure_count %
PRESSURE_LENGTH] = (payload['sequencenbr'],
time.time())
self.pressure_count += 1
# Inform scheduler about potential pressure event
self.scheduler.trigger_pressure_event(self.port.owner.id)
self.pressure_last = payload['sequencenbr']
reply = {
'cmd': 'TOKEN_REPLY',
'port_id': payload['port_id'],
'peer_port_id': payload['peer_port_id'],
'sequencenbr': payload['sequencenbr'],
'value': 'ACK' if ok else 'NACK'
}
self.tunnel.send(reply)
def recv_token(self, payload):
try:
r = self.port.queue.com_write(Token.decode(payload['token']), payload['sequencenbr'])
if r == COMMIT_RESPONSE.handled:
# New token, trigger loop
self.trigger_loop()
if r == COMMIT_RESPONSE.invalid:
ok = False
else:
# Either old or new token, ack it
ok = True
_log.debug("recv_token %s %s: %d %s => %s %d" % (self.port.id, self.port.name, payload['sequencenbr'], payload['token'], "True" if ok else "False", r))
except QueueFull:
# Queue full just send NACK
ok = False
reply = {
'cmd': 'TOKEN_REPLY',
'port_id': payload['port_id'],
'peer_port_id': payload['peer_port_id'],
'sequencenbr': payload['sequencenbr'],
'value': 'ACK' if ok else 'NACK'
}
self.tunnel.send(reply)
def _deserialize_remaining_tokens(self, remaining_tokens):
for peer_id, tokens in remaining_tokens.items():
for token in tokens:
token[1] = Token.decode(token[1])