def send(self, receiver_address, msg):
assert isaddress(receiver_address)
assert not isinstance(msg, (Ack, BaseError)), msg
log.info("SENDING {} > {} : {}".format(pex(self.raiden.address),
pex(receiver_address), msg))
host_port = self.discovery.get(receiver_address)
data = msg.encode()
msghash = sha3(data)
self.tries[msghash] = self.max_tries
log.debug("MSGHASH SENT", msghash=pex(msghash))
assert len(data) < self.max_message_size
def repeater():
while self.tries.get(msghash, 0) > 0:
if not self.repeat_messages and self.tries[
msghash] < self.max_tries:
raise Exception("DEACTIVATED MSG resents {} {}".format(
pex(receiver_address), msg))
self.tries[msghash] -= 1
self.transport.send(self.raiden, host_port, data)
gevent.sleep(self.try_interval)
# Each sent msg must be acked. When msg is acked its hash is removed from self.tries
if msghash in self.tries:
assert False, "Node does not reply, fixme suspend node"
gevent.spawn(repeater)
def send(self, receiver_address, msg):
assert isaddress(receiver_address)
assert not isinstance(msg, (Ack, BaseError)), msg
log.info("SENDING {} > {} : {}".format(pex(self.raiden.address),
pex(receiver_address), msg))
host_port = self.discovery.get(receiver_address)
data = msg.encode()
msghash = sha3(data)
self.tries[msghash] = self.max_tries
log.debug("MSGHASH SENT", msghash=pex(msghash))
assert len(data) < self.max_message_size
def repeater():
while self.tries.get(msghash, 0) > 0:
if not self.repeat_messages and self.tries[msghash] < self.max_tries:
raise Exception(
"DEACTIVATED MSG resents {} {}".format(pex(receiver_address), msg))
self.tries[msghash] -= 1
self.transport.send(self.raiden, host_port, data)
gevent.sleep(self.try_interval)
# Each sent msg must be acked. When msg is acked its hash is removed from self.tries
if msghash in self.tries:
assert False, "Node does not reply, fixme suspend node"
gevent.spawn(repeater)
def send(self, sender, host_port, data):
print 'in send unreliable', self.network.counter, self.network.counter % self.droprate
if self.network.counter % self.droprate:
self.network.send(sender, host_port, data)
else:
self.network.track_send(sender, host_port, data)
print('dropped data {}'.format(pex(sha3(data))))
def send_ack(self, receiver_address, msg):
assert isinstance(msg, (Ack, BaseError))
assert isaddress(receiver_address)
host_port = self.discovery.get(receiver_address)
self.transport.send(self.raiden, host_port, msg.encode())
self.sent_acks[msg.echo] = (receiver_address, msg)
log.debug("MSGHASH SENT", echo=pex(msg.echo))
def send_ack(self, receiver_address, msg):
assert isinstance(msg, (Ack, BaseError))
assert isaddress(receiver_address)
host_port = self.discovery.get(receiver_address)
self.transport.send(self.raiden, host_port, msg.encode())
self.sent_acks[msg.echo] = (receiver_address, msg)
log.debug("MSGHASH SENT", echo=pex(msg.echo))
def send(self, sender, host_port, data):
log.debug('in send unreliable', counter=self.network.counter,
drop_this_one=not(self.network.counter % self.droprate))
if self.network.counter % self.droprate:
self.network.send(sender, host_port, data)
else:
self.network.track_send(sender, host_port, data)
log.debug('dropped', data=format(pex(sha3(data))))
def send(self, sender, host_port, data):
log.debug('in send unreliable', counter=self.network.counter,
drop_this_one=not(self.network.counter % self.droprate))
if self.network.counter % self.droprate:
self.network.send(sender, host_port, data)
else:
self.network.track_send(sender, host_port, data)
log.debug('dropped', data=format(pex(sha3(data))))
def send(self, sender, host_port, message):
for cb in self.on_send_cbs:
cb(sender, host_port, message)
print 'in send unreliable', self.counter, self.counter % self.droprate
self.counter += 1
if (self.counter - 1) % self.droprate:
self.protocols[host_port].receive(message)
else:
print('dropped message {}'.format(pex(sha3(message))))
def repeater():
while self.tries.get(msghash, 0) > 0:
if not self.repeat_messages and self.tries[msghash] < self.max_tries:
raise Exception(
"DEACTIVATED MSG resents {} {}".format(pex(receiver_address), msg))
self.tries[msghash] -= 1
self.transport.send(self.raiden, host_port, data)
gevent.sleep(self.try_interval)
if msghash in self.tries:
assert False, "Node does not reply, fixme suspend node"
def repeater():
while self.tries.get(msghash, 0) > 0:
if not self.repeat_messages and self.tries[
msghash] < self.max_tries:
raise Exception("DEACTIVATED MSG resents {} {}".format(
pex(receiver_address), msg))
self.tries[msghash] -= 1
self.transport.send(self.raiden, host_port, data)
gevent.sleep(self.try_interval)
# Each sent msg must be acked. When msg is acked its hash is removed from self.tries
if msghash in self.tries:
assert False, "Node does not reply, fixme suspend node"
def send(self, receiver_address, msg):
assert isaddress(receiver_address)
assert not isinstance(msg, (Ack, BaseError)), msg
print "SENDING {} > {} : {}".format(pex(self.raiden.address), pex(receiver_address), msg)
host_port = self.discovery.get(receiver_address)
msghash = msg.hash
self.tries[msghash] = self.max_tries
data = rlp.encode(msg)
assert len(data) < self.max_message_size
def repeater():
while self.tries.get(msghash, 0) > 0:
if not self.repeat_messages and self.tries[msghash] < self.max_tries:
raise Exception(
"DEACTIVATED MSG resents {} {}".format(pex(receiver_address), msg))
self.tries[msghash] -= 1
self.transport.send(self.raiden, host_port, data)
gevent.sleep(self.try_interval)
if msghash in self.tries:
assert False, "Node does not reply, fixme suspend node"
gevent.spawn(repeater)
def receive(self, data):
assert len(data) < self.max_message_size
# check if we handled this message already, if so repeat Ack
msghash = sha3(data)
if msghash in self.sent_acks:
# assert False, "DEACTIVATED ACK RESENTS"
return self.send_ack(*self.sent_acks[msghash])
# note, we ignore the sending endpoint, as this can not be known w/ UDP
msg = messages.decode(data)
# handle Acks
if isinstance(msg, Ack):
log.debug("ACK MSGHASH RECEIVED echo=", echo=pex(msg.echo))
del self.tries[msg.echo]
return
assert isinstance(msg, Secret) or msg.sender
self.raiden.on_message(msg, msghash)
def receive(self, data):
assert len(data) < self.max_message_size
# check if we handled this message already, if so repeat Ack
msghash = sha3(data)
if msghash in self.sent_acks:
# assert False, "DEACTIVATED ACK RESENTS"
return self.send_ack(*self.sent_acks[msghash])
# note, we ignore the sending endpoint, as this can not be known w/ UDP
msg = messages.decode(data)
# handle Acks
if isinstance(msg, Ack):
print "ACK MSGHASH RECEIVED", pex(msg.echo)
del self.tries[msg.echo]
return
assert isinstance(msg, Secret) or msg.sender
self.raiden.on_message(msg, msghash)
def __repr__(self):
return '<{} {}>'.format(self.__class__.__name__, pex(self.raiden.address))
def __repr__(self):
return '<{} {}>'.format(self.__class__.__name__, pex(self.hash))
def __repr__(self):
try:
h = self.hash
except Exception:
h = ''
return '<%s(%s)>' % (self.__class__.__name__, pex(h))
def __repr__(self):
return '<{} {}>'.format(self.__class__.__name__, pex(self.raiden.address))
