| /* |
| * 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.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.io.File; |
| import java.lang.invoke.MethodHandles; |
| import java.net.URL; |
| import java.nio.file.Path; |
| import java.text.DateFormat; |
| import java.text.SimpleDateFormat; |
| 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.CountDownLatch; |
| import java.util.concurrent.Future; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.atomic.AtomicLong; |
| import java.util.concurrent.atomic.AtomicReference; |
| 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.ActiveMQIllegalStateException; |
| 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.ConsumerField; |
| 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.PersistedAddressSettingJSON; |
| import org.apache.activemq.artemis.core.persistence.config.PersistedConnector; |
| 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.ActiveMQComponent; |
| 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.MessageReference; |
| 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.ServiceComponent; |
| 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.PrimaryOnlyPolicy; |
| import org.apache.activemq.artemis.core.server.cluster.ha.ScaleDownPolicy; |
| import org.apache.activemq.artemis.core.server.cluster.ha.SharedStoreBackupPolicy; |
| 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.SharedNothingPrimaryActivation; |
| import org.apache.activemq.artemis.core.server.replay.ReplayManager; |
| 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.json.JsonArray; |
| import org.apache.activemq.artemis.json.JsonArrayBuilder; |
| import org.apache.activemq.artemis.json.JsonObject; |
| import org.apache.activemq.artemis.json.JsonObjectBuilder; |
| import org.apache.activemq.artemis.logs.AuditLogger; |
| import org.apache.activemq.artemis.marker.WebServerComponentMarker; |
| 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.slf4j.Logger; |
| import org.slf4j.LoggerFactory; |
| |
| public class ActiveMQServerControlImpl extends AbstractControl implements ActiveMQServerControl, NotificationEmitter, org.apache.activemq.artemis.core.server.management.NotificationListener { |
| |
| private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass()); |
| |
| |
| 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(); |
| |
| private final Object embeddedWebServerLock = 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 getName() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getName(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| return server.getConfiguration().getName(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public long getCurrentTimeMillis() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getCurrentTimeMillis(this.server); |
| } |
| return System.currentTimeMillis(); |
| } |
| |
| @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 String[] getBrokerPluginClassNames() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getBrokerPluginClassNames(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| return configuration.getBrokerPlugins().stream() |
| .map(brokerPlugin -> brokerPlugin.getClass().getCanonicalName() != null ? brokerPlugin.getClass().getCanonicalName() : brokerPlugin.getClass().getName()) |
| .toArray(String[]::new); |
| } 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 SharedStoreBackupPolicy) { |
| ((SharedStoreBackupPolicy) 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 SharedStoreBackupPolicy) { |
| return ((SharedStoreBackupPolicy) 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() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.freezeReplication(this.server); |
| } |
| try (AutoCloseable lock = server.managementLock()) { |
| Activation activation = server.getActivation(); |
| if (activation instanceof SharedNothingPrimaryActivation) { |
| SharedNothingPrimaryActivation primaryActivation = (SharedNothingPrimaryActivation) activation; |
| primaryActivation.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<RoutingType> 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<RoutingType> set = EnumSet.noneOf(RoutingType.class); |
| for (String routingType : ListUtil.toList(routingTypes)) { |
| set.add(RoutingType.valueOf(routingType)); |
| } |
| final AddressInfo addressInfo = new AddressInfo(SimpleString.of(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<RoutingType> 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.of(name), routingTypeSet)) { |
| if (AuditLogger.isResourceLoggingEnabled()) { |
| AuditLogger.updateAddressFailure(name, routingTypes); |
| } |
| throw ActiveMQMessageBundle.BUNDLE.addressDoesNotExist(SimpleString.of(name)); |
| } |
| if (AuditLogger.isResourceLoggingEnabled()) { |
| AuditLogger.updateAddressSuccess(name, routingTypes); |
| } |
| return AddressInfoTextFormatter.Long.format(server.getAddressInfo(SimpleString.of(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 { |
| |
| // delete might be a long running task, we ensure only one large task running |
| try (AutoCloseable lock = server.managementLock()) { |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| server.removeAddressInfo(SimpleString.of(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(QueueConfiguration.of(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 : SimpleString.of(filterStr); |
| try { |
| if (filterStr != null && !filterStr.trim().equals("")) { |
| filter = SimpleString.of(filterStr); |
| } |
| |
| final Queue queue = server.createQueue(QueueConfiguration.of(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, ringSize); |
| if (queue == null) { |
| if (AuditLogger.isResourceLoggingEnabled()) { |
| AuditLogger.updateQueueFailure(name, routingType); |
| } |
| throw ActiveMQMessageBundle.BUNDLE.noSuchQueue(SimpleString.of(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<String> 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<String> 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 forceAutoDeleteAddress) throws Exception { |
| // destroy might be a long running task, we prevent multiple running tasks in this case |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.destroyQueue(this.server, null, null, name, removeConsumers, forceAutoDeleteAddress); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| SimpleString queueName = SimpleString.of(name); |
| try { |
| server.destroyQueue(queueName, null, !removeConsumers, removeConsumers, forceAutoDeleteAddress); |
| } 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.of(address)); |
| if (addressInfo == null) { |
| throw ActiveMQMessageBundle.BUNDLE.addressDoesNotExist(SimpleString.of(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(SimpleString.of(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<SimpleString> addresses = server.getPostOffice().getAddresses(); |
| TreeSet<SimpleString> sortAddress = new TreeSet<>((o1, o2) -> 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<Xid, Long> xids = resourceManager.getPreparedTransactionsWithCreationTime(); |
| ArrayList<Entry<Xid, Long>> xidsSortedByCreationTime = new ArrayList<>(xids.entrySet()); |
| Collections.sort(xidsSortedByCreationTime, Entry.comparingByValue()); |
| String[] s = new String[xidsSortedByCreationTime.size()]; |
| int i = 0; |
| for (Map.Entry<Xid, Long> 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<Xid, Long> xids = resourceManager.getPreparedTransactionsWithCreationTime(); |
| if (xids == null || xids.size() == 0) { |
| return ""; |
| } |
| |
| ArrayList<Entry<Xid, Long>> xidsSortedByCreationTime = new ArrayList<>(xids.entrySet()); |
| Collections.sort(xidsSortedByCreationTime, Entry.comparingByValue()); |
| |
| JsonArrayBuilder txDetailListJson = JsonLoader.createArrayBuilder(); |
| for (Map.Entry<Xid, Long> 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(); |
| } |
| } |
| |
| @Deprecated |
| @Override |
| public String listPreparedTransactionDetailsAsHTML() throws Exception { |
| return listPreparedTransactionDetailsAsHTML((xid, tx, creation) -> new CoreTransactionDetail(xid, tx, creation)); |
| } |
| |
| @Deprecated |
| public String listPreparedTransactionDetailsAsHTML(TransactionDetailFactory factory) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listPreparedTransactionDetailsAsHTML(this.server, factory); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Map<Xid, Long> xids = resourceManager.getPreparedTransactionsWithCreationTime(); |
| if (xids == null || xids.size() == 0) { |
| return "<h3>*** Prepared Transaction Details ***</h3><p>No entry.</p>"; |
| } |
| |
| ArrayList<Entry<Xid, Long>> xidsSortedByCreationTime = new ArrayList<>(xids.entrySet()); |
| Collections.sort(xidsSortedByCreationTime, new Comparator<Entry<Xid, Long>>() { |
| @Override |
| public int compare(final Entry<Xid, Long> entry1, final Entry<Xid, Long> entry2) { |
| // sort by creation time, oldest first |
| return entry1.getValue().compareTo(entry2.getValue()); |
| } |
| }); |
| |
| StringBuilder html = new StringBuilder(); |
| html.append("<h3>*** Prepared Transaction Details ***</h3>"); |
| |
| for (Map.Entry<Xid, Long> entry : xidsSortedByCreationTime) { |
| Xid xid = entry.getKey(); |
| |
| Transaction tx = resourceManager.getTransaction(xid); |
| |
| if (tx == null) { |
| continue; |
| } |
| |
| TransactionDetail detail = factory.createTransactionDetail(xid, tx, entry.getValue()); |
| |
| JsonObject txJson = detail.toJSON(); |
| |
| html.append("<table border=\"1\">"); |
| html.append("<tr><th>creation_time</th>"); |
| html.append("<td>" + txJson.get(TransactionDetail.KEY_CREATION_TIME) + "</td>"); |
| html.append("<th>xid_as_base_64</th>"); |
| html.append("<td colspan=\"3\">" + txJson.get(TransactionDetail.KEY_XID_AS_BASE64) + "</td></tr>"); |
| html.append("<tr><th>xid_format_id</th>"); |
| html.append("<td>" + txJson.get(TransactionDetail.KEY_XID_FORMAT_ID) + "</td>"); |
| html.append("<th>xid_global_txid</th>"); |
| html.append("<td>" + txJson.get(TransactionDetail.KEY_XID_GLOBAL_TXID) + "</td>"); |
| html.append("<th>xid_branch_qual</th>"); |
| html.append("<td>" + txJson.get(TransactionDetail.KEY_XID_BRANCH_QUAL) + "</td></tr>"); |
| |
| html.append("<tr><th colspan=\"6\">Message List</th></tr>"); |
| html.append("<tr><td colspan=\"6\">"); |
| html.append("<table border=\"1\" cellspacing=\"0\" cellpadding=\"0\">"); |
| |
| JsonArray msgs = txJson.getJsonArray(TransactionDetail.KEY_TX_RELATED_MESSAGES); |
| for (int i = 0; i < msgs.size(); i++) { |
| JsonObject msgJson = msgs.getJsonObject(i); |
| JsonObject props = msgJson.getJsonObject(TransactionDetail.KEY_MSG_PROPERTIES); |
| StringBuilder propstr = new StringBuilder(); |
| Set<String> keys = props.keySet(); |
| for (String key : keys) { |
| propstr.append(key); |
| propstr.append("="); |
| propstr.append(props.get(key)); |
| propstr.append(", "); |
| } |
| |
| html.append("<th>operation_type</th>"); |
| html.append("<td>" + msgJson.get(TransactionDetail.KEY_MSG_OP_TYPE) + "</th>"); |
| html.append("<th>message_type</th>"); |
| html.append("<td>" + msgJson.get(TransactionDetail.KEY_MSG_TYPE) + "</td></tr>"); |
| html.append("<tr><th>properties</th>"); |
| html.append("<td colspan=\"3\">" + propstr.toString() + "</td></tr>"); |
| } |
| html.append("</table></td></tr>"); |
| html.append("</table><br>"); |
| } |
| |
| return html.toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String[] listHeuristicCommittedTransactions() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listHeuristicCommittedTransactions(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| List<Xid> xids = resourceManager.getHeuristicCommittedTransactions(); |
| String[] s = new String[xids.size()]; |
| int i = 0; |
| for (Xid xid : xids) { |
| s[i++] = XidImpl.toBase64String(xid); |
| } |
| return s; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String[] listHeuristicRolledBackTransactions() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listHeuristicRolledBackTransactions(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| List<Xid> xids = resourceManager.getHeuristicRolledbackTransactions(); |
| String[] s = new String[xids.size()]; |
| int i = 0; |
| for (Xid xid : xids) { |
| s[i++] = XidImpl.toBase64String(xid); |
| } |
| return s; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public synchronized boolean commitPreparedTransaction(final String transactionAsBase64) throws Exception { |
| // commit might be a long running task if dealing with a large transaction |
| // ensuring a single one just in case |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.commitPreparedTransaction(this.server, transactionAsBase64); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| List<Xid> xids = resourceManager.getPreparedTransactions(); |
| |
| for (Xid xid : xids) { |
| if (XidImpl.toBase64String(xid).equals(transactionAsBase64)) { |
| Transaction transaction = resourceManager.removeTransaction(xid, null); |
| transaction.commit(false); |
| long recordID = server.getStorageManager().storeHeuristicCompletion(xid, true); |
| storageManager.waitOnOperations(); |
| resourceManager.putHeuristicCompletion(recordID, xid, true); |
| return true; |
| } |
| } |
| return false; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| } |
| |
| @Override |
| public synchronized boolean rollbackPreparedTransaction(final String transactionAsBase64) throws Exception { |
| // rollback might be a long running task if dealing with a large transaction |
| // ensuring a single task just in case |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.rollbackPreparedTransaction(this.server, transactionAsBase64); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| |
| List<Xid> xids = resourceManager.getPreparedTransactions(); |
| |
| for (Xid xid : xids) { |
| if (XidImpl.toBase64String(xid).equals(transactionAsBase64)) { |
| Transaction transaction = resourceManager.removeTransaction(xid, null); |
| transaction.rollback(); |
| long recordID = server.getStorageManager().storeHeuristicCompletion(xid, false); |
| server.getStorageManager().waitOnOperations(); |
| resourceManager.putHeuristicCompletion(recordID, xid, false); |
| return true; |
| } |
| } |
| return false; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| } |
| |
| @Override |
| public String[] listRemoteAddresses() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listRemoteAddresses(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Set<RemotingConnection> connections = remotingService.getConnections(); |
| |
| String[] remoteAddresses = new String[connections.size()]; |
| int i = 0; |
| for (RemotingConnection connection : connections) { |
| remoteAddresses[i++] = connection.getRemoteAddress(); |
| } |
| return remoteAddresses; |
| } finally { |
| blockOnIO(); |
| } |
| |
| } |
| |
| @Override |
| public String[] listRemoteAddresses(final String ipAddress) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listRemoteAddresses(this.server, ipAddress); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Set<RemotingConnection> connections = remotingService.getConnections(); |
| List<String> remoteConnections = new ArrayList<>(); |
| for (RemotingConnection connection : connections) { |
| String remoteAddress = connection.getRemoteAddress(); |
| if (remoteAddress.contains(ipAddress)) { |
| remoteConnections.add(connection.getRemoteAddress()); |
| } |
| } |
| return remoteConnections.toArray(new String[remoteConnections.size()]); |
| } finally { |
| blockOnIO(); |
| } |
| |
| } |
| |
| @Override |
| public boolean closeConnectionsForAddress(final String ipAddress) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.closeConnectionsForAddress(this.server, ipAddress); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| boolean closed = false; |
| Set<RemotingConnection> connections = remotingService.getConnections(); |
| for (RemotingConnection connection : connections) { |
| String remoteAddress = connection.getRemoteAddress(); |
| if (remoteAddress.contains(ipAddress)) { |
| connection.fail(ActiveMQMessageBundle.BUNDLE.connectionsClosedByManagement(ipAddress)); |
| remotingService.removeConnection(connection.getID()); |
| closed = true; |
| } |
| } |
| |
| return closed; |
| } finally { |
| blockOnIO(); |
| } |
| |
| } |
| |
| @Override |
| public boolean closeConsumerConnectionsForAddress(final String address) { |
| // this could be a long running task, ensuring a single task |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.closeConsumerConnectionsForAddress(this.server, address); |
| } |
| boolean closed = false; |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| for (Binding binding : postOffice.getMatchingBindings(SimpleString.of(address))) { |
| if (binding instanceof LocalQueueBinding) { |
| Queue queue = ((LocalQueueBinding) binding).getQueue(); |
| for (Consumer consumer : queue.getConsumers()) { |
| if (consumer instanceof ServerConsumer) { |
| ServerConsumer serverConsumer = (ServerConsumer) consumer; |
| RemotingConnection connection = null; |
| |
| for (RemotingConnection potentialConnection : remotingService.getConnections()) { |
| if (potentialConnection.getID().toString().equals(String.valueOf(serverConsumer.getConnectionID()))) { |
| connection = potentialConnection; |
| } |
| } |
| |
| if (connection != null) { |
| remotingService.removeConnection(connection.getID()); |
| connection.fail(ActiveMQMessageBundle.BUNDLE.consumerConnectionsClosedByManagement(address)); |
| closed = true; |
| } |
| } |
| } |
| } |
| } |
| } catch (Exception e) { |
| ActiveMQServerLogger.LOGGER.failedToCloseConsumerConnectionsForAddress(address, e); |
| } finally { |
| blockOnIO(); |
| } |
| return closed; |
| } catch (Throwable e) { |
| throw new RuntimeException(e.getMessage(), e); |
| } |
| } |
| |
| @Override |
| public boolean closeConnectionsForUser(final String userName) { |
| // possibly a long running task |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.closeConnectionsForUser(this.server, userName); |
| } |
| boolean closed = false; |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| for (ServerSession serverSession : server.getSessions()) { |
| if (serverSession.getUsername() != null && serverSession.getUsername().equals(userName)) { |
| RemotingConnection connection = null; |
| |
| for (RemotingConnection potentialConnection : remotingService.getConnections()) { |
| if (potentialConnection.getID().toString().equals(serverSession.getConnectionID().toString())) { |
| connection = potentialConnection; |
| } |
| } |
| |
| if (connection != null) { |
| remotingService.removeConnection(connection.getID()); |
| connection.fail(ActiveMQMessageBundle.BUNDLE.connectionsForUserClosedByManagement(userName)); |
| closed = true; |
| } |
| } |
| } |
| } finally { |
| blockOnIO(); |
| } |
| return closed; |
| } catch (Throwable e) { |
| throw new RuntimeException(e.getMessage(), e); |
| } |
| } |
| |
| @Override |
| public boolean closeConnectionWithID(final String ID) { |
| // possibly a long running task |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.closeConnectionWithID(this.server, ID); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| for (RemotingConnection connection : remotingService.getConnections()) { |
| if (connection.getID().toString().equals(ID)) { |
| remotingService.removeConnection(connection.getID()); |
| connection.fail(ActiveMQMessageBundle.BUNDLE.connectionWithIDClosedByManagement(ID)); |
| return true; |
| } |
| } |
| } finally { |
| blockOnIO(); |
| } |
| return false; |
| } catch (Throwable e) { |
| throw new RuntimeException(e.getMessage(), e); |
| } |
| } |
| |
| @Override |
| public boolean closeSessionWithID(final String connectionID, final String ID) throws Exception { |
| return closeSessionWithID(connectionID, ID, false); |
| } |
| |
| @Override |
| public boolean closeSessionWithID(final String connectionID, final String ID, final boolean force) throws Exception { |
| // possibly a long running task |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.closeSessionWithID(this.server, connectionID, ID); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| List<ServerSession> sessions = server.getSessions(connectionID); |
| for (ServerSession session : sessions) { |
| if (session.getName().equals(ID.toString())) { |
| session.close(true, force); |
| return true; |
| } |
| } |
| |
| } finally { |
| blockOnIO(); |
| } |
| return false; |
| } |
| } |
| |
| @Override |
| public boolean closeConsumerWithID(final String sessionID, final String ID) throws Exception { |
| // possibly a long running task |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.closeConsumerWithID(this.server, sessionID, ID); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Set<ServerSession> sessions = server.getSessions(); |
| for (ServerSession session : sessions) { |
| if (session.getName().equals(sessionID.toString())) { |
| Set<ServerConsumer> serverConsumers = session.getServerConsumers(); |
| for (ServerConsumer serverConsumer : serverConsumers) { |
| if (serverConsumer.sequentialID() == Long.parseLong(ID)) { |
| serverConsumer.disconnect(); |
| return true; |
| } |
| } |
| } |
| } |
| |
| } finally { |
| blockOnIO(); |
| } |
| return false; |
| } |
| } |
| |
| @Override |
| public String[] listConnectionIDs() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listConnectionIDs(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Set<RemotingConnection> connections = remotingService.getConnections(); |
| String[] connectionIDs = new String[connections.size()]; |
| int i = 0; |
| for (RemotingConnection connection : connections) { |
| connectionIDs[i++] = connection.getID().toString(); |
| } |
| return connectionIDs; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String[] listSessions(final String connectionID) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listSessions(this.server, connectionID); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| List<ServerSession> sessions = server.getSessions(connectionID); |
| String[] sessionIDs = new String[sessions.size()]; |
| int i = 0; |
| for (ServerSession serverSession : sessions) { |
| sessionIDs[i++] = serverSession.getName(); |
| } |
| return sessionIDs; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see org.apache.activemq.artemis.api.core.management.ActiveMQServerControl#listProducersInfoAsJSON() |
| */ |
| @Override |
| public String listProducersInfoAsJSON() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listProducersInfoAsJSON(this.server); |
| } |
| JsonArrayBuilder producers = JsonLoader.createArrayBuilder(); |
| |
| for (ServerSession session : server.getSessions()) { |
| session.describeProducersInfo(producers); |
| } |
| |
| return producers.build().toString(); |
| } |
| |
| @Override |
| public String listConnections(String options, int page, int pageSize) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listConnections(this.server, options, page, pageSize); |
| } |
| checkStarted(); |
| clearIO(); |
| try { |
| server.getPostOffice().getAddresses(); |
| ConnectionView view = new ConnectionView(server); |
| view.setCollection(server.getRemotingService().getConnections()); |
| view.setOptions(options); |
| return view.getResultsAsJson(page, pageSize); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listSessions(String options, int page, int pageSize) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listSessions(this.server, options, page, pageSize); |
| } |
| checkStarted(); |
| clearIO(); |
| try { |
| SessionView view = new SessionView(); |
| view.setCollection(server.getSessions()); |
| view.setOptions(options); |
| return view.getResultsAsJson(page, pageSize); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listConsumers(String options, int page, int pageSize) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listConsumers(this.server, options, page, pageSize); |
| } |
| checkStarted(); |
| clearIO(); |
| try { |
| Set<ServerConsumer> consumers = new HashSet(); |
| for (ServerSession session : server.getSessions()) { |
| consumers.addAll(session.getServerConsumers()); |
| } |
| ConsumerView view = new ConsumerView(server); |
| view.setCollection(consumers); |
| view.setOptions(options); |
| return view.getResultsAsJson(page, pageSize); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listAddresses(String options, int page, int pageSize) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listAddresses(this.server, options, page, pageSize); |
| } |
| checkStarted(); |
| clearIO(); |
| try { |
| final Set<SimpleString> addresses = server.getPostOffice().getAddresses(); |
| List<AddressInfo> addressInfo = new ArrayList<>(); |
| for (SimpleString address : addresses) { |
| AddressInfo info = server.getPostOffice().getAddressInfo(address); |
| //ignore if no longer available |
| if (info != null) { |
| addressInfo.add(info); |
| } |
| } |
| AddressView view = new AddressView(server); |
| view.setCollection(addressInfo); |
| view.setOptions(options); |
| return view.getResultsAsJson(page, pageSize); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listQueues(String options, int page, int pageSize) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listQueues(this.server, options, page, pageSize); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| List<QueueControl> queues = new ArrayList<>(); |
| Object[] qs = server.getManagementService().getResources(QueueControl.class); |
| for (int i = 0; i < qs.length; i++) { |
| queues.add((QueueControl) qs[i]); |
| } |
| QueueView view = new QueueView(server); |
| view.setCollection(queues); |
| view.setOptions(options); |
| return view.getResultsAsJson(page, pageSize); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listProducers(@Parameter(name = "Options") String options, |
| @Parameter(name = "Page Number") int page, |
| @Parameter(name = "Page Size") int pageSize) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listProducers(this.server, options, page, pageSize); |
| } |
| checkStarted(); |
| clearIO(); |
| try { |
| Set<ServerProducer> producers = new HashSet<>(); |
| for (ServerSession session : server.getSessions()) { |
| producers.addAll(session.getServerProducers()); |
| } |
| ProducerView view = new ProducerView(server); |
| view.setCollection(producers); |
| view.setOptions(options); |
| return view.getResultsAsJson(page, pageSize); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listConnectionsAsJSON() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listConnectionsAsJSON(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| JsonArrayBuilder array = JsonLoader.createArrayBuilder(); |
| |
| Set<RemotingConnection> connections = server.getRemotingService().getConnections(); |
| |
| for (RemotingConnection connection : connections) { |
| JsonObjectBuilder obj = JsonLoader.createObjectBuilder().add("connectionID", connection.getID().toString()).add("clientAddress", connection.getRemoteAddress()).add("creationTime", connection.getCreationTime()).add("implementation", connection.getClass().getSimpleName()).add("sessionCount", server.getSessions(connection.getID().toString()).size()); |
| array.add(obj); |
| } |
| return array.build().toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listSessionsAsJSON(final String connectionID) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listSessionsAsJSON(this.server, connectionID); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| JsonArrayBuilder array = JsonLoader.createArrayBuilder(); |
| try { |
| List<ServerSession> sessions = server.getSessions(connectionID); |
| for (ServerSession sess : sessions) { |
| buildSessionJSON(array, sess); |
| } |
| } finally { |
| blockOnIO(); |
| } |
| return array.build().toString(); |
| } |
| |
| @Override |
| public String listAllSessionsAsJSON() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listAllSessionsAsJSON(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| JsonArrayBuilder array = JsonLoader.createArrayBuilder(); |
| try { |
| Set<ServerSession> sessions = server.getSessions(); |
| for (ServerSession sess : sessions) { |
| buildSessionJSON(array, sess); |
| } |
| } finally { |
| blockOnIO(); |
| } |
| return array.build().toString(); |
| } |
| |
| public void buildSessionJSON(JsonArrayBuilder array, ServerSession sess) { |
| JsonObjectBuilder obj = JsonLoader.createObjectBuilder().add("sessionID", sess.getName()).add("creationTime", sess.getCreationTime()).add("consumerCount", sess.getServerConsumers().size()); |
| |
| if (sess.getValidatedUser() != null) { |
| obj.add("validatedUser", sess.getValidatedUser()); |
| obj.add("principal", sess.getValidatedUser()); |
| } |
| |
| if (sess.getMetaData() != null) { |
| final JsonObjectBuilder metadata = JsonLoader.createObjectBuilder(); |
| for (Entry<String, String> entry : sess.getMetaData().entrySet()) { |
| metadata.add(entry.getKey(), entry.getValue()); |
| } |
| obj.add("metadata", metadata); |
| } |
| |
| array.add(obj); |
| } |
| |
| @Override |
| public String listConsumersAsJSON(String connectionID) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listConsumersAsJSON(this.server, connectionID); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| JsonArrayBuilder array = JsonLoader.createArrayBuilder(); |
| |
| Set<RemotingConnection> connections = server.getRemotingService().getConnections(); |
| for (RemotingConnection connection : connections) { |
| if (connectionID.equals(connection.getID().toString())) { |
| List<ServerSession> sessions = server.getSessions(connectionID); |
| for (ServerSession session : sessions) { |
| Set<ServerConsumer> consumers = session.getServerConsumers(); |
| for (ServerConsumer consumer : consumers) { |
| JsonObject obj = toJSONObject(consumer); |
| if (obj != null) { |
| array.add(obj); |
| } |
| } |
| } |
| } |
| } |
| return array.build().toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listAllConsumersAsJSON() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listAllConsumersAsJSON(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| JsonArrayBuilder array = JsonLoader.createArrayBuilder(); |
| |
| Set<ServerSession> sessions = server.getSessions(); |
| for (ServerSession session : sessions) { |
| Set<ServerConsumer> consumers = session.getServerConsumers(); |
| for (ServerConsumer consumer : consumers) { |
| JsonObject obj = toJSONObject(consumer); |
| if (obj != null) { |
| array.add(obj); |
| } |
| } |
| } |
| return array.build().toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| private JsonObject toJSONObject(ServerConsumer consumer) throws Exception { |
| List<MessageReference> deliveringMessages = consumer.getDeliveringMessages(); |
| JsonObjectBuilder obj = JsonLoader.createObjectBuilder() |
| .add(ConsumerField.ID.getAlternativeName(), consumer.getID()) |
| .add(ConsumerField.SEQUENTIAL_ID.getAlternativeName(), consumer.getSequentialID()) |
| .add(ConsumerField.CONNECTION.getAlternativeName(), consumer.getConnectionID().toString()) |
| .add(ConsumerField.SESSION.getAlternativeName(), consumer.getSessionID()) |
| .add(ConsumerField.QUEUE.getAlternativeName(), consumer.getQueue().getName().toString()) |
| .add(ConsumerField.BROWSE_ONLY.getName(), consumer.isBrowseOnly()) |
| .add(ConsumerField.CREATION_TIME.getName(), consumer.getCreationTime()) |
| // deliveringCount is renamed as MESSAGES_IN_TRANSIT but left in json for backward compatibility |
| .add(ConsumerField.MESSAGES_IN_TRANSIT.getAlternativeName(), consumer.getMessagesInTransit()) |
| .add(ConsumerField.MESSAGES_IN_TRANSIT.getName(), consumer.getMessagesInTransit()) |
| .add(ConsumerField.MESSAGES_IN_TRANSIT_SIZE.getName(), consumer.getMessagesInTransitSize()) |
| .add(ConsumerField.MESSAGES_DELIVERED.getName(), consumer.getMessagesDelivered()) |
| .add(ConsumerField.MESSAGES_DELIVERED_SIZE.getName(), consumer.getMessagesDeliveredSize()) |
| .add(ConsumerField.MESSAGES_ACKNOWLEDGED.getName(), consumer.getMessagesAcknowledged()) |
| .add(ConsumerField.MESSAGES_ACKNOWLEDGED_AWAITING_COMMIT.getName(), consumer.getMessagesAcknowledgedAwaitingCommit()) |
| .add(ConsumerField.LAST_DELIVERED_TIME.getName(), consumer.getLastDeliveredTime()) |
| .add(ConsumerField.LAST_ACKNOWLEDGED_TIME.getName(), consumer.getLastAcknowledgedTime()) |
| .add(ConsumerField.STATUS.getName(), ConsumerView.checkConsumerStatus(consumer, server)); |
| if (consumer.getFilter() != null) { |
| obj.add("filter", consumer.getFilter().getFilterString().toString()); |
| } |
| |
| return obj.build(); |
| } |
| |
| @Override |
| public Object[] getConnectors() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getConnectors(this.server); |
| } |
| return getNetworkConfigs(configuration.getConnectorConfigurations().values()); |
| } |
| |
| @Override |
| public Object[] getAcceptors() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getAcceptors(this.server); |
| } |
| return getNetworkConfigs(configuration.getAcceptorConfigurations()); |
| } |
| |
| private Object[] getNetworkConfigs(Collection<TransportConfiguration> configs) throws Exception { |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Object[] ret = new Object[configs.size()]; |
| |
| int i = 0; |
| for (TransportConfiguration config : configs) { |
| Object[] tc = new Object[3]; |
| |
| tc[0] = config.getName(); |
| tc[1] = config.getFactoryClassName(); |
| tc[2] = config.getParams(); |
| |
| ret[i++] = tc; |
| } |
| return ret; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String getConnectorsAsJSON() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getConnectorsAsJSON(this.server); |
| } |
| |
| return getNetworkConfigsAsJSON(configuration.getConnectorConfigurations().values()); |
| } |
| |
| @Override |
| public String getAcceptorsAsJSON() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getAcceptorsAsJSON(this.server); |
| } |
| |
| return getNetworkConfigsAsJSON(configuration.getAcceptorConfigurations()); |
| } |
| |
| private String getNetworkConfigsAsJSON(Collection<TransportConfiguration> configs) throws Exception { |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| JsonArrayBuilder array = JsonLoader.createArrayBuilder(); |
| |
| for (TransportConfiguration config : configs) { |
| array.add(config.toJson()); |
| } |
| |
| return array.build().toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void addSecuritySettings(final String addressMatch, |
| final String sendRoles, |
| final String consumeRoles, |
| final String createDurableQueueRoles, |
| final String deleteDurableQueueRoles, |
| final String createNonDurableQueueRoles, |
| final String deleteNonDurableQueueRoles, |
| final String manageRoles) throws Exception { |
| addSecuritySettings(addressMatch, sendRoles, consumeRoles, createDurableQueueRoles, deleteDurableQueueRoles, createNonDurableQueueRoles, deleteNonDurableQueueRoles, manageRoles, ""); |
| } |
| |
| @Override |
| public void addSecuritySettings(final String addressMatch, |
| final String sendRoles, |
| final String consumeRoles, |
| final String createDurableQueueRoles, |
| final String deleteDurableQueueRoles, |
| final String createNonDurableQueueRoles, |
| final String deleteNonDurableQueueRoles, |
| final String manageRoles, |
| final String browseRoles) throws Exception { |
| addSecuritySettings(addressMatch, sendRoles, consumeRoles, createDurableQueueRoles, deleteDurableQueueRoles, createNonDurableQueueRoles, deleteNonDurableQueueRoles, manageRoles, browseRoles, "", ""); |
| } |
| |
| @Override |
| public void addSecuritySettings(final String addressMatch, |
| final String sendRoles, |
| final String consumeRoles, |
| final String createDurableQueueRoles, |
| final String deleteDurableQueueRoles, |
| final String createNonDurableQueueRoles, |
| final String deleteNonDurableQueueRoles, |
| final String manageRoles, |
| final String browseRoles, |
| final String createAddressRoles, |
| final String deleteAddressRoles) throws Exception { |
| addSecuritySettings(addressMatch, sendRoles, consumeRoles, createDurableQueueRoles, deleteDurableQueueRoles, createNonDurableQueueRoles, deleteNonDurableQueueRoles, manageRoles, browseRoles, createAddressRoles, deleteAddressRoles, "", ""); |
| } |
| |
| @Override |
| public void addSecuritySettings(final String addressMatch, |
| final String sendRoles, |
| final String consumeRoles, |
| final String createDurableQueueRoles, |
| final String deleteDurableQueueRoles, |
| final String createNonDurableQueueRoles, |
| final String deleteNonDurableQueueRoles, |
| final String manageRoles, |
| final String browseRoles, |
| final String createAddressRoles, |
| final String deleteAddressRoles, |
| final String viewRoles, |
| final String editRoles) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.addSecuritySettings(this.server, addressMatch, sendRoles, consumeRoles, createDurableQueueRoles, |
| deleteDurableQueueRoles, createNonDurableQueueRoles, deleteNonDurableQueueRoles, manageRoles, |
| browseRoles, createAddressRoles, deleteAddressRoles, viewRoles, editRoles); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Set<Role> roles = SecurityFormatter.createSecurity(sendRoles, consumeRoles, createDurableQueueRoles, deleteDurableQueueRoles, createNonDurableQueueRoles, deleteNonDurableQueueRoles, manageRoles, browseRoles, createAddressRoles, deleteAddressRoles); |
| |
| server.getSecurityRepository().addMatch(addressMatch, roles); |
| |
| PersistedSecuritySetting persistedRoles = new PersistedSecuritySetting(addressMatch, sendRoles, consumeRoles, createDurableQueueRoles, deleteDurableQueueRoles, createNonDurableQueueRoles, deleteNonDurableQueueRoles, manageRoles, browseRoles, createAddressRoles, deleteAddressRoles, viewRoles, editRoles); |
| |
| storageManager.storeSecuritySetting(persistedRoles); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void removeSecuritySettings(final String addressMatch) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.removeSecuritySettings(this.server, addressMatch); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| server.getSecurityRepository().removeMatch(addressMatch); |
| storageManager.deleteSecuritySetting(SimpleString.of(addressMatch)); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public Object[] getRoles(final String addressMatch) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getRoles(this.server, addressMatch); |
| } |
| |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Set<Role> roles = server.getSecurityRepository().getMatch(addressMatch); |
| |
| Object[] objRoles = new Object[roles.size()]; |
| |
| int i = 0; |
| for (Role role : roles) { |
| objRoles[i++] = CheckType.asObjectArray(role); |
| } |
| return objRoles; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String getRolesAsJSON(final String addressMatch) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getRolesAsJSON(this.server, addressMatch); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| JsonArrayBuilder json = JsonLoader.createArrayBuilder(); |
| Set<Role> roles = server.getSecurityRepository().getMatch(addressMatch); |
| |
| for (Role role : roles) { |
| json.add(role.toJson()); |
| } |
| return json.build().toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String getAddressSettingsAsJSON(final String address) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getAddressSettingsAsJSON(this.server, address); |
| } |
| checkStarted(); |
| |
| AddressSettings addressSettings = server.getAddressSettingsRepository().getMatch(address); |
| return addressSettings.toJSON(); |
| } |
| |
| @Override |
| @Deprecated |
| public void addAddressSettings(final String address, |
| final String DLA, |
| final String expiryAddress, |
| final long expiryDelay, |
| final boolean lastValueQueue, |
| final int deliveryAttempts, |
| final long maxSizeBytes, |
| final int pageSizeBytes, |
| final int pageMaxCacheSize, |
| final long redeliveryDelay, |
| final double redeliveryMultiplier, |
| final long maxRedeliveryDelay, |
| final long redistributionDelay, |
| final boolean sendToDLAOnNoRoute, |
| final String addressFullMessagePolicy, |
| final long slowConsumerThreshold, |
| final long slowConsumerCheckPeriod, |
| final String slowConsumerPolicy, |
| final boolean autoCreateJmsQueues, |
| final boolean autoDeleteJmsQueues, |
| final boolean autoCreateJmsTopics, |
| final boolean autoDeleteJmsTopics) throws Exception { |
| addAddressSettings(address, |
| DLA, |
| expiryAddress, |
| expiryDelay, |
| lastValueQueue, |
| deliveryAttempts, |
| maxSizeBytes, |
| pageSizeBytes, |
| pageMaxCacheSize, |
| redeliveryDelay, |
| redeliveryMultiplier, |
| maxRedeliveryDelay, |
| redistributionDelay, |
| sendToDLAOnNoRoute, |
| addressFullMessagePolicy, |
| slowConsumerThreshold, |
| slowConsumerCheckPeriod, |
| slowConsumerPolicy, |
| autoCreateJmsQueues, |
| autoDeleteJmsQueues, |
| autoCreateJmsTopics, |
| autoDeleteJmsTopics, |
| AddressSettings.DEFAULT_AUTO_CREATE_QUEUES, |
| AddressSettings.DEFAULT_AUTO_DELETE_QUEUES, |
| AddressSettings.DEFAULT_AUTO_CREATE_ADDRESSES, |
| AddressSettings.DEFAULT_AUTO_DELETE_ADDRESSES); |
| } |
| |
| @Override |
| @Deprecated |
| public void addAddressSettings(final String address, |
| final String DLA, |
| final String expiryAddress, |
| final long expiryDelay, |
| final boolean defaultLastValueQueue, |
| final int maxDeliveryAttempts, |
| final long maxSizeBytes, |
| final int pageSizeBytes, |
| final int pageMaxCacheSize, |
| final long redeliveryDelay, |
| final double redeliveryMultiplier, |
| final long maxRedeliveryDelay, |
| final long redistributionDelay, |
| final boolean sendToDLAOnNoRoute, |
| final String addressFullMessagePolicy, |
| final long slowConsumerThreshold, |
| final long slowConsumerCheckPeriod, |
| final String slowConsumerPolicy, |
| final boolean autoCreateJmsQueues, |
| final boolean autoDeleteJmsQueues, |
| final boolean autoCreateJmsTopics, |
| final boolean autoDeleteJmsTopics, |
| final boolean autoCreateQueues, |
| final boolean autoDeleteQueues, |
| final boolean autoCreateAddresses, |
| final boolean autoDeleteAddresses) throws Exception { |
| addAddressSettings(address, |
| DLA, |
| expiryAddress, |
| expiryDelay, |
| defaultLastValueQueue, |
| maxDeliveryAttempts, |
| maxSizeBytes, |
| pageSizeBytes, |
| pageMaxCacheSize, |
| redeliveryDelay, |
| redeliveryMultiplier, |
| maxRedeliveryDelay, |
| redistributionDelay, |
| sendToDLAOnNoRoute, |
| addressFullMessagePolicy, |
| slowConsumerThreshold, |
| slowConsumerCheckPeriod, |
| slowConsumerPolicy, |
| autoCreateJmsQueues, |
| autoDeleteJmsQueues, |
| autoCreateJmsTopics, |
| autoDeleteJmsTopics, |
| autoCreateQueues, |
| autoDeleteQueues, |
| autoCreateAddresses, |
| autoDeleteAddresses, |
| AddressSettings.DEFAULT_CONFIG_DELETE_QUEUES.toString(), |
| AddressSettings.DEFAULT_CONFIG_DELETE_ADDRESSES.toString(), |
| AddressSettings.DEFAULT_ADDRESS_REJECT_THRESHOLD, |
| ActiveMQDefaultConfiguration.getDefaultLastValueKey() == null ? null : ActiveMQDefaultConfiguration.getDefaultLastValueKey().toString(), |
| ActiveMQDefaultConfiguration.getDefaultNonDestructive(), |
| ActiveMQDefaultConfiguration.getDefaultExclusive(), |
| ActiveMQDefaultConfiguration.getDefaultGroupRebalance(), |
| ActiveMQDefaultConfiguration.getDefaultGroupBuckets(), |
| ActiveMQDefaultConfiguration.getDefaultGroupFirstKey() == null ? null : ActiveMQDefaultConfiguration.getDefaultGroupFirstKey().toString(), |
| ActiveMQDefaultConfiguration.getDefaultMaxQueueConsumers(), |
| ActiveMQDefaultConfiguration.getDefaultPurgeOnNoConsumers(), |
| ActiveMQDefaultConfiguration.getDefaultConsumersBeforeDispatch(), |
| ActiveMQDefaultConfiguration.getDefaultDelayBeforeDispatch(), |
| ActiveMQDefaultConfiguration.getDefaultRoutingType().toString(), |
| ActiveMQDefaultConfiguration.getDefaultRoutingType().toString(), |
| ActiveMQClient.DEFAULT_CONSUMER_WINDOW_SIZE, |
| ActiveMQDefaultConfiguration.getDefaultRingSize(), |
| AddressSettings.DEFAULT_AUTO_DELETE_CREATED_QUEUES, |
| AddressSettings.DEFAULT_AUTO_DELETE_QUEUES_DELAY, |
| AddressSettings.DEFAULT_AUTO_DELETE_QUEUES_MESSAGE_COUNT, |
| AddressSettings.DEFAULT_AUTO_DELETE_ADDRESSES_DELAY, |
| AddressSettings.DEFAULT_REDELIVER_COLLISION_AVOIDANCE_FACTOR, |
| ActiveMQDefaultConfiguration.getDefaultRetroactiveMessageCount()); |
| } |
| |
| @Override |
| @Deprecated |
| public void addAddressSettings(final String address, |
| final String DLA, |
| final String expiryAddress, |
| final long expiryDelay, |
| final boolean defaultLastValueQueue, |
| final int maxDeliveryAttempts, |
| final long maxSizeBytes, |
| final int pageSizeBytes, |
| final int pageMaxCacheSize, |
| final long redeliveryDelay, |
| final double redeliveryMultiplier, |
| final long maxRedeliveryDelay, |
| final long redistributionDelay, |
| final boolean sendToDLAOnNoRoute, |
| final String addressFullMessagePolicy, |
| final long slowConsumerThreshold, |
| final long slowConsumerCheckPeriod, |
| final String slowConsumerPolicy, |
| final boolean autoCreateJmsQueues, |
| final boolean autoDeleteJmsQueues, |
| final boolean autoCreateJmsTopics, |
| final boolean autoDeleteJmsTopics, |
| final boolean autoCreateQueues, |
| final boolean autoDeleteQueues, |
| final boolean autoCreateAddresses, |
| final boolean autoDeleteAddresses, |
| final String configDeleteQueues, |
| final String configDeleteAddresses, |
| final long maxSizeBytesRejectThreshold, |
| final String defaultLastValueKey, |
| final boolean defaultNonDestructive, |
| final boolean defaultExclusiveQueue, |
| final boolean defaultGroupRebalance, |
| final int defaultGroupBuckets, |
| final String defaultGroupFirstKey, |
| final int defaultMaxConsumers, |
| final boolean defaultPurgeOnNoConsumers, |
| final int defaultConsumersBeforeDispatch, |
| final long defaultDelayBeforeDispatch, |
| final String defaultQueueRoutingType, |
| final String defaultAddressRoutingType, |
| final int defaultConsumerWindowSize, |
| final long defaultRingSize, |
| final boolean autoDeleteCreatedQueues, |
| final long autoDeleteQueuesDelay, |
| final long autoDeleteQueuesMessageCount, |
| final long autoDeleteAddressesDelay, |
| final double redeliveryCollisionAvoidanceFactor, |
| final long retroactiveMessageCount) throws Exception { |
| addAddressSettings(address, |
| DLA, |
| expiryAddress, |
| expiryDelay, |
| defaultLastValueQueue, |
| maxDeliveryAttempts, |
| maxSizeBytes, |
| pageSizeBytes, |
| pageMaxCacheSize, |
| redeliveryDelay, |
| redeliveryMultiplier, |
| maxRedeliveryDelay, |
| redistributionDelay, |
| sendToDLAOnNoRoute, |
| addressFullMessagePolicy, |
| slowConsumerThreshold, |
| slowConsumerCheckPeriod, |
| slowConsumerPolicy, |
| autoCreateJmsQueues, |
| autoDeleteJmsQueues, |
| autoCreateJmsTopics, |
| autoDeleteJmsTopics, |
| autoCreateQueues, |
| autoDeleteQueues, |
| autoCreateAddresses, |
| autoDeleteAddresses, |
| configDeleteQueues, |
| configDeleteAddresses, |
| maxSizeBytesRejectThreshold, |
| defaultLastValueKey, |
| defaultNonDestructive, |
| defaultExclusiveQueue, |
| defaultGroupRebalance, |
| defaultGroupBuckets, |
| defaultGroupFirstKey, |
| defaultMaxConsumers, |
| defaultPurgeOnNoConsumers, |
| defaultConsumersBeforeDispatch, |
| defaultDelayBeforeDispatch, |
| defaultQueueRoutingType, |
| defaultAddressRoutingType, |
| defaultConsumerWindowSize, |
| defaultRingSize, |
| autoDeleteCreatedQueues, |
| autoDeleteQueuesDelay, |
| autoDeleteQueuesMessageCount, |
| autoDeleteAddressesDelay, |
| redeliveryCollisionAvoidanceFactor, |
| retroactiveMessageCount, |
| AddressSettings.DEFAULT_AUTO_CREATE_DEAD_LETTER_RESOURCES, |
| AddressSettings.DEFAULT_DEAD_LETTER_QUEUE_PREFIX.toString(), |
| AddressSettings.DEFAULT_DEAD_LETTER_QUEUE_SUFFIX.toString(), |
| AddressSettings.DEFAULT_AUTO_CREATE_EXPIRY_RESOURCES, |
| AddressSettings.DEFAULT_EXPIRY_QUEUE_PREFIX.toString(), |
| AddressSettings.DEFAULT_EXPIRY_QUEUE_SUFFIX.toString()); |
| } |
| |
| @Override |
| @Deprecated |
| public void addAddressSettings(final String address, |
| final String DLA, |
| final String expiryAddress, |
| final long expiryDelay, |
| final boolean defaultLastValueQueue, |
| final int maxDeliveryAttempts, |
| final long maxSizeBytes, |
| final int pageSizeBytes, |
| final int pageMaxCacheSize, |
| final long redeliveryDelay, |
| final double redeliveryMultiplier, |
| final long maxRedeliveryDelay, |
| final long redistributionDelay, |
| final boolean sendToDLAOnNoRoute, |
| final String addressFullMessagePolicy, |
| final long slowConsumerThreshold, |
| final long slowConsumerCheckPeriod, |
| final String slowConsumerPolicy, |
| final boolean autoCreateJmsQueues, |
| final boolean autoDeleteJmsQueues, |
| final boolean autoCreateJmsTopics, |
| final boolean autoDeleteJmsTopics, |
| final boolean autoCreateQueues, |
| final boolean autoDeleteQueues, |
| final boolean autoCreateAddresses, |
| final boolean autoDeleteAddresses, |
| final String configDeleteQueues, |
| final String configDeleteAddresses, |
| final long maxSizeBytesRejectThreshold, |
| final String defaultLastValueKey, |
| final boolean defaultNonDestructive, |
| final boolean defaultExclusiveQueue, |
| final boolean defaultGroupRebalance, |
| final int defaultGroupBuckets, |
| final String defaultGroupFirstKey, |
| final int defaultMaxConsumers, |
| final boolean defaultPurgeOnNoConsumers, |
| final int defaultConsumersBeforeDispatch, |
| final long defaultDelayBeforeDispatch, |
| final String defaultQueueRoutingType, |
| final String defaultAddressRoutingType, |
| final int defaultConsumerWindowSize, |
| final long defaultRingSize, |
| final boolean autoDeleteCreatedQueues, |
| final long autoDeleteQueuesDelay, |
| final long autoDeleteQueuesMessageCount, |
| final long autoDeleteAddressesDelay, |
| final double redeliveryCollisionAvoidanceFactor, |
| final long retroactiveMessageCount, |
| final boolean autoCreateDeadLetterResources, |
| final String deadLetterQueuePrefix, |
| final String deadLetterQueueSuffix, |
| final boolean autoCreateExpiryResources, |
| final String expiryQueuePrefix, |
| final String expiryQueueSuffix) throws Exception { |
| addAddressSettings(address, |
| DLA, |
| expiryAddress, |
| expiryDelay, |
| defaultLastValueQueue, |
| maxDeliveryAttempts, |
| maxSizeBytes, |
| pageSizeBytes, |
| pageMaxCacheSize, |
| redeliveryDelay, |
| redeliveryMultiplier, |
| maxRedeliveryDelay, |
| redistributionDelay, |
| sendToDLAOnNoRoute, |
| addressFullMessagePolicy, |
| slowConsumerThreshold, |
| slowConsumerCheckPeriod, |
| slowConsumerPolicy, |
| autoCreateJmsQueues, |
| autoDeleteJmsQueues, |
| autoCreateJmsTopics, |
| autoDeleteJmsTopics, |
| autoCreateQueues, |
| autoDeleteQueues, |
| autoCreateAddresses, |
| autoDeleteAddresses, |
| configDeleteQueues, |
| configDeleteAddresses, |
| maxSizeBytesRejectThreshold, |
| defaultLastValueKey, |
| defaultNonDestructive, |
| defaultExclusiveQueue, |
| defaultGroupRebalance, |
| defaultGroupBuckets, |
| defaultGroupFirstKey, |
| defaultMaxConsumers, |
| defaultPurgeOnNoConsumers, |
| defaultConsumersBeforeDispatch, |
| defaultDelayBeforeDispatch, |
| defaultQueueRoutingType, |
| defaultAddressRoutingType, |
| defaultConsumerWindowSize, |
| defaultRingSize, |
| autoDeleteCreatedQueues, |
| autoDeleteQueuesDelay, |
| autoDeleteQueuesMessageCount, |
| autoDeleteAddressesDelay, |
| redeliveryCollisionAvoidanceFactor, |
| retroactiveMessageCount, |
| AddressSettings.DEFAULT_AUTO_CREATE_DEAD_LETTER_RESOURCES, |
| AddressSettings.DEFAULT_DEAD_LETTER_QUEUE_PREFIX.toString(), |
| AddressSettings.DEFAULT_DEAD_LETTER_QUEUE_SUFFIX.toString(), |
| AddressSettings.DEFAULT_AUTO_CREATE_EXPIRY_RESOURCES, |
| AddressSettings.DEFAULT_EXPIRY_QUEUE_PREFIX.toString(), |
| AddressSettings.DEFAULT_EXPIRY_QUEUE_SUFFIX.toString(), |
| AddressSettings.DEFAULT_MIN_EXPIRY_DELAY, |
| AddressSettings.DEFAULT_MAX_EXPIRY_DELAY, |
| AddressSettings.DEFAULT_ENABLE_METRICS); |
| } |
| |
| @Override |
| @Deprecated |
| public void addAddressSettings(final String address, |
| final String DLA, |
| final String expiryAddress, |
| final long expiryDelay, |
| final boolean defaultLastValueQueue, |
| final int maxDeliveryAttempts, |
| final long maxSizeBytes, |
| final int pageSizeBytes, |
| final int pageMaxCacheSize, |
| final long redeliveryDelay, |
| final double redeliveryMultiplier, |
| final long maxRedeliveryDelay, |
| final long redistributionDelay, |
| final boolean sendToDLAOnNoRoute, |
| final String addressFullMessagePolicy, |
| final long slowConsumerThreshold, |
| final long slowConsumerCheckPeriod, |
| final String slowConsumerPolicy, |
| final boolean autoCreateJmsQueues, |
| final boolean autoDeleteJmsQueues, |
| final boolean autoCreateJmsTopics, |
| final boolean autoDeleteJmsTopics, |
| final boolean autoCreateQueues, |
| final boolean autoDeleteQueues, |
| final boolean autoCreateAddresses, |
| final boolean autoDeleteAddresses, |
| final String configDeleteQueues, |
| final String configDeleteAddresses, |
| final long maxSizeBytesRejectThreshold, |
| final String defaultLastValueKey, |
| final boolean defaultNonDestructive, |
| final boolean defaultExclusiveQueue, |
| final boolean defaultGroupRebalance, |
| final int defaultGroupBuckets, |
| final String defaultGroupFirstKey, |
| final int defaultMaxConsumers, |
| final boolean defaultPurgeOnNoConsumers, |
| final int defaultConsumersBeforeDispatch, |
| final long defaultDelayBeforeDispatch, |
| final String defaultQueueRoutingType, |
| final String defaultAddressRoutingType, |
| final int defaultConsumerWindowSize, |
| final long defaultRingSize, |
| final boolean autoDeleteCreatedQueues, |
| final long autoDeleteQueuesDelay, |
| final long autoDeleteQueuesMessageCount, |
| final long autoDeleteAddressesDelay, |
| final double redeliveryCollisionAvoidanceFactor, |
| final long retroactiveMessageCount, |
| final boolean autoCreateDeadLetterResources, |
| final String deadLetterQueuePrefix, |
| final String deadLetterQueueSuffix, |
| final boolean autoCreateExpiryResources, |
| final String expiryQueuePrefix, |
| final String expiryQueueSuffix, |
| final long minExpiryDelay, |
| final long maxExpiryDelay, |
| final boolean enableMetrics) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.addAddressSettings(this.server, address, DLA, expiryAddress, expiryDelay, defaultLastValueQueue, maxDeliveryAttempts, |
| maxSizeBytes, pageSizeBytes, pageMaxCacheSize, redeliveryDelay, redeliveryMultiplier, |
| maxRedeliveryDelay, redistributionDelay, sendToDLAOnNoRoute, addressFullMessagePolicy, |
| slowConsumerThreshold, slowConsumerCheckPeriod, slowConsumerPolicy, autoCreateJmsQueues, |
| autoDeleteJmsQueues, autoCreateJmsTopics, autoDeleteJmsTopics, autoCreateQueues, autoDeleteQueues, |
| autoCreateAddresses, autoDeleteAddresses, configDeleteQueues, configDeleteAddresses, maxSizeBytesRejectThreshold, |
| defaultLastValueKey, defaultNonDestructive, defaultExclusiveQueue, defaultGroupRebalance, defaultGroupBuckets, |
| defaultGroupFirstKey, defaultMaxConsumers, defaultPurgeOnNoConsumers, defaultConsumersBeforeDispatch, |
| defaultDelayBeforeDispatch, defaultQueueRoutingType, defaultAddressRoutingType, defaultConsumerWindowSize, |
| defaultRingSize, autoDeleteCreatedQueues, autoDeleteQueuesDelay, autoDeleteQueuesMessageCount, |
| autoDeleteAddressesDelay, redeliveryCollisionAvoidanceFactor, retroactiveMessageCount, autoCreateDeadLetterResources, |
| deadLetterQueuePrefix, deadLetterQueueSuffix, autoCreateExpiryResources, expiryQueuePrefix, |
| expiryQueueSuffix, minExpiryDelay, maxExpiryDelay, enableMetrics); |
| } |
| checkStarted(); |
| |
| // JBPAPP-6334 requested this to be pageSizeBytes > maxSizeBytes |
| if (pageSizeBytes > maxSizeBytes && maxSizeBytes > 0) { |
| throw new IllegalStateException("pageSize has to be lower than maxSizeBytes. Invalid argument (" + pageSizeBytes + " < " + maxSizeBytes + ")"); |
| } |
| |
| if (maxSizeBytes < -1) { |
| throw new IllegalStateException("Invalid argument on maxSizeBytes"); |
| } |
| |
| AddressSettings addressSettings = new AddressSettings(); |
| addressSettings.setDeadLetterAddress(DLA == null ? null : SimpleString.of(DLA)); |
| addressSettings.setExpiryAddress(expiryAddress == null ? null : SimpleString.of(expiryAddress)); |
| addressSettings.setExpiryDelay(expiryDelay); |
| addressSettings.setMinExpiryDelay(minExpiryDelay); |
| addressSettings.setMaxExpiryDelay(maxExpiryDelay); |
| addressSettings.setDefaultLastValueQueue(defaultLastValueQueue); |
| addressSettings.setMaxDeliveryAttempts(maxDeliveryAttempts); |
| addressSettings.setPageCacheMaxSize(pageMaxCacheSize); |
| addressSettings.setMaxSizeBytes(maxSizeBytes); |
| addressSettings.setPageSizeBytes(pageSizeBytes); |
| addressSettings.setRedeliveryDelay(redeliveryDelay); |
| addressSettings.setRedeliveryMultiplier(redeliveryMultiplier); |
| addressSettings.setMaxRedeliveryDelay(maxRedeliveryDelay); |
| addressSettings.setRedistributionDelay(redistributionDelay); |
| addressSettings.setSendToDLAOnNoRoute(sendToDLAOnNoRoute); |
| addressSettings.setAddressFullMessagePolicy(addressFullMessagePolicy == null || addressFullMessagePolicy.isEmpty() ? AddressSettings.DEFAULT_ADDRESS_FULL_MESSAGE_POLICY : AddressFullMessagePolicy.valueOf(addressFullMessagePolicy.toUpperCase())); |
| addressSettings.setSlowConsumerThreshold(slowConsumerThreshold); |
| addressSettings.setSlowConsumerCheckPeriod(slowConsumerCheckPeriod); |
| addressSettings.setSlowConsumerPolicy(slowConsumerPolicy == null || slowConsumerPolicy.isEmpty() ? AddressSettings.DEFAULT_SLOW_CONSUMER_POLICY : SlowConsumerPolicy.valueOf(slowConsumerPolicy.toUpperCase())); |
| addressSettings.setAutoCreateJmsQueues(autoCreateJmsQueues); |
| addressSettings.setAutoDeleteJmsQueues(autoDeleteJmsQueues); |
| addressSettings.setAutoCreateJmsTopics(autoCreateJmsTopics); |
| addressSettings.setAutoDeleteJmsTopics(autoDeleteJmsTopics); |
| addressSettings.setAutoCreateQueues(autoCreateQueues); |
| addressSettings.setAutoDeleteQueues(autoDeleteQueues); |
| addressSettings.setAutoCreateAddresses(autoCreateAddresses); |
| addressSettings.setAutoDeleteAddresses(autoDeleteAddresses); |
| addressSettings.setConfigDeleteQueues(configDeleteQueues == null || configDeleteQueues.isEmpty() ? AddressSettings.DEFAULT_CONFIG_DELETE_QUEUES : DeletionPolicy.valueOf(configDeleteQueues.toUpperCase())); |
| addressSettings.setConfigDeleteAddresses(configDeleteAddresses == null || configDeleteAddresses.isEmpty() ? AddressSettings.DEFAULT_CONFIG_DELETE_ADDRESSES : DeletionPolicy.valueOf(configDeleteAddresses.toUpperCase())); |
| addressSettings.setMaxSizeBytesRejectThreshold(maxSizeBytesRejectThreshold); |
| addressSettings.setDefaultLastValueKey(defaultLastValueKey == null || defaultLastValueKey.isEmpty() ? ActiveMQDefaultConfiguration.getDefaultLastValueKey() : SimpleString.of(defaultLastValueKey)); |
| addressSettings.setDefaultNonDestructive(defaultNonDestructive); |
| addressSettings.setDefaultExclusiveQueue(defaultExclusiveQueue); |
| addressSettings.setDefaultGroupRebalance(defaultGroupRebalance); |
| addressSettings.setDefaultGroupBuckets(defaultGroupBuckets); |
| addressSettings.setDefaultGroupFirstKey(defaultGroupFirstKey == null || defaultGroupFirstKey.isEmpty() ? ActiveMQDefaultConfiguration.getDefaultGroupFirstKey() : SimpleString.of(defaultGroupFirstKey)); |
| addressSettings.setDefaultMaxConsumers(defaultMaxConsumers); |
| addressSettings.setDefaultPurgeOnNoConsumers(defaultPurgeOnNoConsumers); |
| addressSettings.setDefaultConsumersBeforeDispatch(defaultConsumersBeforeDispatch); |
| addressSettings.setDefaultDelayBeforeDispatch(defaultDelayBeforeDispatch); |
| addressSettings.setDefaultQueueRoutingType(defaultQueueRoutingType == null || defaultQueueRoutingType.isEmpty() ? ActiveMQDefaultConfiguration.getDefaultRoutingType() : RoutingType.valueOf(defaultQueueRoutingType.toUpperCase())); |
| addressSettings.setDefaultAddressRoutingType(defaultAddressRoutingType == null || defaultAddressRoutingType.isEmpty() ? ActiveMQDefaultConfiguration.getDefaultRoutingType() : RoutingType.valueOf(defaultAddressRoutingType.toUpperCase())); |
| addressSettings.setDefaultConsumerWindowSize(defaultConsumerWindowSize); |
| addressSettings.setDefaultRingSize(defaultRingSize); |
| addressSettings.setAutoDeleteCreatedQueues(autoDeleteCreatedQueues); |
| addressSettings.setAutoDeleteQueuesDelay(autoDeleteQueuesDelay); |
| addressSettings.setAutoDeleteQueuesMessageCount(autoDeleteQueuesMessageCount); |
| addressSettings.setAutoDeleteAddressesDelay(autoDeleteAddressesDelay); |
| addressSettings.setRedeliveryCollisionAvoidanceFactor(redeliveryCollisionAvoidanceFactor); |
| addressSettings.setRetroactiveMessageCount(retroactiveMessageCount); |
| addressSettings.setAutoCreateDeadLetterResources(autoCreateDeadLetterResources); |
| addressSettings.setDeadLetterQueuePrefix(deadLetterQueuePrefix == null || deadLetterQueuePrefix.isEmpty() ? null : SimpleString.of(deadLetterQueuePrefix)); |
| addressSettings.setDeadLetterQueueSuffix(deadLetterQueueSuffix == null || deadLetterQueueSuffix.isEmpty() ? null : SimpleString.of(deadLetterQueueSuffix)); |
| addressSettings.setAutoCreateExpiryResources(autoCreateExpiryResources); |
| addressSettings.setExpiryQueuePrefix(expiryQueuePrefix == null || expiryQueuePrefix.isEmpty() ? null : SimpleString.of(expiryQueuePrefix)); |
| addressSettings.setExpiryQueueSuffix(expiryQueueSuffix == null || expiryQueueSuffix.isEmpty() ? null : SimpleString.of(expiryQueueSuffix)); |
| addressSettings.setEnableMetrics(enableMetrics); |
| |
| server.getAddressSettingsRepository().addMatch(address, addressSettings); |
| |
| storageManager.storeAddressSetting(new PersistedAddressSettingJSON(SimpleString.of(address), addressSettings, addressSettings.toJSON())); |
| |
| } |
| |
| @Override |
| public String addAddressSettings(String address, String addressSettingsConfigurationAsJson) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.addAddressSettings(this.server, addressSettingsConfigurationAsJson); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| AddressSettings addressSettingsConfiguration = AddressSettings.fromJSON(addressSettingsConfigurationAsJson); |
| |
| if (addressSettingsConfiguration == null) { |
| throw ActiveMQMessageBundle.BUNDLE.failedToParseJson(addressSettingsConfigurationAsJson); |
| } |
| // JBPAPP-6334 requested this to be pageSizeBytes > maxSizeBytes |
| if (addressSettingsConfiguration.getPageSizeBytes() > addressSettingsConfiguration.getMaxSizeBytes() && addressSettingsConfiguration.getMaxSizeBytes() > 0) { |
| throw new IllegalStateException("pageSize has to be lower than maxSizeBytes. Invalid argument (" + addressSettingsConfiguration.getPageSizeBytes() + " < " + addressSettingsConfiguration.getMaxSizeBytes() + ")"); |
| } |
| |
| if (addressSettingsConfiguration.getMaxSizeBytes() < -1) { |
| throw new IllegalStateException("Invalid argument on maxSizeBytes"); |
| } |
| server.getAddressSettingsRepository().addMatch(address, addressSettingsConfiguration); |
| |
| storageManager.storeAddressSetting(new PersistedAddressSettingJSON(SimpleString.of(address), addressSettingsConfiguration, SimpleString.of(addressSettingsConfigurationAsJson))); |
| return addressSettingsConfiguration.toJSON(); |
| } catch (ActiveMQException e) { |
| throw new IllegalStateException(e.getMessage()); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void removeAddressSettings(final String addressMatch) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.removeAddressSettings(this.server, addressMatch); |
| } |
| checkStarted(); |
| |
| server.getAddressSettingsRepository().removeMatch(addressMatch); |
| storageManager.deleteAddressSetting(SimpleString.of(addressMatch)); |
| } |
| |
| public void sendQueueInfoToQueue(final String queueName, final String address) throws Exception { |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| postOffice.sendQueueInfoToQueue(SimpleString.of(queueName), SimpleString.of(address == null ? "" : address)); |
| |
| GroupingHandler handler = server.getGroupingHandler(); |
| if (handler != null) { |
| // the group handler would miss responses if the group was requested before the reset was done |
| // on that case we ask the groupinghandler to replay its send in case it's waiting for the information |
| handler.resendPending(); |
| } |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String[] getDivertNames() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getDivertNames(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Object[] diverts = server.getManagementService().getResources(DivertControl.class); |
| String[] names = new String[diverts.length]; |
| for (int i = 0; i < diverts.length; i++) { |
| DivertControl divert = (DivertControl) diverts[i]; |
| names[i] = divert.getUniqueName(); |
| } |
| |
| return names; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void createDivert(final String name, |
| final String routingName, |
| final String address, |
| final String forwardingAddress, |
| final boolean exclusive, |
| final String filterString, |
| final String transformerClassName) throws Exception { |
| createDivert(name, routingName, address, forwardingAddress, exclusive, filterString, transformerClassName, ActiveMQDefaultConfiguration.getDefaultDivertRoutingType()); |
| } |
| |
| @Override |
| public void createDivert(final String name, |
| final String routingName, |
| final String address, |
| final String forwardingAddress, |
| final boolean exclusive, |
| final String filterString, |
| final String transformerClassName, |
| final String routingType) throws Exception { |
| createDivert(name, routingName, address, forwardingAddress, exclusive, filterString, transformerClassName, (String) null, routingType); |
| } |
| |
| @Override |
| public void createDivert(final String name, |
| final String routingName, |
| final String address, |
| final String forwardingAddress, |
| final boolean exclusive, |
| final String filterString, |
| final String transformerClassName, |
| final String transformerPropertiesAsJSON, |
| final String routingType) throws Exception { |
| createDivert(name, routingName, address, forwardingAddress, exclusive, filterString, transformerClassName, JsonUtil.readJsonProperties(transformerPropertiesAsJSON), routingType); |
| } |
| |
| @Override |
| public void createDivert(final String name, |
| final String routingName, |
| final String address, |
| final String forwardingAddress, |
| final boolean exclusive, |
| final String filterString, |
| final String transformerClassName, |
| final Map<String, String> transformerProperties, |
| final String routingType) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.createDivert(this.server, name, routingName, address, forwardingAddress, |
| exclusive, filterString, transformerClassName, transformerProperties, routingType); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| TransformerConfiguration transformerConfiguration = transformerClassName == null || transformerClassName.isEmpty() ? null : new TransformerConfiguration(transformerClassName).setProperties(transformerProperties); |
| DivertConfiguration config = new DivertConfiguration().setName(name).setRoutingName(routingName).setAddress(address).setForwardingAddress(forwardingAddress).setExclusive(exclusive).setFilterString(filterString).setTransformerConfiguration(transformerConfiguration).setRoutingType(ComponentConfigurationRoutingType.valueOf(routingType)); |
| server.deployDivert(config); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void updateDivert(final String name, |
| final String forwardingAddress, |
| final String filterString, |
| final String transformerClassName, |
| final Map<String, String> transformerProperties, |
| final String routingType) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.updateDivert(this.server, name, forwardingAddress, filterString, |
| transformerClassName, transformerProperties, routingType); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| TransformerConfiguration transformerConfiguration = transformerClassName == null || transformerClassName.isEmpty() ? null : |
| new TransformerConfiguration(transformerClassName).setProperties(transformerProperties); |
| |
| DivertConfiguration config = new DivertConfiguration().setName(name).setForwardingAddress(forwardingAddress). |
| setFilterString(filterString).setTransformerConfiguration(transformerConfiguration). |
| setRoutingType(ComponentConfigurationRoutingType.valueOf(routingType)); |
| |
| final Divert divert = server.updateDivert(config); |
| if (divert == null) { |
| throw ActiveMQMessageBundle.BUNDLE.divertDoesNotExist(config.getName()); |
| } |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void destroyDivert(final String name) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.destroyDivert(this.server, name); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| server.destroyDivert(SimpleString.of(name), true); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String[] getBridgeNames() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getBridgeNames(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| Object[] bridges = server.getManagementService().getResources(BridgeControl.class); |
| String[] names = new String[bridges.length]; |
| for (int i = 0; i < bridges.length; i++) { |
| BridgeControl bridge = (BridgeControl) bridges[i]; |
| names[i] = bridge.getName(); |
| } |
| |
| return names; |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void createBridge(final String name, |
| final String queueName, |
| final String forwardingAddress, |
| final String filterString, |
| final String transformerClassName, |
| final long retryInterval, |
| final double retryIntervalMultiplier, |
| final int initialConnectAttempts, |
| final int reconnectAttempts, |
| final boolean useDuplicateDetection, |
| final int confirmationWindowSize, |
| final int producerWindowSize, |
| final long clientFailureCheckPeriod, |
| final String staticConnectorsOrDiscoveryGroup, |
| boolean useDiscoveryGroup, |
| final boolean ha, |
| final String user, |
| final String password) throws Exception { |
| createBridge(name, |
| queueName, |
| forwardingAddress, |
| filterString, |
| transformerClassName, |
| (String) null, |
| retryInterval, |
| retryIntervalMultiplier, |
| initialConnectAttempts, |
| reconnectAttempts, |
| useDuplicateDetection, |
| confirmationWindowSize, |
| producerWindowSize, |
| clientFailureCheckPeriod, |
| staticConnectorsOrDiscoveryGroup, |
| useDiscoveryGroup, |
| ha, |
| user, |
| password); |
| } |
| |
| @Override |
| public void createBridge(final String name, |
| final String queueName, |
| final String forwardingAddress, |
| final String filterString, |
| final String transformerClassName, |
| final String transformerPropertiesAsJSON, |
| final long retryInterval, |
| final double retryIntervalMultiplier, |
| final int initialConnectAttempts, |
| final int reconnectAttempts, |
| final boolean useDuplicateDetection, |
| final int confirmationWindowSize, |
| final int producerWindowSize, |
| final long clientFailureCheckPeriod, |
| final String staticConnectorsOrDiscoveryGroup, |
| boolean useDiscoveryGroup, |
| final boolean ha, |
| final String user, |
| final String password) throws Exception { |
| createBridge(name, |
| queueName, |
| forwardingAddress, |
| filterString, |
| transformerClassName, |
| JsonUtil.readJsonProperties(transformerPropertiesAsJSON), |
| retryInterval, |
| retryIntervalMultiplier, |
| initialConnectAttempts, |
| reconnectAttempts, |
| useDuplicateDetection, |
| confirmationWindowSize, |
| producerWindowSize, |
| clientFailureCheckPeriod, |
| staticConnectorsOrDiscoveryGroup, |
| useDiscoveryGroup, |
| ha, |
| user, |
| password); |
| } |
| |
| @Override |
| public void createBridge(final String name, |
| final String queueName, |
| final String forwardingAddress, |
| final String filterString, |
| final String transformerClassName, |
| final Map<String, String> transformerProperties, |
| final long retryInterval, |
| final double retryIntervalMultiplier, |
| final int initialConnectAttempts, |
| final int reconnectAttempts, |
| final boolean useDuplicateDetection, |
| final int confirmationWindowSize, |
| final int producerWindowSize, |
| final long clientFailureCheckPeriod, |
| final String staticConnectorsOrDiscoveryGroup, |
| boolean useDiscoveryGroup, |
| final boolean ha, |
| final String user, |
| final String password) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.createBridge(this.server, name, queueName, forwardingAddress, filterString, |
| transformerClassName, transformerProperties, retryInterval, retryIntervalMultiplier, |
| initialConnectAttempts, reconnectAttempts, useDuplicateDetection, confirmationWindowSize, |
| producerWindowSize, clientFailureCheckPeriod, staticConnectorsOrDiscoveryGroup, |
| useDiscoveryGroup, ha, user, "****"); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| TransformerConfiguration transformerConfiguration = transformerClassName == null || transformerClassName.isEmpty() ? null : new TransformerConfiguration(transformerClassName).setProperties(transformerProperties); |
| BridgeConfiguration config = new BridgeConfiguration().setName(name).setQueueName(queueName).setForwardingAddress(forwardingAddress).setFilterString(filterString).setTransformerConfiguration(transformerConfiguration).setClientFailureCheckPeriod(clientFailureCheckPeriod).setRetryInterval(retryInterval).setRetryIntervalMultiplier(retryIntervalMultiplier).setInitialConnectAttempts(initialConnectAttempts).setReconnectAttempts(reconnectAttempts).setUseDuplicateDetection(useDuplicateDetection).setConfirmationWindowSize(confirmationWindowSize).setProducerWindowSize(producerWindowSize).setHA(ha).setUser(user).setPassword(password).setConfigurationManaged(false); |
| |
| if (useDiscoveryGroup) { |
| config.setDiscoveryGroupName(staticConnectorsOrDiscoveryGroup); |
| } else { |
| config.setStaticConnectors(ListUtil.toList(staticConnectorsOrDiscoveryGroup)); |
| } |
| |
| server.deployBridge(config); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void createBridge(final String name, |
| final String queueName, |
| final String forwardingAddress, |
| final String filterString, |
| final String transformerClassName, |
| final long retryInterval, |
| final double retryIntervalMultiplier, |
| final int initialConnectAttempts, |
| final int reconnectAttempts, |
| final boolean useDuplicateDetection, |
| final int confirmationWindowSize, |
| final long clientFailureCheckPeriod, |
| final String staticConnectorsOrDiscoveryGroup, |
| boolean useDiscoveryGroup, |
| final boolean ha, |
| final String user, |
| final String password) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.createBridge(this.server, name, queueName, forwardingAddress, filterString, |
| transformerClassName, retryInterval, retryIntervalMultiplier, initialConnectAttempts, |
| reconnectAttempts, useDuplicateDetection, confirmationWindowSize, clientFailureCheckPeriod, |
| staticConnectorsOrDiscoveryGroup, useDiscoveryGroup, ha, user, "****"); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| TransformerConfiguration transformerConfiguration = transformerClassName == null || transformerClassName.isEmpty() ? null : new TransformerConfiguration(transformerClassName); |
| BridgeConfiguration config = new BridgeConfiguration().setName(name).setQueueName(queueName).setForwardingAddress(forwardingAddress).setFilterString(filterString).setTransformerConfiguration(transformerConfiguration).setClientFailureCheckPeriod(clientFailureCheckPeriod).setRetryInterval(retryInterval).setRetryIntervalMultiplier(retryIntervalMultiplier).setInitialConnectAttempts(initialConnectAttempts).setReconnectAttempts(reconnectAttempts).setUseDuplicateDetection(useDuplicateDetection).setConfirmationWindowSize(confirmationWindowSize).setHA(ha).setUser(user).setPassword(password).setConfigurationManaged(false); |
| |
| if (useDiscoveryGroup) { |
| config.setDiscoveryGroupName(staticConnectorsOrDiscoveryGroup); |
| } else { |
| config.setStaticConnectors(ListUtil.toList(staticConnectorsOrDiscoveryGroup)); |
| } |
| |
| server.deployBridge(config); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void createBridge(String bridgeConfigurationAsJson) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.createBridge(this.server, bridgeConfigurationAsJson); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| // when the BridgeConfiguration is passed through createBridge all of its defaults get set which we return to the caller |
| BridgeConfiguration bridgeConfiguration = BridgeConfiguration.fromJSON(bridgeConfigurationAsJson); |
| if (bridgeConfiguration == null) { |
| throw ActiveMQMessageBundle.BUNDLE.failedToParseJson(bridgeConfigurationAsJson); |
| } |
| bridgeConfiguration.setConfigurationManaged(false); |
| server.deployBridge(bridgeConfiguration); |
| } catch (ActiveMQException e) { |
| throw new IllegalStateException(e.getMessage()); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void addConnector(String name, String url) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.addConnector(this.server, name, url); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| server.getConfiguration().addConnectorConfiguration(name, url); |
| storageManager.storeConnector(new PersistedConnector(name, url)); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void removeConnector(String name) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.removeConnector(this.server, name); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| server.getConfiguration().getConnectorConfigurations().remove(name); |
| storageManager.deleteConnector(name); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String listBrokerConnections() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listBrokerConnections(); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| |
| JsonArrayBuilder connections = JsonLoader.createArrayBuilder(); |
| for (BrokerConnection brokerConnection : server.getBrokerConnections()) { |
| JsonObjectBuilder obj = JsonLoader.createObjectBuilder(); |
| obj.add("name", brokerConnection.getName()); |
| obj.add("protocol", brokerConnection.getProtocol()); |
| obj.add("started", brokerConnection.isStarted()); |
| connections.add(obj.build()); |
| } |
| return connections.build().toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void startBrokerConnection(String name) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.startBrokerConnection(name); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| server.startBrokerConnection(name); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void stopBrokerConnection(String name) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.stopBrokerConnection(name); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| server.stopBrokerConnection(name); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void destroyBridge(final String name) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.destroyBridge(this.server, name); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| server.destroyBridge(name); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void createConnectorService(final String name, final String factoryClass, final Map<String, Object> parameters) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.createConnectorService(this.server, name, factoryClass, parameters); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| final ConnectorServiceConfiguration config = new ConnectorServiceConfiguration().setName(name).setFactoryClassName(factoryClass).setParams(parameters); |
| ConnectorServiceFactory factory = server.getServiceRegistry().getConnectorService(config); |
| server.getConnectorsService().createService(config, factory); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void destroyConnectorService(final String name) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.destroyConnectorService(this.server, name); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| server.getConnectorsService().destroyService(name); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public String[] getConnectorServices() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getConnectorServices(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| try { |
| return server.getConnectorsService().getConnectors().keySet().toArray(new String[0]); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void forceFailover() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.forceFailover(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| |
| Thread t = new Thread(() -> { |
| try { |
| server.stop(true, true); |
| } catch (Throwable e) { |
| logger.warn(e.getMessage(), e); |
| } |
| }); |
| t.start(); |
| } |
| |
| public void updateDuplicateIdCache(String address, Object[] ids) throws Exception { |
| clearIO(); |
| try { |
| DuplicateIDCache duplicateIDCache = server.getPostOffice().getDuplicateIDCache(SimpleString.of(address)); |
| for (Object id : ids) { |
| duplicateIDCache.addToCache(((String) id).getBytes(), null); |
| } |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void scaleDown(String connector) throws Exception { |
| try (AutoCloseable lock = server.managementLock()) { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.scaleDown(this.server, connector); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| HAPolicy haPolicy = server.getHAPolicy(); |
| if (haPolicy instanceof PrimaryOnlyPolicy) { |
| PrimaryOnlyPolicy primaryOnlyPolicy = (PrimaryOnlyPolicy) haPolicy; |
| |
| if (primaryOnlyPolicy.getScaleDownPolicy() == null) { |
| primaryOnlyPolicy.setScaleDownPolicy(new ScaleDownPolicy()); |
| } |
| |
| primaryOnlyPolicy.getScaleDownPolicy().setEnabled(true); |
| |
| if (connector != null) { |
| primaryOnlyPolicy.getScaleDownPolicy().getConnectors().add(0, connector); |
| } |
| |
| server.fail(true); |
| } |
| } |
| } |
| |
| |
| @Override |
| public String listNetworkTopology() throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listNetworkTopology(this.server); |
| } |
| checkStarted(); |
| |
| clearIO(); |
| try { |
| JsonArrayBuilder brokers = JsonLoader.createArrayBuilder(); |
| ClusterManager clusterManager = server.getClusterManager(); |
| if (clusterManager != null) { |
| Set<ClusterConnection> clusterConnections = clusterManager.getClusterConnections(); |
| for (ClusterConnection clusterConnection : clusterConnections) { |
| Topology topology = clusterConnection.getTopology(); |
| Collection<TopologyMemberImpl> members = topology.getMembers(); |
| for (TopologyMemberImpl member : members) { |
| |
| TransportConfiguration primary = member.getPrimary(); |
| if (primary != null) { |
| JsonObjectBuilder obj = JsonLoader.createObjectBuilder(); |
| // keep "live" here for backwards compatibility |
| obj.add("nodeID", member.getNodeId()).add("live", primary.getParams().get("host") + ":" + primary.getParams().get("port")); |
| obj.add("nodeID", member.getNodeId()).add("primary", primary.getParams().get("host") + ":" + primary.getParams().get("port")); |
| TransportConfiguration backup = member.getBackup(); |
| if (backup != null) { |
| obj.add("backup", backup.getParams().get("host") + ":" + backup.getParams().get("port")); |
| } |
| brokers.add(obj); |
| } |
| } |
| } |
| } |
| return brokers.build().toString(); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| |
| // NotificationEmitter implementation ---------------------------- |
| |
| @Override |
| public void removeNotificationListener(final NotificationListener listener, |
| final NotificationFilter filter, |
| final Object handback) throws ListenerNotFoundException { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.removeNotificationListener(this.server, listener, filter, handback); |
| } |
| clearIO(); |
| try { |
| broadcaster.removeNotificationListener(listener, filter, handback); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void removeNotificationListener(final NotificationListener listener) throws ListenerNotFoundException { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.removeNotificationListener(this.server, listener); |
| } |
| clearIO(); |
| try { |
| broadcaster.removeNotificationListener(listener); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public void addNotificationListener(final NotificationListener listener, |
| final NotificationFilter filter, |
| final Object handback) throws IllegalArgumentException { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.addNotificationListener(this.server, listener, filter, handback); |
| } |
| clearIO(); |
| try { |
| broadcaster.addNotificationListener(listener, filter, handback); |
| } finally { |
| blockOnIO(); |
| } |
| } |
| |
| @Override |
| public MBeanNotificationInfo[] getNotificationInfo() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getNotificationInfo(this.server); |
| } |
| CoreNotificationType[] values = CoreNotificationType.values(); |
| String[] names = new String[values.length]; |
| for (int i = 0; i < values.length; i++) { |
| names[i] = values[i].toString(); |
| } |
| return new MBeanNotificationInfo[]{new MBeanNotificationInfo(names, this.getClass().getName(), "Notifications emitted by a Core Server")}; |
| } |
| |
| |
| |
| |
| private synchronized void setMessageCounterEnabled(final boolean enable) { |
| if (isStarted()) { |
| if (configuration.isMessageCounterEnabled() && !enable) { |
| stopMessageCounters(); |
| } else if (!configuration.isMessageCounterEnabled() && enable) { |
| startMessageCounters(); |
| } |
| } |
| configuration.setMessageCounterEnabled(enable); |
| } |
| |
| private void startMessageCounters() { |
| messageCounterManager.start(); |
| } |
| |
| private void stopMessageCounters() { |
| messageCounterManager.stop(); |
| |
| messageCounterManager.resetAllCounters(); |
| |
| messageCounterManager.resetAllCounterHistories(); |
| } |
| |
| @Override |
| public long getConnectionTTLOverride() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getConnectionTTLOverride(this.server); |
| } |
| return configuration.getConnectionTTLOverride(); |
| } |
| |
| @Override |
| public int getIDCacheSize() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getIDCacheSize(this.server); |
| } |
| return configuration.getIDCacheSize(); |
| } |
| |
| @Override |
| public String getLargeMessagesDirectory() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getLargeMessagesDirectory(this.server); |
| } |
| return configuration.getLargeMessagesDirectory(); |
| } |
| |
| @Override |
| public String getManagementAddress() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getManagementAddress(this.server); |
| } |
| return configuration.getManagementAddress().toString(); |
| } |
| |
| @Override |
| public String getNodeID() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getNodeID(this.server); |
| } |
| return server.getNodeID() == null ? null : server.getNodeID().toString(); |
| } |
| |
| @Override |
| public long getActivationSequence() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getActivationSequence(this.server); |
| } |
| if (server.getNodeManager() != null) { |
| return server.getNodeManager().getNodeActivationSequence(); |
| } |
| return 0; |
| } |
| |
| @Override |
| public String getManagementNotificationAddress() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getManagementNotificationAddress(this.server); |
| } |
| return configuration.getManagementNotificationAddress().toString(); |
| } |
| |
| @Override |
| public long getMessageExpiryScanPeriod() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getMessageExpiryScanPeriod(this.server); |
| } |
| return configuration.getMessageExpiryScanPeriod(); |
| } |
| |
| @Override |
| @Deprecated |
| public long getMessageExpiryThreadPriority() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getMessageExpiryThreadPriority(this.server); |
| } |
| return configuration.getMessageExpiryThreadPriority(); |
| } |
| |
| @Override |
| public long getTransactionTimeout() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getTransactionTimeout(this.server); |
| } |
| return configuration.getTransactionTimeout(); |
| } |
| |
| @Override |
| public long getTransactionTimeoutScanPeriod() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getTransactionTimeoutScanPeriod(this.server); |
| } |
| return configuration.getTransactionTimeoutScanPeriod(); |
| } |
| |
| @Override |
| public boolean isPersistDeliveryCountBeforeDelivery() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.isPersistDeliveryCountBeforeDelivery(this.server); |
| } |
| return configuration.isPersistDeliveryCountBeforeDelivery(); |
| } |
| |
| @Override |
| public boolean isPersistIDCache() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.isPersistIDCache(this.server); |
| } |
| return configuration.isPersistIDCache(); |
| } |
| |
| @Override |
| public boolean isWildcardRoutingEnabled() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.isWildcardRoutingEnabled(this.server); |
| } |
| return configuration.isWildcardRoutingEnabled(); |
| } |
| |
| @Override |
| protected MBeanOperationInfo[] fillMBeanOperationInfo() { |
| return MBeanInfoHelper.getMBeanOperationsInfo(ActiveMQServerControl.class); |
| } |
| |
| @Override |
| protected MBeanAttributeInfo[] fillMBeanAttributeInfo() { |
| return MBeanInfoHelper.getMBeanAttributesInfo(ActiveMQServerControl.class); |
| } |
| |
| private void checkStarted() { |
| if (!server.isStarted()) { |
| throw new IllegalStateException("Broker is not started. It can not be managed yet"); |
| } |
| } |
| |
| @Override |
| public void onNotification(org.apache.activemq.artemis.core.server.management.Notification notification) { |
| if (!(notification.getType() instanceof CoreNotificationType)) |
| return; |
| CoreNotificationType type = (CoreNotificationType) notification.getType(); |
| if (type == CoreNotificationType.SESSION_CREATED) { |
| TypedProperties props = notification.getProperties(); |
| /* |
| * If the SESSION_CREATED notification is received from another node in the cluster, no broadcast call is made. |
| * To keep the original logic to avoid calling the broadcast multiple times for the same SESSION_CREATED notification in the cluster. |
| */ |
| if (props.getIntProperty(ManagementHelper.HDR_DISTANCE) > 0) { |
| return; |
| } |
| } |
| |
| this.broadcaster.sendNotification(new Notification(type.toString(), this, notifSeq.incrementAndGet(), notification.toString())); |
| } |
| |
| @Override |
| public void addUser(String username, String password, String roles, boolean plaintext) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.addUser(this.server, username, "****", roles, plaintext); |
| } |
| |
| String passwordToUse = plaintext ? password : PasswordMaskingUtil.getHashProcessor().hash(password); |
| |
| if (server.getSecurityManager() instanceof ActiveMQBasicSecurityManager) { |
| ((ActiveMQBasicSecurityManager) server.getSecurityManager()).addNewUser(username, passwordToUse, roles.split(",")); |
| } else { |
| synchronized (userLock) { |
| tcclInvoke(ActiveMQServerControlImpl.class.getClassLoader(), () -> { |
| PropertiesLoginModuleConfigurator config = getPropertiesLoginModuleConfigurator(); |
| config.addNewUser(username, passwordToUse, roles.split(",")); |
| config.save(); |
| }); |
| } |
| } |
| } |
| |
| private String getSecurityDomain() { |
| return server.getSecurityManager().getDomain(); |
| } |
| |
| @Override |
| public String listUser(String username) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.listUser(this.server, username); |
| } |
| if (server.getSecurityManager() instanceof ActiveMQBasicSecurityManager) { |
| return buildJsonUserList(((ActiveMQBasicSecurityManager) server.getSecurityManager()).listUser(username)); |
| } else { |
| synchronized (userLock) { |
| return (String) tcclCall(ActiveMQServerControlImpl.class.getClassLoader(), () -> { |
| return buildJsonUserList(getPropertiesLoginModuleConfigurator().listUser(username)); |
| }); |
| } |
| } |
| } |
| |
| private String buildJsonUserList(Map<String, Set<String>> info) { |
| JsonArrayBuilder users = JsonLoader.createArrayBuilder(); |
| for (Entry<String, Set<String>> entry : info.entrySet()) { |
| JsonObjectBuilder user = JsonLoader.createObjectBuilder(); |
| user.add("username", entry.getKey()); |
| JsonArrayBuilder roles = JsonLoader.createArrayBuilder(); |
| for (String role : entry.getValue()) { |
| roles.add(role); |
| } |
| user.add("roles", roles); |
| users.add(user); |
| } |
| return users.build().toString(); |
| } |
| |
| @Override |
| public void removeUser(String username) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.removeUser(this.server, username); |
| } |
| if (server.getSecurityManager() instanceof ActiveMQBasicSecurityManager) { |
| ((ActiveMQBasicSecurityManager) server.getSecurityManager()).removeUser(username); |
| } else { |
| synchronized (userLock) { |
| tcclInvoke(ActiveMQServerControlImpl.class.getClassLoader(), () -> { |
| PropertiesLoginModuleConfigurator config = getPropertiesLoginModuleConfigurator(); |
| config.removeUser(username); |
| config.save(); |
| }); |
| } |
| } |
| } |
| |
| @Override |
| public String getStatus() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getStatus(this.server); |
| } |
| checkStarted(); |
| |
| return server.getStatus(); |
| } |
| |
| @Override |
| public void resetUser(String username, String password, String roles, boolean plaintext) throws Exception { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.resetUser(this.server, username, "****", roles, plaintext); |
| } |
| |
| String passwordToUse = password == null || password.isEmpty() ? password : plaintext ? password : PasswordMaskingUtil.getHashProcessor().hash(password); |
| |
| if (server.getSecurityManager() instanceof ActiveMQBasicSecurityManager) { |
| ((ActiveMQBasicSecurityManager) server.getSecurityManager()).updateUser(username, passwordToUse, roles == null ? null : roles.split(",")); |
| } else { |
| synchronized (userLock) { |
| tcclInvoke(ActiveMQServerControlImpl.class.getClassLoader(), () -> { |
| PropertiesLoginModuleConfigurator config = getPropertiesLoginModuleConfigurator(); |
| // don't hash a null password even if plaintext = false |
| config.updateUser(username, passwordToUse, roles == null ? null : roles.split(",")); |
| config.save(); |
| }); |
| } |
| } |
| } |
| |
| @Override |
| public void resetUser(String username, String password, String roles) throws Exception { |
| // no need to synchronize here because the method we call is synchronized |
| resetUser(username, password, roles, true); |
| } |
| |
| private PropertiesLoginModuleConfigurator getPropertiesLoginModuleConfigurator() throws Exception { |
| URL configurationUrl = server.getConfiguration().getConfigurationUrl(); |
| if (configurationUrl == null) { |
| throw ActiveMQMessageBundle.BUNDLE.failedToLocateConfigURL(); |
| } |
| String path = Path.of(configurationUrl.toURI()).toString(); |
| return new PropertiesLoginModuleConfigurator(getSecurityDomain(), path.substring(0, path.lastIndexOf(File.separator))); |
| } |
| |
| @Override |
| public void reloadConfigurationFile() throws Exception { |
| server.reloadConfigurationFile(); |
| } |
| |
| @Override |
| public void replay(String address, String target, String filter) throws Exception { |
| server.replay(null, null, address, target, filter); |
| } |
| |
| @Override |
| public void replay(String startScan, String endScan, String address, String target, String filter) throws Exception { |
| |
| SimpleDateFormat format = ReplayManager.newRetentionSimpleDateFormat(); |
| |
| Date startScanDate = format.parse(startScan); |
| Date endScanDate = format.parse(endScan); |
| |
| server.replay(startScanDate, endScanDate, address, target, filter); |
| } |
| |
| @Override |
| public void stopEmbeddedWebServer() throws Exception { |
| synchronized (embeddedWebServerLock) { |
| getEmbeddedWebServerComponent().stop(true); |
| } |
| } |
| |
| @Override |
| public void startEmbeddedWebServer() throws Exception { |
| synchronized (embeddedWebServerLock) { |
| getEmbeddedWebServerComponent().start(); |
| } |
| } |
| |
| @Override |
| public void restartEmbeddedWebServer() throws Exception { |
| restartEmbeddedWebServer(ActiveMQDefaultConfiguration.getDefaultEmbeddedWebServerRestartTimeout()); |
| } |
| |
| @Override |
| public void restartEmbeddedWebServer(long timeout) throws Exception { |
| final CountDownLatch latch = new CountDownLatch(1); |
| final AtomicReference<Exception> exception = new AtomicReference<>(); |
| /* |
| * This needs to be run in its own thread managed by the broker because if it is run on a thread managed by Jetty |
| * (e.g. if it is invoked from the web console) then the thread will die before Jetty can be restarted. |
| */ |
| server.getThreadPool().execute(() -> { |
| try { |
| synchronized (embeddedWebServerLock) { |
| stopEmbeddedWebServer(); |
| startEmbeddedWebServer(); |
| } |
| } catch (Exception e) { |
| exception.set(e); |
| } finally { |
| latch.countDown(); |
| } |
| }); |
| if (!latch.await(timeout, TimeUnit.MILLISECONDS)) { |
| throw ActiveMQMessageBundle.BUNDLE.embeddedWebServerRestartTimeout(timeout); |
| } |
| if (exception.get() != null) { |
| throw ActiveMQMessageBundle.BUNDLE.embeddedWebServerRestartFailed(exception.get()); |
| } |
| } |
| |
| @Override |
| public boolean isEmbeddedWebServerStarted() { |
| try { |
| return getEmbeddedWebServerComponent().isStarted(); |
| } catch (Exception e) { |
| logger.trace(e.getMessage()); |
| return false; |
| } |
| } |
| |
| @Override |
| public void rebuildPageCounters() throws Exception { |
| // managementLock will guarantee there's only one management operation being called |
| try (AutoCloseable lock = server.managementLock()) { |
| Future<Object> task = server.getPagingManager().rebuildCounters(null); |
| task.get(); |
| } |
| } |
| |
| private ServiceComponent getEmbeddedWebServerComponent() throws ActiveMQIllegalStateException { |
| for (ActiveMQComponent component : server.getExternalComponents()) { |
| if (component instanceof WebServerComponentMarker) { |
| return (ServiceComponent) component; |
| } |
| } |
| throw ActiveMQMessageBundle.BUNDLE.embeddedWebServerNotFound(); |
| } |
| |
| @Override |
| public void clearAuthenticationCache() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.clearAuthenticationCache(this.server); |
| } |
| ((SecurityStoreImpl)server.getSecurityStore()).invalidateAuthenticationCache(); |
| } |
| |
| @Override |
| public void clearAuthorizationCache() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.clearAuthorizationCache(this.server); |
| } |
| ((SecurityStoreImpl)server.getSecurityStore()).invalidateAuthorizationCache(); |
| } |
| |
| @Override |
| public long getAuthenticationSuccessCount() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getAuthenticationSuccessCount(this.server); |
| } |
| return server.getSecurityStore().getAuthenticationSuccessCount(); |
| } |
| |
| @Override |
| public long getAuthenticationFailureCount() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getAuthenticationFailureCount(this.server); |
| } |
| return server.getSecurityStore().getAuthenticationFailureCount(); |
| } |
| |
| @Override |
| public long getAuthorizationSuccessCount() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getAuthorizationSuccessCount(this.server); |
| } |
| return server.getSecurityStore().getAuthorizationSuccessCount(); |
| } |
| |
| @Override |
| public long getAuthorizationFailureCount() { |
| if (AuditLogger.isBaseLoggingEnabled()) { |
| AuditLogger.getAuthorizationFailureCount(this.server); |
| } |
| return server.getSecurityStore().getAuthorizationFailureCount(); |
| } |
| |
| public ActiveMQServer getServer() { |
| return server; |
| } |
| } |
| |
