How to use

ClusterConnection

in

org.apache.activemq.artemis.core.server.cluster

@Override
public String getTopology() {
 clearIO();
 try {
   return clusterConnection.getTopology().describe();
 } finally {
   blockOnIO();
 }
}

FailbackChecker() {
  TransportConfiguration connector = activeMQServer.getClusterManager().getDefaultConnection(null).getConnector();
  backupListener = new BackupTopologyListener(activeMQServer.getNodeID().toString(), connector);
  activeMQServer.getClusterManager().getDefaultConnection(null).addClusterTopologyListener(backupListener);
}

public String describe() {
 StringWriter str = new StringWriter();
 PrintWriter out = new PrintWriter(str);
 out.println("Information on " + this);
 out.println("*******************************************************");
 for (ClusterConnection conn : cloneClusterConnections()) {
   out.println(conn.describe());
 }
 out.println("*******************************************************");
 return str.toString();
}

@Override
public void stop() throws Exception {
 clearIO();
 try {
   clusterConnection.stop();
   clusterConnection.flushExecutor();
 } finally {
   blockOnIO();
 }
}

@Override
public void start() throws Exception {
 clearIO();
 try {
   clusterConnection.start();
   clusterConnection.flushExecutor();
 } finally {
   blockOnIO();
 }
}

protected String clusterDescription(ActiveMQServer server) {
 String br = "-------------------------\n";
 String out = br;
 out += "ActiveMQ Artemis server " + server + "\n";
 ClusterManager clusterManager = server.getClusterManager();
 if (clusterManager == null) {
   out += "N/A";
 } else {
   for (ClusterConnection cc : clusterManager.getClusterConnections()) {
    out += cc.describe() + "\n";
    out += cc.getTopology().describe();
   }
 }
 out += "\n\nfull topology:";
 return out + br;
}

activeMQServer.getStorageManager().startReplication(replicationManager, activeMQServer.getPagingManager(), activeMQServer.getNodeID().toString(), isFailBackRequest && replicatedPolicy.isAllowAutoFailBack(), replicatedPolicy.getInitialReplicationSyncTimeout());
clusterConnection.nodeAnnounced(System.currentTimeMillis(), activeMQServer.getNodeID().toString(), replicatedPolicy.getGroupName(), replicatedPolicy.getScaleDownGroupName(), pair, true);
  BackupTopologyListener listener1 = new BackupTopologyListener(activeMQServer.getNodeID().toString(), clusterConnection.getConnector());
  clusterConnection.addClusterTopologyListener(listener1);
  if (listener1.waitForBackup()) {

private void setupNotificationConsumer() throws Exception {
 if (flowRecord != null) {
   if (logger.isDebugEnabled()) {
    logger.debug("Setting up notificationConsumer between " + this.clusterConnection.getConnector() +
            " and " +
            flowRecord.getBridge().getForwardingConnection() +
            " clusterConnection = " +
            this.clusterConnection.getName() +
            " on server " +
            clusterConnection.getServer());
    clusterConnection.getServer().toString().replaceAll(CompositeAddress.SEPARATOR, "_");

@Override
public long getMessagesPendingAcknowledgement() {
 clearIO();
 try {
   return clusterConnection.getMetrics().getMessagesPendingAcknowledgement();
 } finally {
   blockOnIO();
 }
}

/**
* Return the default ClusterConnection to be used case it's not defined by the acceptor
*
* @return default connection
*/
public ClusterConnection getDefaultConnection(TransportConfiguration acceptorConfig) {
 if (acceptorConfig == null) {
   // if the parameter is null, we just return whatever is defined on defaultClusterConnection
   return defaultClusterConnection;
 } else if (defaultClusterConnection != null && defaultClusterConnection.getConnector().isEquivalent(acceptorConfig)) {
   return defaultClusterConnection;
 } else {
   for (ClusterConnection conn : cloneClusterConnections()) {
    if (conn.getConnector().isEquivalent(acceptorConfig)) {
      return conn;
    }
   }
   return null;
 }
}

clusterConnection.stop();
managementService.unregisterCluster(clusterConnection.getName().toString());

protected void waitForClusterConnections(final int node, final int expected) throws Exception {
 ActiveMQServer server = servers[node];
 if (server == null) {
   throw new IllegalArgumentException("No server at " + node);
 }
 ClusterManager clusterManager = server.getClusterManager();
 long start = System.currentTimeMillis();
 int nodesCount;
 do {
   nodesCount = 0;
   for (ClusterConnection clusterConn : clusterManager.getClusterConnections()) {
    Map<String, String> nodes = clusterConn.getNodes();
    for (String id : nodes.keySet()) {
      if (clusterConn.isNodeActive(id)) {
       nodesCount++;
      }
    }
   }
   if (nodesCount == expected) {
    return;
   }
   Thread.sleep(10);
 }
 while (System.currentTimeMillis() - start < ActiveMQTestBase.WAIT_TIMEOUT);
 log.error(clusterDescription(servers[node]));
 Assert.assertEquals("Timed out waiting for cluster connections for server " + node, expected, nodesCount);
}

@Override
public Map<String, Object> getBridgeMetrics(String nodeId) {
 clearIO();
 try {
   final BridgeMetrics bridgeMetrics = clusterConnection.getBridgeMetrics(nodeId);
   return bridgeMetrics != null ? bridgeMetrics.convertToMap() : null;
 } finally {
   blockOnIO();
 }
}

public OpenWireProtocolManager(OpenWireProtocolManagerFactory factory, ActiveMQServer server) {
 this.factory = factory;
 this.server = server;
 this.wireFactory = new OpenWireFormatFactory();
 // preferred prop, should be done via config
 wireFactory.setCacheEnabled(false);
 advisoryProducerId.setConnectionId(ID_GENERATOR.generateId());
 scheduledPool = server.getScheduledPool();
 this.wireFormat = (OpenWireFormat) wireFactory.createWireFormat();
 final ClusterManager clusterManager = this.server.getClusterManager();
 ClusterConnection cc = clusterManager.getDefaultConnection(null);
 if (cc != null) {
   cc.addClusterTopologyListener(this);
 }
}

@Override
public Map<String, String> getNodes() throws Exception {
 clearIO();
 try {
   return clusterConnection.getNodes();
 } finally {
   blockOnIO();
 }
}

public void clear() {
 for (Bridge bridge : bridges.values()) {
   try {
    bridge.stop();
   } catch (Exception e) {
    ActiveMQServerLogger.LOGGER.warn(e.getMessage(), e);
   }
 }
 bridges.clear();
 for (ClusterConnection clusterConnection : clusterConnections.values()) {
   try {
    clusterConnection.stop();
   } catch (Exception e) {
    ActiveMQServerLogger.LOGGER.failedToStopClusterConnection(e);
   }
 }
 clearClusterConnections();
}

protected void stopClusterConnections(final int... nodes) throws Exception {
 for (int node : nodes) {
   if (servers[node].isStarted()) {
    for (ClusterConnection cc : servers[node].getClusterManager().getClusterConnections()) {
      cc.stop();
      cc.flushExecutor();
    }
   }
 }
}

@Override
public long getMessagesAcknowledged() {
 clearIO();
 try {
   return clusterConnection.getMetrics().getMessagesAcknowledged();
 } finally {
   blockOnIO();
 }
}

ClusterConnectionImpl clusterConnection = (ClusterConnectionImpl) ccs.iterator().next();
Topology topology = clusterConnection.getTopology();
TransportConfiguration nodeConnector = liveServer.getClusterManager().getClusterConnections().iterator().next().getConnector();
do {
 Collection<TopologyMemberImpl> members = topology.getMembers();

protected void verifyBridgeMetrics(final int node, final String clusterName, final String bridgeNodeId,
   final long expectedMessagesPendingAcknowledgement, final long expectedMessagesAcknowledged) {
 final ClusterConnection clusterConnection = servers[node].getClusterManager().getClusterConnection(clusterName);
 final BridgeMetrics bridgeMetrics = clusterConnection.getBridgeMetrics(bridgeNodeId);
 assertEquals(expectedMessagesPendingAcknowledgement, bridgeMetrics.getMessagesPendingAcknowledgement());
 assertEquals(expectedMessagesAcknowledged, bridgeMetrics.getMessagesAcknowledged());
}