public static ClusterConnectionConfiguration getReplicationClusterConfiguration(Configuration conf, String replicationCluster) throws ActiveMQIllegalStateException { if (replicationCluster == null || replicationCluster.isEmpty()) return conf.getClusterConfigurations().get(0); for (ClusterConnectionConfiguration clusterConf : conf.getClusterConfigurations()) { if (replicationCluster.equals(clusterConf.getName())) return clusterConf; } throw new ActiveMQIllegalStateException("Missing cluster-configuration for replication-clustername '" + replicationCluster + "'."); }
static void addClusterConnectionConfigs(final OperationContext context, final Configuration configuration, final ModelNode model) throws OperationFailedException { if (model.hasDefined(CommonAttributes.CLUSTER_CONNECTION)) { final List<ClusterConnectionConfiguration> configs = configuration.getClusterConfigurations(); for (Property prop : model.get(CommonAttributes.CLUSTER_CONNECTION).asPropertyList()) { configs.add(createClusterConnectionConfiguration(context, prop.getName(), prop.getValue())); } } }
static void addClusterConnectionConfigs(final OperationContext context, final Configuration configuration, final ModelNode model) throws OperationFailedException { if (model.hasDefined(CommonAttributes.CLUSTER_CONNECTION)) { final List<ClusterConnectionConfiguration> configs = configuration.getClusterConfigurations(); for (Property prop : model.get(CommonAttributes.CLUSTER_CONNECTION).asPropertyList()) { configs.add(createClusterConnectionConfiguration(context, prop.getName(), prop.getValue())); } } }
public synchronized void deploy() throws Exception { if (state == State.STOPPED) { state = State.DEPLOYED; } else { throw new IllegalStateException(); } for (BroadcastGroupConfiguration config : configuration.getBroadcastGroupConfigurations()) { deployBroadcastGroup(config); } for (ClusterConnectionConfiguration config : configuration.getClusterConfigurations()) { deployClusterConnection(config); } /* * only start if we are actually in a cluster * */ clusterController.start(); }
/** * the hack to create the failing condition in certain tests * * @param config */ private void installHack(Configuration config) { if (this.getName().equals("testSendBytesAsLargeOnBridgeOnly")) { for (ClusterConnectionConfiguration conn : config.getClusterConfigurations()) { conn.setMinLargeMessageSize(1000); } } }
@Test public void testParsingClusterConnectionURIs() throws Exception { FileConfigurationParser parser = new FileConfigurationParser(); String configStr = firstPart + "<cluster-connections>\n" + " <cluster-connection-uri name=\"my-cluster\" address=\"multicast://my-discovery-group?messageLoadBalancingType=STRICT;retryInterval=333;connectorName=netty-connector;maxHops=1\"/>\n" + "</cluster-connections>\n" + lastPart; ByteArrayInputStream input = new ByteArrayInputStream(configStr.getBytes(StandardCharsets.UTF_8)); Configuration config = parser.parseMainConfig(input); Assert.assertEquals(1, config.getClusterConfigurations().size()); Assert.assertEquals("my-discovery-group", config.getClusterConfigurations().get(0).getDiscoveryGroupName()); Assert.assertEquals(333, config.getClusterConfigurations().get(0).getRetryInterval()); }
@Override public void config(Configuration liveConfig, Configuration backupConfig) { List<ClusterConnectionConfiguration> ccList = backupConfig.getClusterConfigurations(); assertTrue(ccList.size() > 0); ClusterConnectionConfiguration cc = ccList.get(0); cc.setConnectionTTL(ttlOverride); cc.setClientFailureCheckPeriod(checkPeriodOverride); } };
private void setupCluster(MessageLoadBalancingType messageLoadBalancingType) { for (ActiveMQServer server : servers) { if (server != null) { server.getConfiguration().getClusterConfigurations().clear(); } } // server #0 is connected to server #1 setupClusterConnection("cluster1", 0, 1, "queues", messageLoadBalancingType, 1, 0, 500, isNetty(), true); // server #1 is connected to nobody setupClusterConnection("clusterX", 1, -1, "queues", messageLoadBalancingType, 1, 0, 500, isNetty(), true); }
@Override public synchronized void start() throws Exception { if (started) return; //deploy the backup connectors using the cluster configuration for (ClusterConnectionConfiguration config : configuration.getClusterConfigurations()) { deployBackupConnector(config); } //start each connector and if we are backup and shared store announce ourselves. NB with replication we don't do this //as we wait for replication to start and be notified by the replication manager. for (BackupConnector conn : backupConnectors) { conn.start(); if (server.getHAPolicy().isBackup() && server.getHAPolicy().isSharedStore()) { conn.informTopology(); conn.announceBackup(); } } started = true; }
private static void compareTTLWithCheckPeriod(Configuration configuration) { for (ClusterConnectionConfiguration c : configuration.getClusterConfigurations()) compareTTLWithCheckPeriod(c.getName(), c.getConnectionTTL(), configuration.getConnectionTTLOverride(), c.getClientFailureCheckPeriod()); for (BridgeConfiguration c : configuration.getBridgeConfigurations()) compareTTLWithCheckPeriod(c.getName(), c.getConnectionTTL(), configuration.getConnectionTTLOverride(), c.getClientFailureCheckPeriod()); }
protected void setupClusterConnection(ClusterConnectionConfiguration clusterConf, final boolean netty, final int nodeFrom, final int... nodesTo) { ActiveMQServer serverFrom = servers[nodeFrom]; if (serverFrom == null) { throw new IllegalStateException("No server at node " + nodeFrom); } TransportConfiguration connectorFrom = createTransportConfiguration(netty, false, generateParams(nodeFrom, netty)); serverFrom.getConfiguration().getConnectorConfigurations().put(connectorFrom.getName(), connectorFrom); List<String> pairs = getClusterConnectionTCNames(netty, serverFrom, nodesTo); Configuration config = serverFrom.getConfiguration(); clusterConf.setConnectorName(connectorFrom.getName()).setConfirmationWindowSize(1024).setStaticConnectors(pairs); config.getClusterConfigurations().add(clusterConf); }
protected void setupClusterConnection(final String name, final String address, final MessageLoadBalancingType messageLoadBalancingType, final int maxHops, final boolean netty, final ClusterConfigCallback cb, final int nodeFrom, final int... nodesTo) { ActiveMQServer serverFrom = servers[nodeFrom]; if (serverFrom == null) { throw new IllegalStateException("No server at node " + nodeFrom); } TransportConfiguration connectorFrom = createTransportConfiguration(netty, false, generateParams(nodeFrom, netty)); serverFrom.getConfiguration().getConnectorConfigurations().put(connectorFrom.getName(), connectorFrom); List<String> pairs = getClusterConnectionTCNames(netty, serverFrom, nodesTo); Configuration config = serverFrom.getConfiguration(); ClusterConnectionConfiguration clusterConf = createClusterConfig(name, address, messageLoadBalancingType, maxHops, connectorFrom, pairs); if (cb != null) { cb.configure(clusterConf); } config.getClusterConfigurations().add(clusterConf); }
class OrderedConsumerHolder implements Comparable<OrderedConsumerHolder> { ConsumerHolder consumer; int order; @Override public int compareTo(final OrderedConsumerHolder o) { int thisOrder = order; int otherOrder = o.order; return thisOrder < otherOrder ? -1 : thisOrder == otherOrder ? 0 : 1; } }
protected final void adaptLiveConfigForReplicatedFailBack(TestableServer server) { Configuration configuration = server.getServer().getConfiguration(); final TransportConfiguration backupConnector = getConnectorTransportConfiguration(false); if (server.getServer().getHAPolicy().isSharedStore()) { ClusterConnectionConfiguration cc = configuration.getClusterConfigurations().get(0); Assert.assertNotNull("cluster connection configuration", cc); Assert.assertNotNull("static connectors", cc.getStaticConnectors()); cc.getStaticConnectors().add(backupConnector.getName()); // backupConnector is only necessary for fail-back tests configuration.getConnectorConfigurations().put(backupConnector.getName(), backupConnector); return; } ReplicatedPolicy haPolicy = (ReplicatedPolicy) server.getServer().getHAPolicy(); haPolicy.setCheckForLiveServer(true); }
protected void setupClusterConnectionWithBackups(final String name, final String address, final MessageLoadBalancingType messageLoadBalancingType, final int maxHops, final boolean netty, final int nodeFrom, final int[] nodesTo) { ActiveMQServer serverFrom = servers[nodeFrom]; if (serverFrom == null) { throw new IllegalStateException("No server at node " + nodeFrom); } TransportConfiguration connectorFrom = createTransportConfiguration(netty, false, generateParams(nodeFrom, netty)); serverFrom.getConfiguration().getConnectorConfigurations().put(name, connectorFrom); List<String> pairs = getClusterConnectionTCNames(netty, serverFrom, nodesTo); Configuration config = serverFrom.getConfiguration(); ClusterConnectionConfiguration clusterConf = new ClusterConnectionConfiguration().setName(name).setAddress(address).setConnectorName(name).setRetryInterval(250).setMessageLoadBalancingType(messageLoadBalancingType).setMaxHops(maxHops).setConfirmationWindowSize(1024).setStaticConnectors(pairs); config.getClusterConfigurations().add(clusterConf); }
protected void setupDiscoveryClusterConnection(final String name, final int node, final String discoveryGroupName, final String address, final MessageLoadBalancingType messageLoadBalancingType, final int maxHops, final boolean netty) { ActiveMQServer server = servers[node]; if (server == null) { throw new IllegalStateException("No server at node " + node); } TransportConfiguration connectorConfig = createTransportConfiguration(netty, false, generateParams(node, netty)); server.getConfiguration().getConnectorConfigurations().put(name, connectorConfig); Configuration config = server.getConfiguration(); ClusterConnectionConfiguration clusterConf = new ClusterConnectionConfiguration().setName(name).setAddress(address).setConnectorName(name).setRetryInterval(100).setDuplicateDetection(true).setMessageLoadBalancingType(messageLoadBalancingType).setMaxHops(maxHops).setConfirmationWindowSize(1024).setDiscoveryGroupName(discoveryGroupName); List<ClusterConnectionConfiguration> clusterConfs = config.getClusterConfigurations(); clusterConfs.add(clusterConf); }
protected void setupClusterConnection(final String name, final int nodeFrom, final int nodeTo, final String address, final MessageLoadBalancingType messageLoadBalancingType, final int maxHops, final boolean netty, final boolean allowDirectConnectionsOnly) { ActiveMQServer serverFrom = servers[nodeFrom]; if (serverFrom == null) { throw new IllegalStateException("No server at node " + nodeFrom); } TransportConfiguration connectorFrom = createTransportConfiguration(netty, false, generateParams(nodeFrom, netty)); serverFrom.getConfiguration().getConnectorConfigurations().put(name, connectorFrom); List<String> pairs = null; if (nodeTo != -1) { TransportConfiguration serverTotc = createTransportConfiguration(netty, false, generateParams(nodeTo, netty)); serverFrom.getConfiguration().getConnectorConfigurations().put(serverTotc.getName(), serverTotc); pairs = new ArrayList<>(); pairs.add(serverTotc.getName()); } Configuration config = serverFrom.getConfiguration(); ClusterConnectionConfiguration clusterConf = new ClusterConnectionConfiguration().setName(name).setAddress(address).setConnectorName(name).setRetryInterval(100).setMessageLoadBalancingType(messageLoadBalancingType).setMaxHops(maxHops).setConfirmationWindowSize(1024).setStaticConnectors(pairs).setAllowDirectConnectionsOnly(allowDirectConnectionsOnly); config.getClusterConfigurations().add(clusterConf); }
@Override @Before public void setUp() throws Exception { super.setUp(); setupLiveServer(0, isFileStorage(), isNetty(), true); setupLiveServer(1, isFileStorage(), isNetty(), true); LiveOnlyPolicyConfiguration haPolicyConfiguration0 = (LiveOnlyPolicyConfiguration) servers[0].getConfiguration().getHAPolicyConfiguration(); haPolicyConfiguration0.setScaleDownConfiguration(new ScaleDownConfiguration()); LiveOnlyPolicyConfiguration haPolicyConfiguration1 = (LiveOnlyPolicyConfiguration) servers[1].getConfiguration().getHAPolicyConfiguration(); haPolicyConfiguration1.setScaleDownConfiguration(new ScaleDownConfiguration()); if (useScaleDownGroupName) { haPolicyConfiguration0.getScaleDownConfiguration().setGroupName("bill"); haPolicyConfiguration1.getScaleDownConfiguration().setGroupName("bill"); } setupClusterConnection("cluster0", "testAddress", MessageLoadBalancingType.ON_DEMAND, 1, isNetty(), 0, 1); setupClusterConnection("cluster0", "testAddress", MessageLoadBalancingType.ON_DEMAND, 1, isNetty(), 1, 0); haPolicyConfiguration0.getScaleDownConfiguration().getConnectors().addAll(servers[0].getConfiguration().getClusterConfigurations().iterator().next().getStaticConnectors()); haPolicyConfiguration1.getScaleDownConfiguration().getConnectors().addAll(servers[1].getConfiguration().getClusterConfigurations().iterator().next().getStaticConnectors()); servers[0].getConfiguration().getAddressesSettings().put("#", new AddressSettings().setRedistributionDelay(0)); servers[1].getConfiguration().getAddressesSettings().put("#", new AddressSettings().setRedistributionDelay(0)); startServers(0, 1); setupSessionFactory(0, isNetty()); setupSessionFactory(1, isNetty()); }
@Test public void testRouteWhenNoConsumersTrueLoadBalancedQueuesNoLocalQueue() throws Exception { servers[0].getConfiguration().getClusterConfigurations().clear(); // server #0 is connected to server #1 setupClusterConnection("cluster1", 0, 1, "queues", MessageLoadBalancingType.STRICT, 1, isNetty(), true); startServers(1, 0); setupSessionFactory(0, isNetty(), true); setupSessionFactory(1, isNetty(), true); createQueue(0, "queues.testaddress", "queue0", null, false); createQueue(0, "queues.testaddress", "queue1", null, false); createQueue(1, "queues.testaddress", "queue0", null, false); createQueue(1, "queues.testaddress", "queue1", null, false); waitForBindings(0, "queues.testaddress", 2, 0, true); waitForBindings(0, "queues.testaddress", 2, 0, false); send(0, "queues.testaddress", 10, false, null); addConsumer(0, 0, "queue0", null); addConsumer(1, 0, "queue1", null); addConsumer(2, 1, "queue0", null); addConsumer(3, 1, "queue1", null); verifyReceiveRoundRobin(10, 0, 2); verifyReceiveRoundRobin(10, 1, 3); verifyNotReceive(0, 1, 2, 3); }
@Test public void testRouteWhenNoConsumersTrueLoadBalancedQueuesLocalConsumer() throws Exception { servers[0].getConfiguration().getClusterConfigurations().clear(); // server #0 is connected to server #1 setupClusterConnection("cluster1", 0, 1, "queues", MessageLoadBalancingType.STRICT, 1, isNetty(), true); startServers(1, 0); setupSessionFactory(0, isNetty(), true); setupSessionFactory(1, isNetty(), true); createQueue(0, "queues.testaddress", "queue0", null, false); createQueue(0, "queues.testaddress", "queue1", null, false); createQueue(0, "queues.testaddress", "queue2", null, false); createQueue(1, "queues.testaddress", "queue0", null, false); createQueue(1, "queues.testaddress", "queue1", null, false); createQueue(1, "queues.testaddress", "queue2", null, false); addConsumer(0, 0, "queue0", null); addConsumer(1, 0, "queue1", null); addConsumer(2, 0, "queue2", null); waitForBindings(0, "queues.testaddress", 3, 3, true); waitForBindings(0, "queues.testaddress", 3, 0, false); send(0, "queues.testaddress", 10, false, null); addConsumer(3, 1, "queue0", null); addConsumer(4, 1, "queue1", null); addConsumer(5, 1, "queue2", null); verifyReceiveRoundRobin(10, 0, 3); verifyReceiveRoundRobin(10, 1, 4); verifyReceiveRoundRobin(10, 2, 5); verifyNotReceive(0, 1, 2, 3, 4, 5); }