@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; } }
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()); }