protected void sendEof(Address requester) { try { Message eof_msg=new Message(requester).putHeader(getId(), new StateHeader(StateHeader.STATE_EOF)); log.trace("%s --> EOF --> %s", local_addr, requester); down(eof_msg); } catch(Throwable t) { log.error("%s: failed sending EOF to %s", local_addr, requester); } }
protected synchronized boolean handleMessage(Address sender, byte msg_bit) { boolean retval=false; if(this.bit == msg_bit) { this.bit^=1; retval=true; } byte ack_bit=(byte)(this.bit ^ 1); Message ack=new Message(sender).putHeader(id, new ABPHeader(Type.ack, ack_bit)); log.trace("%s: --> %s.ack(%d)", local_addr, sender, ack_bit); down_prot.down(ack); return retval; }
protected void sendRequestForFirstSeqno(Address dest) { if(last_sync_sent.addIfAbsentOrExpired(dest)) { Message msg=new Message(dest).setFlag(Message.Flag.OOB) .putHeader(this.id, UnicastHeader3.createSendFirstSeqnoHeader(timestamper.incrementAndGet())); log.trace("%s --> SEND_FIRST_SEQNO(%s)", local_addr, dest); down_prot.down(msg); } }
protected void sendLockInfoRequestTo(Buffer buf, Address[] mbrs, Address exclude) { Stream.of(mbrs).filter(m -> m != null && !Objects.equals(m, exclude)).forEach(dest -> { Message msg=new Message(dest, buf).putHeader(id, new LockingHeader()); if(bypass_bundling) msg.setFlag(Message.Flag.DONT_BUNDLE); try { down_prot.down(msg); } catch(Throwable t) { log.error("%s: failed sending LOCK_INFO_REQ to %s: %s", local_addr, dest, t); } }); }
public void run() { FD.FdHeader hdr; synchronized(suspected_members) { if(suspected_members.isEmpty()) { stop(); return; } hdr=new FdHeader(FdHeader.SUSPECT); hdr.mbrs=new ArrayList<>(suspected_members); hdr.from=local_addr; } Message suspect_msg=new Message().setFlag(Message.Flag.INTERNAL).putHeader(id, hdr); log.trace("%s: broadcasting SUSPECT message (suspects=%s)", local_addr, suspected_members); down_prot.down(suspect_msg); }
/** Sends or broadcasts a I_HAVE_SOCK response. If 'dst' is null, the reponse will be broadcast, otherwise it will be unicast back to the requester */ protected void sendIHaveSockMessage(Address dst, Address mbr, IpAddress addr) { Message msg=new Message(dst).setFlag(Message.Flag.INTERNAL).setTransientFlag(Message.TransientFlag.DONT_LOOPBACK); FdHeader hdr=new FdHeader(FdHeader.I_HAVE_SOCK, mbr); hdr.sock_addr=addr; msg.putHeader(this.id, hdr); down_prot.down(msg); }
protected void sendSeqnoResponse(Address original_sender,long seqno, int num_seqnos) { SequencerHeader hdr = new SequencerHeader(SequencerHeader.RESPONSE, seqno, num_seqnos); Message ucast_msg = new Message(original_sender).putHeader(this.id, hdr); if (log.isTraceEnabled()) log.trace(local_addr + ": sending seqno response to " + original_sender + ":: new_seqno=" + seqno + ", num_seqnos=" + num_seqnos); down_prot.down(ucast_msg); sent_responses++; }
public void run() { log.trace("%s: broadcasting SUSPECT message (suspected_mbrs=%s)", local_addr, suspects); FdHeader hdr; synchronized(suspects) { if(suspects.isEmpty()) { stopTask(); return; } hdr=new FdHeader(FdHeader.SUSPECT).mbrs(new HashSet<>(suspects)); } Message suspect_msg=new Message().setFlag(Message.Flag.INTERNAL).putHeader(id, hdr); // mcast SUSPECT to all members down_prot.down(suspect_msg); }
protected void sendCredit(Address dest, long credits) { if(log.isTraceEnabled()) log.trace("sending %d credits to %s", credits, dest); Message msg=new Message(dest, longToBuffer(credits)) .setFlag(Message.Flag.OOB, Message.Flag.INTERNAL, Message.Flag.DONT_BUNDLE) .putHeader(this.id,getReplenishHeader()); down_prot.down(msg); num_credit_responses_sent++; }
private void sendLeaveResponses(Collection<Address> leaving_members) { for(Address address: leaving_members){ Message msg=new Message(address).setFlag(Message.Flag.OOB, Message.Flag.INTERNAL, Message.Flag.NO_RELIABILITY) .putHeader(gms.getId(), new GMS.GmsHeader(GMS.GmsHeader.LEAVE_RSP)); log.trace("%s: sending LEAVE response to %s", gms.local_addr, address); gms.getDownProtocol().down(msg); } }
protected void send(Address dest, Request req) { Message msg=new Message(dest, Util.streamableToBuffer(req)).putHeader(id, new LockingHeader()); if(bypass_bundling) msg.setFlag(Message.Flag.DONT_BUNDLE); log.trace("%s --> %s: %s", local_addr, dest == null? "ALL" : dest, req); try { down_prot.down(msg); } catch(Exception ex) { log.error("%s: failed sending %s request: %s", local_addr, req.type, ex); } }
protected void broadcastUnuspectMessage(Address mbr) { if(mbr == null) return; log.debug("%s: broadcasting unsuspect(%s)", local_addr, mbr); // 1. Send a SUSPECT message right away; the broadcast task will take some time to send it (sleeps first) FdHeader hdr=new FdHeader(FdHeader.UNSUSPECT).mbrs(Collections.singleton(mbr)); Message suspect_msg=new Message().setFlag(Message.Flag.INTERNAL).putHeader(this.id, hdr); down_prot.down(suspect_msg); }
protected void sendAck(Address dst, long seqno, short conn_id) { if(!running) // if we are disconnected, then don't send any acks which throw exceptions on shutdown return; Message ack=new Message(dst).setFlag(Message.Flag.INTERNAL). putHeader(this.id, UnicastHeader3.createAckHeader(seqno, conn_id, timestamper.incrementAndGet())); if(is_trace) log.trace("%s --> ACK(%s: #%d)", local_addr, dst, seqno); try { down_prot.down(ack); num_acks_sent++; } catch(Throwable t) { log.error(Util.getMessage("FailedSendingAck"), local_addr, seqno, dst, t); } }
protected void send(Address dest, Buffer buffer) { try { Message rsp_msg=new Message(dest, buffer).putHeader(id, new CounterHeader()); if(bypass_bundling) rsp_msg.setFlag(Message.Flag.DONT_BUNDLE); down_prot.down(rsp_msg); } catch(Exception ex) { log.error(Util.getMessage("FailedSendingMessageTo") + dest + ": " + ex); } }