Best code snippets using org.jgroups.stack(Showing top 15 results out of 315)

public void init() throws Exception {
  List<Protocol> protocols=getProtocols();
  Collections.reverse(protocols);
  top_prot=Configurator.connectProtocols(protocols);
  top_prot.setUpProtocol(this);
  this.setDownProtocol(top_prot);
  bottom_prot=getBottomProtocol();
  Configurator.setDefaultValues(protocols);
  initProtocolStack();
}

private NakReceiverWindow createNakReceiverWindow(Address sender, long initial_seqno) {
  NakReceiverWindow win=new NakReceiverWindow(sender, this, initial_seqno, timer, use_range_based_retransmitter,
                        xmit_table_num_rows, xmit_table_msgs_per_row,
                        xmit_table_resize_factor, xmit_table_max_compaction_time, false);
  if(exponential_backoff > 0)
    win.setRetransmitTimeouts(new ExponentialInterval(exponential_backoff));
  else
    win.setRetransmitTimeouts(new StaticInterval(retransmit_timeouts));
  if(xmit_stagger_timeout > 0)
    win.setXmitStaggerTimeout(xmit_stagger_timeout);
  return win;
}

protected void moveStubToReconnects(RouterStub stub) {
  if(stub == null) return;
  remove(stub);
  if(add(new Target(stub.local(), stub.remote(), stub.receiver()))) {
    log.debug("connection to %s closed, trying to re-establish connection", stub.remote());
    startReconnector();
  }
}

public RouterStub createAndRegisterStub(IpAddress local, IpAddress router_addr) {
  RouterStub stub=new RouterStub(local, router_addr, use_nio, this);
  RouterStub old_stub=unregisterStub(router_addr);
  if(old_stub != null)
    old_stub.destroy();
  add(stub);
  return stub;
}

public void connectStubs() {
  for(RouterStub stub : stubs) {
    try {
      if(!stub.isConnected())
        stub.connect(cluster_name, local_addr, logical_name, phys_addr);
    }
    catch (Throwable e) {
      moveStubToReconnects(stub);
    }
  }
}

protected RouterStub find(IpAddress router_addr) {
  for(RouterStub stub: stubs) {
    IpAddress addr=stub.gossipRouterAddress();
    if(addr != null && addr.equals(router_addr))
      return stub;
  }
  return null;
}

protected void handleRegister(Address sender, GossipData request) {
  String          group=request.getGroup();
  Address         addr=request.getAddress();
  PhysicalAddress phys_addr=request.getPhysicalAddress();
  String          logical_name=request.getLogicalName();
  addAddressMapping(sender, group, addr, phys_addr, logical_name);
}

public void disconnectStubs() {
  stopReconnector();
  for(RouterStub stub : stubs) {
    try {
      stub.disconnect(cluster_name, local_addr);
    }
    catch (Throwable e) {
    }
  }       
}

@Override
public void connectionClosed(Connection conn, String reason) {
  if(close_listener != null)
    close_listener.closed(this);
}

/** Creates a fork-stack from the configuration, initializes all protocols (setting values),
 * sets the protocol stack as top protocol, connects the protocols and calls init() on them. Returns
 * the protocols in a list, from bottom to top */
protected static List<Protocol> createProtocols(ProtocolStack stack, List<ProtocolConfiguration> protocol_configs) throws Exception {
  return Configurator.createProtocols(protocol_configs,stack);
}

/**
 * Removes a protocol from the stack. Stops the protocol and readjusts the linked lists of
 * protocols.
 * @param prot_name The name of the protocol. Since all protocol names in a stack have to be unique
 *                  (otherwise the stack won't be created), the name refers to just 1 protocol.
 * @exception Exception Thrown if the protocol cannot be stopped correctly.
 */
public Protocol removeProtocol(String prot_name) {
  if(prot_name == null) return null;
  return removeProtocol(findProtocol(prot_name));
}

public void setup(List<ProtocolConfiguration> configs) throws Exception {
  if(top_prot == null) {
    top_prot=new Configurator(this).setupProtocolStack(configs);
    top_prot.setUpProtocol(this);
    this.setDownProtocol(top_prot);
    bottom_prot=getBottomProtocol();
    initProtocolStack();
  }
}

/**
 * Applies action to all RouterStubs that are connected
 * @param action
 */
public void forEach(Consumer action) {
  for(RouterStub stub: stubs) {
    if(stub.isConnected())
      apply(stub, action);
  }
}

public Protocol removeProtocol(Class prot) {
  if(prot == null)
    return null;
  return removeProtocol(findProtocol(prot));
}

public void setup(ProtocolStack stack) throws Exception {
  if(top_prot == null) {
    top_prot=new Configurator(this).setupProtocolStack(stack);
    top_prot.setUpProtocol(this);
    this.setDownProtocol(top_prot);
    bottom_prot=getBottomProtocol();
    initProtocolStack();
  }
}