Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.activemq.artemis.core.management.impl;
import javax.json.JsonArray;
import javax.json.JsonArrayBuilder;
import javax.json.JsonObject;
import javax.json.JsonObjectBuilder;
import javax.management.ListenerNotFoundException;
import javax.management.MBeanAttributeInfo;
import javax.management.MBeanNotificationInfo;
import javax.management.MBeanOperationInfo;
import javax.management.Notification;
import javax.management.NotificationBroadcasterSupport;
import javax.management.NotificationEmitter;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.transaction.xa.Xid;
import java.net.URL;
import java.text.DateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;
import java.util.concurrent.atomic.AtomicLong;
import java.util.stream.Collectors;
import org.apache.activemq.artemis.api.config.ActiveMQDefaultConfiguration;
import org.apache.activemq.artemis.api.core.ActiveMQAddressDoesNotExistException;
import org.apache.activemq.artemis.api.core.ActiveMQException;
import org.apache.activemq.artemis.api.core.JsonUtil;
import org.apache.activemq.artemis.api.core.QueueConfiguration;
import org.apache.activemq.artemis.api.core.RoutingType;
import org.apache.activemq.artemis.api.core.SimpleString;
import org.apache.activemq.artemis.api.core.TransportConfiguration;
import org.apache.activemq.artemis.api.core.client.ActiveMQClient;
import org.apache.activemq.artemis.api.core.management.ActiveMQServerControl;
import org.apache.activemq.artemis.api.core.management.AddressControl;
import org.apache.activemq.artemis.api.core.management.BridgeControl;
import org.apache.activemq.artemis.api.core.management.CoreNotificationType;
import org.apache.activemq.artemis.api.core.management.DivertControl;
import org.apache.activemq.artemis.api.core.management.ManagementHelper;
import org.apache.activemq.artemis.api.core.management.Parameter;
import org.apache.activemq.artemis.api.core.management.QueueControl;
import org.apache.activemq.artemis.core.client.impl.Topology;
import org.apache.activemq.artemis.core.client.impl.TopologyMemberImpl;
import org.apache.activemq.artemis.core.config.BridgeConfiguration;
import org.apache.activemq.artemis.core.config.Configuration;
import org.apache.activemq.artemis.core.config.ConnectorServiceConfiguration;
import org.apache.activemq.artemis.core.config.DivertConfiguration;
import org.apache.activemq.artemis.core.config.TransformerConfiguration;
import org.apache.activemq.artemis.core.filter.Filter;
import org.apache.activemq.artemis.core.management.impl.view.AddressView;
import org.apache.activemq.artemis.core.management.impl.view.ConnectionView;
import org.apache.activemq.artemis.core.management.impl.view.ConsumerView;
import org.apache.activemq.artemis.core.management.impl.view.ProducerView;
import org.apache.activemq.artemis.core.management.impl.view.QueueView;
import org.apache.activemq.artemis.core.management.impl.view.SessionView;
import org.apache.activemq.artemis.core.messagecounter.MessageCounterManager;
import org.apache.activemq.artemis.core.messagecounter.impl.MessageCounterManagerImpl;
import org.apache.activemq.artemis.core.persistence.StorageManager;
import org.apache.activemq.artemis.core.persistence.config.PersistedAddressSetting;
import org.apache.activemq.artemis.core.persistence.config.PersistedSecuritySetting;
import org.apache.activemq.artemis.core.postoffice.Binding;
import org.apache.activemq.artemis.core.postoffice.Bindings;
import org.apache.activemq.artemis.core.postoffice.DuplicateIDCache;
import org.apache.activemq.artemis.core.postoffice.PostOffice;
import org.apache.activemq.artemis.core.postoffice.impl.LocalQueueBinding;
import org.apache.activemq.artemis.core.remoting.server.RemotingService;
import org.apache.activemq.artemis.core.security.CheckType;
import org.apache.activemq.artemis.core.security.Role;
import org.apache.activemq.artemis.core.security.impl.SecurityStoreImpl;
import org.apache.activemq.artemis.core.server.ActiveMQMessageBundle;
import org.apache.activemq.artemis.core.server.ActiveMQServer;
import org.apache.activemq.artemis.core.server.ActiveMQServerLogger;
import org.apache.activemq.artemis.core.server.BrokerConnection;
import org.apache.activemq.artemis.core.server.ComponentConfigurationRoutingType;
import org.apache.activemq.artemis.core.server.ConnectorServiceFactory;
import org.apache.activemq.artemis.core.server.Consumer;
import org.apache.activemq.artemis.core.server.Divert;
import org.apache.activemq.artemis.core.server.JournalType;
import org.apache.activemq.artemis.core.server.Queue;
import org.apache.activemq.artemis.core.server.ServerConsumer;
import org.apache.activemq.artemis.core.server.ServerProducer;
import org.apache.activemq.artemis.core.server.ServerSession;
import org.apache.activemq.artemis.core.server.cluster.ClusterConnection;
import org.apache.activemq.artemis.core.server.cluster.ClusterManager;
import org.apache.activemq.artemis.core.server.cluster.ha.HAPolicy;
import org.apache.activemq.artemis.core.server.cluster.ha.LiveOnlyPolicy;
import org.apache.activemq.artemis.core.server.cluster.ha.ScaleDownPolicy;
import org.apache.activemq.artemis.core.server.cluster.ha.SharedStoreSlavePolicy;
import org.apache.activemq.artemis.core.server.group.GroupingHandler;
import org.apache.activemq.artemis.core.server.impl.Activation;
import org.apache.activemq.artemis.core.server.impl.AddressInfo;
import org.apache.activemq.artemis.core.server.impl.SharedNothingLiveActivation;
import org.apache.activemq.artemis.core.settings.impl.AddressFullMessagePolicy;
import org.apache.activemq.artemis.core.settings.impl.AddressSettings;
import org.apache.activemq.artemis.core.settings.impl.DeletionPolicy;
import org.apache.activemq.artemis.core.settings.impl.SlowConsumerPolicy;
import org.apache.activemq.artemis.core.transaction.ResourceManager;
import org.apache.activemq.artemis.core.transaction.Transaction;
import org.apache.activemq.artemis.core.transaction.TransactionDetail;
import org.apache.activemq.artemis.core.transaction.TransactionDetailFactory;
import org.apache.activemq.artemis.core.transaction.impl.CoreTransactionDetail;
import org.apache.activemq.artemis.core.transaction.impl.XidImpl;
import org.apache.activemq.artemis.logs.AuditLogger;
import org.apache.activemq.artemis.spi.core.protocol.RemotingConnection;
import org.apache.activemq.artemis.spi.core.security.ActiveMQBasicSecurityManager;
import org.apache.activemq.artemis.spi.core.security.jaas.PropertiesLoginModuleConfigurator;
import org.apache.activemq.artemis.utils.JsonLoader;
import org.apache.activemq.artemis.utils.ListUtil;
import org.apache.activemq.artemis.utils.PasswordMaskingUtil;
import org.apache.activemq.artemis.utils.SecurityFormatter;
import org.apache.activemq.artemis.utils.collections.TypedProperties;
import org.jboss.logging.Logger;
public class ActiveMQServerControlImpl extends AbstractControl implements ActiveMQServerControl, NotificationEmitter, org.apache.activemq.artemis.core.server.management.NotificationListener {
// Constants -----------------------------------------------------
private static final Logger logger = Logger.getLogger(ActiveMQServerControlImpl.class);
// Attributes ----------------------------------------------------
private final PostOffice postOffice;
private final Configuration configuration;
private final ResourceManager resourceManager;
private final RemotingService remotingService;
private final ActiveMQServer server;
private final MessageCounterManager messageCounterManager;
private final NotificationBroadcasterSupport broadcaster;
private final AtomicLong notifSeq = new AtomicLong(0);
private final Object userLock = new Object();
public ActiveMQServerControlImpl(final PostOffice postOffice,
final Configuration configuration,
final ResourceManager resourceManager,
final RemotingService remotingService,
final ActiveMQServer messagingServer,
final MessageCounterManager messageCounterManager,
final StorageManager storageManager,
final NotificationBroadcasterSupport broadcaster) throws Exception {
super(ActiveMQServerControl.class, storageManager);
this.postOffice = postOffice;
this.configuration = configuration;
this.resourceManager = resourceManager;
this.remotingService = remotingService;
server = messagingServer;
this.messageCounterManager = messageCounterManager;
this.broadcaster = broadcaster;
server.getManagementService().addNotificationListener(this);
}
// ActiveMQServerControlMBean implementation --------------------
@Override
public boolean isStarted() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isStarted(this.server);
}
clearIO();
try {
return server.isStarted();
} finally {
blockOnIO();
}
}
@Override
public String getVersion() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getVersion(this.server);
}
checkStarted();
clearIO();
try {
return server.getVersion().getFullVersion();
} finally {
blockOnIO();
}
}
@Override
public boolean isActive() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getVersion(this.server);
}
checkStarted();
clearIO();
try {
return server.isActive();
} finally {
blockOnIO();
}
}
@Override
public boolean isBackup() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isBackup(this.server);
}
checkStarted();
clearIO();
try {
return server.getHAPolicy().isBackup();
} finally {
blockOnIO();
}
}
@Override
public boolean isSharedStore() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isSharedStore(this.server);
}
checkStarted();
clearIO();
try {
return server.getHAPolicy().isSharedStore();
} finally {
blockOnIO();
}
}
@Override
public String getBindingsDirectory() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getBindingsDirectory(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getBindingsDirectory();
} finally {
blockOnIO();
}
}
public String[] getInterceptorClassNames() {
checkStarted();
clearIO();
try {
return configuration.getIncomingInterceptorClassNames().toArray(new String[configuration.getIncomingInterceptorClassNames().size()]);
} finally {
blockOnIO();
}
}
@Override
public String[] getIncomingInterceptorClassNames() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getIncomingInterceptorClassNames(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getIncomingInterceptorClassNames().toArray(new String[configuration.getIncomingInterceptorClassNames().size()]);
} finally {
blockOnIO();
}
}
@Override
public String[] getOutgoingInterceptorClassNames() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getOutgoingInterceptorClassNames(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getOutgoingInterceptorClassNames().toArray(new String[configuration.getOutgoingInterceptorClassNames().size()]);
} finally {
blockOnIO();
}
}
@Override
public int getJournalPoolFiles() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalBufferSize(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalPoolFiles();
} finally {
blockOnIO();
}
}
@Override
public int getJournalBufferSize() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalBufferSize(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalType() == JournalType.ASYNCIO ? configuration.getJournalBufferSize_AIO() : configuration.getJournalBufferSize_NIO();
} finally {
blockOnIO();
}
}
@Override
public int getJournalBufferTimeout() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalBufferTimeout(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalType() == JournalType.ASYNCIO ? configuration.getJournalBufferTimeout_AIO() : configuration.getJournalBufferTimeout_NIO();
} finally {
blockOnIO();
}
}
@Override
public void setFailoverOnServerShutdown(boolean failoverOnServerShutdown) {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.setFailoverOnServerShutdown(this.server, failoverOnServerShutdown);
}
checkStarted();
clearIO();
try {
HAPolicy haPolicy = server.getHAPolicy();
if (haPolicy instanceof SharedStoreSlavePolicy) {
((SharedStoreSlavePolicy) haPolicy).setFailoverOnServerShutdown(failoverOnServerShutdown);
}
} finally {
blockOnIO();
}
}
@Override
public boolean isFailoverOnServerShutdown() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isFailoverOnServerShutdown(this.server);
}
checkStarted();
clearIO();
try {
HAPolicy haPolicy = server.getHAPolicy();
if (haPolicy instanceof SharedStoreSlavePolicy) {
return ((SharedStoreSlavePolicy) haPolicy).isFailoverOnServerShutdown();
} else {
return false;
}
} finally {
blockOnIO();
}
}
@Override
public int getJournalMaxIO() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalMaxIO(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalType() == JournalType.ASYNCIO ? configuration.getJournalMaxIO_AIO() : configuration.getJournalMaxIO_NIO();
} finally {
blockOnIO();
}
}
@Override
public String getJournalDirectory() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalDirectory(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalDirectory();
} finally {
blockOnIO();
}
}
@Override
public int getJournalFileSize() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalFileSize(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalFileSize();
} finally {
blockOnIO();
}
}
@Override
public int getJournalMinFiles() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalMinFiles(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalMinFiles();
} finally {
blockOnIO();
}
}
@Override
public int getJournalCompactMinFiles() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalCompactMinFiles(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalCompactMinFiles();
} finally {
blockOnIO();
}
}
@Override
public int getJournalCompactPercentage() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalCompactPercentage(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalCompactPercentage();
} finally {
blockOnIO();
}
}
@Override
public boolean isPersistenceEnabled() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isPersistenceEnabled(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isPersistenceEnabled();
} finally {
blockOnIO();
}
}
@Override
public String getJournalType() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getJournalType(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getJournalType().toString();
} finally {
blockOnIO();
}
}
@Override
public String getPagingDirectory() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getPagingDirectory(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getPagingDirectory();
} finally {
blockOnIO();
}
}
@Override
public int getScheduledThreadPoolMaxSize() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getScheduledThreadPoolMaxSize(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getScheduledThreadPoolMaxSize();
} finally {
blockOnIO();
}
}
@Override
public int getThreadPoolMaxSize() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getThreadPoolMaxSize(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getThreadPoolMaxSize();
} finally {
blockOnIO();
}
}
@Override
public long getSecurityInvalidationInterval() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getSecurityInvalidationInterval(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getSecurityInvalidationInterval();
} finally {
blockOnIO();
}
}
@Override
public boolean isClustered() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isClustered(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isClustered();
} finally {
blockOnIO();
}
}
@Override
public boolean isCreateBindingsDir() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isCreateBindingsDir(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isCreateBindingsDir();
} finally {
blockOnIO();
}
}
@Override
public boolean isCreateJournalDir() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isCreateJournalDir(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isCreateJournalDir();
} finally {
blockOnIO();
}
}
@Override
public boolean isJournalSyncNonTransactional() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isJournalSyncNonTransactional(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isJournalSyncNonTransactional();
} finally {
blockOnIO();
}
}
@Override
public boolean isJournalSyncTransactional() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isJournalSyncTransactional(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isJournalSyncTransactional();
} finally {
blockOnIO();
}
}
@Override
public boolean isSecurityEnabled() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isSecurityEnabled(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isSecurityEnabled();
} finally {
blockOnIO();
}
}
@Override
public boolean isAsyncConnectionExecutionEnabled() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isAsyncConnectionExecutionEnabled(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isAsyncConnectionExecutionEnabled();
} finally {
blockOnIO();
}
}
@Override
public int getDiskScanPeriod() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getDiskScanPeriod(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getDiskScanPeriod();
} finally {
blockOnIO();
}
}
@Override
public int getMaxDiskUsage() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getMaxDiskUsage(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getMaxDiskUsage();
} finally {
blockOnIO();
}
}
@Override
public long getGlobalMaxSize() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getGlobalMaxSize(this.server);
}
checkStarted();
clearIO();
try {
return configuration.getGlobalMaxSize();
} finally {
blockOnIO();
}
}
@Override
public long getAddressMemoryUsage() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getAddressMemoryUsage(this.server);
}
checkStarted();
clearIO();
try {
//this should not happen but if it does, return -1 to highlight it is not working
if (server.getPagingManager() == null) {
return -1L;
}
return server.getPagingManager().getGlobalSize();
} finally {
blockOnIO();
}
}
@Override
public double getDiskStoreUsage() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getDiskStoreUsage(this.server);
}
checkStarted();
clearIO();
try {
return server.getDiskStoreUsage();
} finally {
blockOnIO();
}
}
@Override
public int getAddressMemoryUsagePercentage() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getAddressMemoryUsagePercentage(this.server);
}
long globalMaxSize = getGlobalMaxSize();
// no max size set implies 0% used
if (globalMaxSize <= 0) {
return 0;
}
long memoryUsed = getAddressMemoryUsage();
if (memoryUsed <= 0) {
return 0;
}
double result = (100D * memoryUsed) / globalMaxSize;
return (int) result;
}
@Override
public String getHAPolicy() {
return configuration.getHAPolicyConfiguration().getType().getName();
}
@Override
public long getAuthenticationCacheSize() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getAuthenticationCacheSize(this.server);
}
return ((SecurityStoreImpl)server.getSecurityStore()).getAuthenticationCacheSize();
}
@Override
public long getAuthorizationCacheSize() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getAuthorizationCacheSize(this.server);
}
return ((SecurityStoreImpl)server.getSecurityStore()).getAuthorizationCacheSize();
}
@Override
public boolean freezeReplication() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.freezeReplication(this.server);
}
Activation activation = server.getActivation();
if (activation instanceof SharedNothingLiveActivation) {
SharedNothingLiveActivation liveActivation = (SharedNothingLiveActivation) activation;
liveActivation.freezeReplication();
return true;
}
return false;
}
private enum AddressInfoTextFormatter {
Long {
@Override
public StringBuilder format(AddressInfo addressInfo, StringBuilder output) {
output.append("Address [name=").append(addressInfo.getName());
output.append(", routingTypes={");
final EnumSet routingTypes = addressInfo.getRoutingTypes();
if (!routingTypes.isEmpty()) {
for (RoutingType routingType : routingTypes) {
output.append(routingType).append(',');
}
// delete hanging comma
output.deleteCharAt(output.length() - 1);
}
output.append('}');
output.append(", autoCreated=").append(addressInfo.isAutoCreated());
output.append(']');
return output;
}
};
public abstract StringBuilder format(AddressInfo addressInfo, StringBuilder output);
}
public enum QueueTextFormatter {
Long {
@Override
StringBuilder format(Queue queue, StringBuilder output) {
output.append("Queue [name=").append(queue.getName());
output.append(", address=").append(queue.getAddress());
output.append(", routingType=").append(queue.getRoutingType());
final Filter filter = queue.getFilter();
if (filter != null) {
output.append(", filter=").append(filter.getFilterString());
}
output.append(", durable=").append(queue.isDurable());
final int maxConsumers = queue.getMaxConsumers();
if (maxConsumers != Queue.MAX_CONSUMERS_UNLIMITED) {
output.append(", maxConsumers=").append(queue.getMaxConsumers());
}
output.append(", purgeOnNoConsumers=").append(queue.isPurgeOnNoConsumers());
output.append(", autoCreateAddress=").append(queue.isAutoCreated());
output.append(", exclusive=").append(queue.isExclusive());
output.append(", lastValue=").append(queue.isLastValue());
output.append(", lastValueKey=").append(queue.getLastValueKey());
output.append(", nonDestructive=").append(queue.isNonDestructive());
output.append(", consumersBeforeDispatch=").append(queue.getConsumersBeforeDispatch());
output.append(", delayBeforeDispatch=").append(queue.getDelayBeforeDispatch());
output.append(", autoCreateAddress=").append(queue.isAutoCreated());
output.append(']');
return output;
}
};
abstract StringBuilder format(Queue queue, StringBuilder output);
}
@Override
public String createAddress(String name, String routingTypes) throws Exception {
checkStarted();
clearIO();
try {
EnumSet set = EnumSet.noneOf(RoutingType.class);
for (String routingType : ListUtil.toList(routingTypes)) {
set.add(RoutingType.valueOf(routingType));
}
final AddressInfo addressInfo = new AddressInfo(new SimpleString(name), set);
if (server.addAddressInfo(addressInfo)) {
String result = AddressInfoTextFormatter.Long.format(addressInfo, new StringBuilder()).toString();
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.createAddressSuccess(name, routingTypes);
}
return result;
} else {
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.createAddressFailure(name, routingTypes);
}
throw ActiveMQMessageBundle.BUNDLE.addressAlreadyExists(addressInfo.getName());
}
} finally {
blockOnIO();
}
}
@Override
public String updateAddress(String name, String routingTypes) throws Exception {
checkStarted();
clearIO();
try {
final EnumSet routingTypeSet;
if (routingTypes == null) {
routingTypeSet = null;
} else {
routingTypeSet = EnumSet.noneOf(RoutingType.class);
final String[] routingTypeNames = routingTypes.split(",");
for (String routingTypeName : routingTypeNames) {
routingTypeSet.add(RoutingType.valueOf(routingTypeName));
}
}
if (!server.updateAddressInfo(SimpleString.toSimpleString(name), routingTypeSet)) {
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.updateAddressFailure(name, routingTypes);
}
throw ActiveMQMessageBundle.BUNDLE.addressDoesNotExist(SimpleString.toSimpleString(name));
}
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.updateAddressSuccess(name, routingTypes);
}
return AddressInfoTextFormatter.Long.format(server.getAddressInfo(SimpleString.toSimpleString(name)), new StringBuilder()).toString();
} finally {
blockOnIO();
}
}
@Override
public void deleteAddress(String name) throws Exception {
deleteAddress(name, false);
}
@Override
public void deleteAddress(String name, boolean force) throws Exception {
checkStarted();
clearIO();
try {
server.removeAddressInfo(new SimpleString(name), null, force);
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.deleteAddressSuccess(name);
}
} catch (ActiveMQException e) {
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.deleteAddressFailure(name);
}
throw new IllegalStateException(e.getMessage());
} finally {
blockOnIO();
}
}
@Deprecated
@Override
public void deployQueue(final String address, final String name, final String filterString) throws Exception {
deployQueue(address, name, filterString, true);
}
@Deprecated
@Override
public void deployQueue(final String address,
final String name,
final String filterStr,
final boolean durable) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.deployQueue(this.server, address, name, filterStr, durable);
}
checkStarted();
clearIO();
try {
server.createQueue(new QueueConfiguration(name)
.setAddress(address)
.setFilterString(filterStr)
.setDurable(durable));
} finally {
blockOnIO();
}
}
@Override
public void createQueue(final String address, final String name) throws Exception {
createQueue(address, name, true);
}
@Override
public void createQueue(final String address, final String name, final String routingType) throws Exception {
createQueue(address, name, true, routingType);
}
@Override
public void createQueue(final String address, final String name, final boolean durable) throws Exception {
createQueue(address, name, null, durable);
}
@Override
public void createQueue(final String address, final String name, final boolean durable, final String routingType) throws Exception {
createQueue(address, name, null, durable, routingType);
}
@Override
public void createQueue(final String address, final String name, final String filterStr, final boolean durable) throws Exception {
createQueue(address, name, filterStr, durable, server.getAddressSettingsRepository().getMatch(address == null ? name : address).getDefaultQueueRoutingType().toString());
}
@Override
public void createQueue(final String address, final String name, final String filterStr, final boolean durable, final String routingType) throws Exception {
AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch(address == null ? name : address);
createQueue(address, routingType, name, filterStr, durable, addressSettings.getDefaultMaxConsumers(), addressSettings.isDefaultPurgeOnNoConsumers(), addressSettings.isAutoCreateAddresses());
}
@Override
public String createQueue(String address,
String routingType,
String name,
String filterStr,
boolean durable,
int maxConsumers,
boolean purgeOnNoConsumers,
boolean autoCreateAddress) throws Exception {
AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch(address == null ? name : address);
return createQueue(
address,
routingType,
name,
filterStr,
durable,
maxConsumers,
purgeOnNoConsumers,
addressSettings.isDefaultExclusiveQueue(),
addressSettings.isDefaultGroupRebalance(),
addressSettings.getDefaultGroupBuckets(),
addressSettings.isDefaultLastValueQueue(),
addressSettings.getDefaultLastValueKey() == null ? null : addressSettings.getDefaultLastValueKey().toString(),
addressSettings.isDefaultNonDestructive(),
addressSettings.getDefaultConsumersBeforeDispatch(),
addressSettings.getDefaultDelayBeforeDispatch(),
addressSettings.isAutoDeleteCreatedQueues(),
addressSettings.getAutoDeleteQueuesDelay(),
addressSettings.getAutoDeleteQueuesMessageCount(),
autoCreateAddress
);
}
@Override
public String createQueue(String address,
String routingType,
String name,
String filterStr,
boolean durable,
int maxConsumers,
boolean purgeOnNoConsumers,
boolean exclusive,
boolean groupRebalance,
int groupBuckets,
boolean lastValue,
String lastValueKey,
boolean nonDestructive,
int consumersBeforeDispatch,
long delayBeforeDispatch,
boolean autoCreateAddress) throws Exception {
AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch(address == null ? name : address);
return createQueue(
address,
routingType,
name,
filterStr,
durable,
maxConsumers,
purgeOnNoConsumers,
exclusive,
groupRebalance,
groupBuckets,
lastValue,
lastValueKey,
nonDestructive,
consumersBeforeDispatch,
delayBeforeDispatch,
addressSettings.isAutoDeleteCreatedQueues(),
addressSettings.getAutoDeleteQueuesDelay(),
addressSettings.getAutoDeleteQueuesMessageCount(),
autoCreateAddress);
}
@Override
public String createQueue(String address,
String routingType,
String name,
String filterStr,
boolean durable,
int maxConsumers,
boolean purgeOnNoConsumers,
boolean exclusive,
boolean groupRebalance,
int groupBuckets,
boolean lastValue,
String lastValueKey,
boolean nonDestructive,
int consumersBeforeDispatch,
long delayBeforeDispatch,
boolean autoDelete,
long autoDeleteDelay,
long autoDeleteMessageCount,
boolean autoCreateAddress) throws Exception {
AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch(address == null ? name : address);
return createQueue(
address,
routingType,
name,
filterStr,
durable,
maxConsumers,
purgeOnNoConsumers,
exclusive,
groupRebalance,
groupBuckets,
addressSettings.getDefaultGroupFirstKey() == null ? null : addressSettings.getDefaultGroupFirstKey().toString(),
lastValue,
lastValueKey,
nonDestructive,
consumersBeforeDispatch,
delayBeforeDispatch,
autoDelete,
autoDeleteDelay,
autoDeleteMessageCount,
autoCreateAddress
);
}
@Override
public String createQueue(String address,
String routingType,
String name,
String filterStr,
boolean durable,
int maxConsumers,
boolean purgeOnNoConsumers,
boolean exclusive,
boolean groupRebalance,
int groupBuckets,
String groupFirstKey,
boolean lastValue,
String lastValueKey,
boolean nonDestructive,
int consumersBeforeDispatch,
long delayBeforeDispatch,
boolean autoDelete,
long autoDeleteDelay,
long autoDeleteMessageCount,
boolean autoCreateAddress) throws Exception {
AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch(address == null ? name : address);
return createQueue(
address,
routingType,
name,
filterStr,
durable,
maxConsumers,
purgeOnNoConsumers,
exclusive,
groupRebalance,
groupBuckets,
groupFirstKey,
lastValue,
lastValueKey,
nonDestructive,
consumersBeforeDispatch,
delayBeforeDispatch,
autoDelete,
autoDeleteDelay,
autoDeleteMessageCount,
autoCreateAddress,
addressSettings.getDefaultRingSize()
);
}
@Override
public String createQueue(String address,
String routingType,
String name,
String filterStr,
boolean durable,
int maxConsumers,
boolean purgeOnNoConsumers,
boolean exclusive,
boolean groupRebalance,
int groupBuckets,
String groupFirstKey,
boolean lastValue,
String lastValueKey,
boolean nonDestructive,
int consumersBeforeDispatch,
long delayBeforeDispatch,
boolean autoDelete,
long autoDeleteDelay,
long autoDeleteMessageCount,
boolean autoCreateAddress,
long ringSize) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.createQueue(this.server, null, null, address, routingType, name, filterStr, durable,
maxConsumers, purgeOnNoConsumers, exclusive, groupRebalance, groupBuckets, groupFirstKey,
lastValue, lastValueKey, nonDestructive, consumersBeforeDispatch, delayBeforeDispatch,
autoDelete, autoDeleteDelay, autoDeleteMessageCount, autoCreateAddress, ringSize);
}
checkStarted();
clearIO();
SimpleString filter = filterStr == null ? null : new SimpleString(filterStr);
try {
if (filterStr != null && !filterStr.trim().equals("")) {
filter = new SimpleString(filterStr);
}
final Queue queue = server.createQueue(new QueueConfiguration(name)
.setAddress(address)
.setRoutingType(RoutingType.valueOf(routingType.toUpperCase()))
.setFilterString(filter)
.setDurable(durable)
.setMaxConsumers(maxConsumers)
.setPurgeOnNoConsumers(purgeOnNoConsumers)
.setExclusive(exclusive)
.setGroupRebalance(groupRebalance)
.setGroupBuckets(groupBuckets)
.setGroupFirstKey(groupFirstKey)
.setLastValue(lastValue)
.setLastValueKey(lastValueKey)
.setNonDestructive(nonDestructive)
.setConsumersBeforeDispatch(consumersBeforeDispatch)
.setDelayBeforeDispatch(delayBeforeDispatch)
.setAutoDelete(autoDelete)
.setAutoDeleteDelay(autoDeleteDelay)
.setAutoDeleteMessageCount(autoDeleteMessageCount)
.setAutoCreateAddress(autoCreateAddress)
.setRingSize(ringSize));
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.createQueueSuccess( name, address, routingType);
}
return QueueTextFormatter.Long.format(queue, new StringBuilder()).toString();
} catch (ActiveMQException e) {
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.createQueueFailure( name, address, routingType);
}
throw new IllegalStateException(e.getMessage());
} finally {
blockOnIO();
}
}
@Override
public String createQueue(String queueConfigurationAsJson) throws Exception {
return createQueue(queueConfigurationAsJson, false);
}
@Override
public String createQueue(String queueConfigurationAsJson, boolean ignoreIfExists) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.createQueue(this.server, null, null, queueConfigurationAsJson, ignoreIfExists);
}
checkStarted();
clearIO();
try {
// when the QueueConfiguration is passed through createQueue all of its defaults get set which we return to the caller
QueueConfiguration queueConfiguration = QueueConfiguration.fromJSON(queueConfigurationAsJson);
if (queueConfiguration == null) {
throw ActiveMQMessageBundle.BUNDLE.failedToParseJson(queueConfigurationAsJson);
}
server.createQueue(queueConfiguration, ignoreIfExists);
return queueConfiguration.toJSON();
} catch (ActiveMQException e) {
throw new IllegalStateException(e.getMessage());
} finally {
blockOnIO();
}
}
@Override
public String updateQueue(String queueConfigurationAsJson) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.updateQueue(this.server, queueConfigurationAsJson);
}
checkStarted();
clearIO();
try {
QueueConfiguration queueConfiguration = QueueConfiguration.fromJSON(queueConfigurationAsJson);
if (queueConfiguration == null) {
throw ActiveMQMessageBundle.BUNDLE.failedToParseJson(queueConfigurationAsJson);
}
final Queue queue = server.updateQueue(queueConfiguration);
if (queue == null) {
throw ActiveMQMessageBundle.BUNDLE.noSuchQueue(queueConfiguration.getName());
}
return server.locateQueue(queueConfiguration.getName()).getQueueConfiguration().toJSON();
} finally {
blockOnIO();
}
}
@Deprecated
@Override
public String updateQueue(String name,
String routingType,
Integer maxConsumers,
Boolean purgeOnNoConsumers) throws Exception {
return updateQueue(name, routingType, maxConsumers, purgeOnNoConsumers, null);
}
@Deprecated
@Override
public String updateQueue(String name,
String routingType,
Integer maxConsumers,
Boolean purgeOnNoConsumers,
Boolean exclusive) throws Exception {
return updateQueue(name, routingType, maxConsumers, purgeOnNoConsumers, exclusive, null);
}
@Override
public String updateQueue(String name,
String routingType,
Integer maxConsumers,
Boolean purgeOnNoConsumers,
Boolean exclusive,
String user) throws Exception {
return updateQueue(name, routingType, null, maxConsumers, purgeOnNoConsumers, exclusive, null, null, null, null, null, user);
}
@Override
public String updateQueue(String name,
String routingType,
String filter,
Integer maxConsumers,
Boolean purgeOnNoConsumers,
Boolean exclusive,
Boolean groupRebalance,
Integer groupBuckets,
Boolean nonDestructive,
Integer consumersBeforeDispatch,
Long delayBeforeDispatch,
String user) throws Exception {
return updateQueue(name, routingType, filter, maxConsumers, purgeOnNoConsumers, exclusive, groupRebalance, groupBuckets, null, nonDestructive, consumersBeforeDispatch, delayBeforeDispatch, user);
}
@Override
public String updateQueue(String name,
String routingType,
String filter,
Integer maxConsumers,
Boolean purgeOnNoConsumers,
Boolean exclusive,
Boolean groupRebalance,
Integer groupBuckets,
String groupFirstKey,
Boolean nonDestructive,
Integer consumersBeforeDispatch,
Long delayBeforeDispatch,
String user) throws Exception {
return updateQueue(name, routingType, filter, maxConsumers, purgeOnNoConsumers, exclusive, groupRebalance, groupBuckets, null, nonDestructive, consumersBeforeDispatch, delayBeforeDispatch, user, null);
}
@Override
public String updateQueue(String name,
String routingType,
String filter,
Integer maxConsumers,
Boolean purgeOnNoConsumers,
Boolean exclusive,
Boolean groupRebalance,
Integer groupBuckets,
String groupFirstKey,
Boolean nonDestructive,
Integer consumersBeforeDispatch,
Long delayBeforeDispatch,
String user,
Long ringSize) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.updateQueue(this.server, name, routingType, filter, maxConsumers, purgeOnNoConsumers,
exclusive, groupRebalance, groupBuckets, groupFirstKey, nonDestructive, consumersBeforeDispatch, delayBeforeDispatch, user, ringSize);
}
checkStarted();
clearIO();
try {
final Queue queue = server.updateQueue(name, routingType != null ? RoutingType.valueOf(routingType) : null, filter, maxConsumers, purgeOnNoConsumers, exclusive, groupRebalance, groupBuckets, groupFirstKey, nonDestructive, consumersBeforeDispatch, delayBeforeDispatch, user);
if (queue == null) {
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.updateQueueFailure(name, routingType);
}
throw ActiveMQMessageBundle.BUNDLE.noSuchQueue(new SimpleString(name));
}
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.updateQueueSuccess(name, routingType);
}
return QueueTextFormatter.Long.format(queue, new StringBuilder()).toString();
} finally {
blockOnIO();
}
}
@Override
public int getQueueCount() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getQueueCount(this.server);
}
checkStarted();
clearIO();
try {
Object[] queueControls = server.getManagementService().getResources(QueueControl.class);
return queueControls.length;
} finally {
blockOnIO();
}
}
@Override
public String[] getQueueNames() {
return getQueueNames(null);
}
@Override
public String[] getQueueNames(String routingType) {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getQueueNames(this.server, routingType);
}
checkStarted();
clearIO();
try {
Object[] queueControls = server.getManagementService().getResources(QueueControl.class);
List names = new ArrayList<>();
for (int i = 0; i < queueControls.length; i++) {
QueueControl queueControl = (QueueControl) queueControls[i];
if (routingType != null && routingType.length() > 1 && queueControl.getRoutingType().equals(routingType.toUpperCase())) {
names.add(queueControl.getName());
} else if (routingType == null || routingType.isEmpty()) {
names.add(queueControl.getName());
}
}
String[] result = new String[names.size()];
return names.toArray(result);
} finally {
blockOnIO();
}
}
@Override
public String[] getClusterConnectionNames() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getClusterConnectionNames(this.server);
}
checkStarted();
clearIO();
try {
List names = new ArrayList<>();
for (ClusterConnection clusterConnection : server.getClusterManager().getClusterConnections()) {
names.add(clusterConnection.getName().toString());
}
String[] result = new String[names.size()];
return names.toArray(result);
} finally {
blockOnIO();
}
}
@Override
public String getUptime() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getUptime(this.server);
}
checkStarted();
clearIO();
try {
return server.getUptime();
} finally {
blockOnIO();
}
}
@Override
public long getUptimeMillis() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getUptimeMillis(this.server);
}
checkStarted();
clearIO();
try {
return server.getUptimeMillis();
} finally {
blockOnIO();
}
}
@Override
public boolean isReplicaSync() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isReplicaSync(this.server);
}
checkStarted();
clearIO();
try {
return server.isReplicaSync();
} finally {
blockOnIO();
}
}
@Override
public int getAddressCount() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getAddressCount(this.server);
}
checkStarted();
clearIO();
try {
Object[] addresses = server.getManagementService().getResources(AddressControl.class);
return addresses.length;
} finally {
blockOnIO();
}
}
@Override
public String[] getAddressNames() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getAddressNames(this.server);
}
checkStarted();
clearIO();
try {
Object[] addresses = server.getManagementService().getResources(AddressControl.class);
String[] names = new String[addresses.length];
for (int i = 0; i < addresses.length; i++) {
AddressControl address = (AddressControl) addresses[i];
names[i] = address.getAddress();
}
return names;
} finally {
blockOnIO();
}
}
@Override
public void destroyQueue(final String name, final boolean removeConsumers, final boolean autoDeleteAddress) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.destroyQueue(this.server, null, null, name, removeConsumers, autoDeleteAddress);
}
checkStarted();
clearIO();
try {
SimpleString queueName = new SimpleString(name);
try {
server.destroyQueue(queueName, null, !removeConsumers, removeConsumers, autoDeleteAddress);
} catch (Exception e) {
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.destroyQueueFailure(name);
}
throw e;
}
if (AuditLogger.isResourceLoggingEnabled()) {
AuditLogger.destroyQueueSuccess(name);
}
} finally {
blockOnIO();
}
}
@Override
public void destroyQueue(final String name, final boolean removeConsumers) throws Exception {
destroyQueue(name, removeConsumers, false);
}
@Override
public void destroyQueue(final String name) throws Exception {
destroyQueue(name, false);
}
@Override
public String getAddressInfo(String address) throws ActiveMQAddressDoesNotExistException {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getAddressInfo(this.server, address);
}
checkStarted();
clearIO();
try {
final AddressInfo addressInfo = server.getAddressInfo(SimpleString.toSimpleString(address));
if (addressInfo == null) {
throw ActiveMQMessageBundle.BUNDLE.addressDoesNotExist(SimpleString.toSimpleString(address));
} else {
return AddressInfoTextFormatter.Long.format(addressInfo, new StringBuilder()).toString();
}
} finally {
blockOnIO();
}
}
@Override
public String listBindingsForAddress(String address) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.listBindingsForAddress(this.server, address);
}
checkStarted();
clearIO();
try {
final Bindings bindings = server.getPostOffice().lookupBindingsForAddress(new SimpleString(address));
return bindings == null ? "" : bindings.getBindings().stream().map(Binding::toManagementString).collect(Collectors.joining(","));
} finally {
blockOnIO();
}
}
@Override
public String listAddresses(String separator) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.listAddresses(this.server, separator);
}
checkStarted();
clearIO();
try {
final Set addresses = server.getPostOffice().getAddresses();
TreeSet sortAddress = new TreeSet<>(new Comparator() {
@Override
public int compare(SimpleString o1, SimpleString o2) {
return o1.toString().compareToIgnoreCase(o2.toString());
}
});
sortAddress.addAll(addresses);
StringBuilder result = new StringBuilder();
for (SimpleString string : sortAddress) {
if (result.length() > 0) {
result.append(separator);
}
result.append(string);
}
return result.toString();
} finally {
blockOnIO();
}
}
@Override
public int getConnectionCount() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getConnectionCount(this.server);
}
checkStarted();
clearIO();
try {
return server.getConnectionCount();
} finally {
blockOnIO();
}
}
@Override
public long getTotalConnectionCount() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getTotalConnectionCount(this.server);
}
checkStarted();
clearIO();
try {
return server.getTotalConnectionCount();
} finally {
blockOnIO();
}
}
@Override
public long getTotalMessageCount() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getTotalMessageCount(this.server);
}
checkStarted();
clearIO();
try {
return server.getTotalMessageCount();
} finally {
blockOnIO();
}
}
@Override
public long getTotalMessagesAdded() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getTotalMessagesAdded(this.server);
}
checkStarted();
clearIO();
try {
return server.getTotalMessagesAdded();
} finally {
blockOnIO();
}
}
@Override
public long getTotalMessagesAcknowledged() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getTotalMessagesAcknowledged(this.server);
}
checkStarted();
clearIO();
try {
return server.getTotalMessagesAcknowledged();
} finally {
blockOnIO();
}
}
@Override
public long getTotalConsumerCount() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getTotalConsumerCount(this.server);
}
checkStarted();
clearIO();
try {
return server.getTotalConsumerCount();
} finally {
blockOnIO();
}
}
@Override
public void enableMessageCounters() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.enableMessageCounters(this.server);
}
checkStarted();
clearIO();
try {
setMessageCounterEnabled(true);
} finally {
blockOnIO();
}
}
@Override
public void disableMessageCounters() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.disableMessageCounters(this.server);
}
checkStarted();
clearIO();
try {
setMessageCounterEnabled(false);
} finally {
blockOnIO();
}
}
@Override
public void resetAllMessageCounters() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.resetAllMessageCounters(this.server);
}
checkStarted();
clearIO();
try {
messageCounterManager.resetAllCounters();
} finally {
blockOnIO();
}
}
@Override
public void resetAllMessageCounterHistories() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.resetAllMessageCounterHistories(this.server);
}
checkStarted();
clearIO();
try {
messageCounterManager.resetAllCounterHistories();
} finally {
blockOnIO();
}
}
@Override
public boolean isMessageCounterEnabled() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.isMessageCounterEnabled(this.server);
}
checkStarted();
clearIO();
try {
return configuration.isMessageCounterEnabled();
} finally {
blockOnIO();
}
}
@Override
public synchronized long getMessageCounterSamplePeriod() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getMessageCounterSamplePeriod(this.server);
}
checkStarted();
clearIO();
try {
return messageCounterManager.getSamplePeriod();
} finally {
blockOnIO();
}
}
@Override
public synchronized void setMessageCounterSamplePeriod(final long newPeriod) {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.setMessageCounterSamplePeriod(this.server, newPeriod);
}
checkStarted();
clearIO();
try {
if (newPeriod < MessageCounterManagerImpl.MIN_SAMPLE_PERIOD) {
if (newPeriod <= 0) {
throw ActiveMQMessageBundle.BUNDLE.periodMustGreaterThanZero(newPeriod);
}
ActiveMQServerLogger.LOGGER.invalidMessageCounterPeriod(newPeriod);
}
if (messageCounterManager != null && newPeriod != messageCounterManager.getSamplePeriod()) {
messageCounterManager.reschedule(newPeriod);
}
} finally {
blockOnIO();
}
}
@Override
public int getMessageCounterMaxDayCount() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.getMessageCounterMaxDayCount(this.server);
}
checkStarted();
clearIO();
try {
return messageCounterManager.getMaxDayCount();
} finally {
blockOnIO();
}
}
@Override
public void setMessageCounterMaxDayCount(final int count) {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.setMessageCounterMaxDayCount(this.server, count);
}
checkStarted();
clearIO();
try {
if (count <= 0) {
throw ActiveMQMessageBundle.BUNDLE.greaterThanZero(count);
}
messageCounterManager.setMaxDayCount(count);
} finally {
blockOnIO();
}
}
@Override
public String[] listPreparedTransactions() {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.listPreparedTransactions(this.server);
}
checkStarted();
clearIO();
try {
DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM);
Map xids = resourceManager.getPreparedTransactionsWithCreationTime();
ArrayList> xidsSortedByCreationTime = new ArrayList<>(xids.entrySet());
Collections.sort(xidsSortedByCreationTime, new Comparator>() {
@Override
public int compare(final Entry entry1, final Entry entry2) {
// sort by creation time, oldest first
return entry1.getValue().compareTo(entry2.getValue());
}
});
String[] s = new String[xidsSortedByCreationTime.size()];
int i = 0;
for (Map.Entry entry : xidsSortedByCreationTime) {
Date creation = new Date(entry.getValue());
Xid xid = entry.getKey();
s[i++] = dateFormat.format(creation) + " base64: " + XidImpl.toBase64String(xid) + " " + xid.toString();
}
return s;
} finally {
blockOnIO();
}
}
@Override
public String listPreparedTransactionDetailsAsJSON() throws Exception {
return listPreparedTransactionDetailsAsJSON((xid, tx, creation) -> new CoreTransactionDetail(xid, tx, creation));
}
public String listPreparedTransactionDetailsAsJSON(TransactionDetailFactory factory) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.listPreparedTransactionDetailsAsJSON(this.server);
}
checkStarted();
clearIO();
try {
Map xids = resourceManager.getPreparedTransactionsWithCreationTime();
if (xids == null || xids.size() == 0) {
return "";
}
ArrayList> xidsSortedByCreationTime = new ArrayList<>(xids.entrySet());
Collections.sort(xidsSortedByCreationTime, new Comparator>() {
@Override
public int compare(final Entry entry1, final Entry entry2) {
// sort by creation time, oldest first
return entry1.getValue().compareTo(entry2.getValue());
}
});
JsonArrayBuilder txDetailListJson = JsonLoader.createArrayBuilder();
for (Map.Entry entry : xidsSortedByCreationTime) {
Xid xid = entry.getKey();
Transaction tx = resourceManager.getTransaction(xid);
if (tx == null) {
continue;
}
TransactionDetail detail = factory.createTransactionDetail(xid, tx, entry.getValue());
txDetailListJson.add(detail.toJSON());
}
return txDetailListJson.build().toString();
} finally {
blockOnIO();
}
}
@Override
public String listPreparedTransactionDetailsAsHTML() throws Exception {
return listPreparedTransactionDetailsAsHTML((xid, tx, creation) -> new CoreTransactionDetail(xid, tx, creation));
}
public String listPreparedTransactionDetailsAsHTML(TransactionDetailFactory factory) throws Exception {
if (AuditLogger.isBaseLoggingEnabled()) {
AuditLogger.listPreparedTransactionDetailsAsHTML(this.server, factory);
}
checkStarted();
clearIO();
try {
Map xids = resourceManager.getPreparedTransactionsWithCreationTime();
if (xids == null || xids.size() == 0) {
return "
*** Prepared Transaction Details ***
No entry.
";
}
ArrayList> xidsSortedByCreationTime = new ArrayList<>(xids.entrySet());
Collections.sort(xidsSortedByCreationTime, new Comparator>() {
@Override
public int compare(final Entry entry1, final Entry entry2) {
// sort by creation time, oldest first
return entry1.getValue().compareTo(entry2.getValue());
}
});
StringBuilder html = new StringBuilder();
html.append("
