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(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))