Log (Red Hat JBoss Enterprise Application Platform 7.4.0.GA public API)

All Superinterfaces:

BasicLogger

All Known Implementing Classes:

Log_$logger
```
@MessageLogger(projectCode="ISPN")
public interface Log
extends BasicLogger
```
Infinispan's log abstraction layer on top of JBoss Logging.
It contains explicit methods for all INFO or above levels so that they can be internationalized. For the core module, message ids ranging from 0001 to 0900 inclusively have been reserved.
Log log = LogFactory.getLog( getClass() ); The above will get you an instance of Log, which can be used to generate log messages either via JBoss Logging which then can delegate to Log4J (if the libraries are present) or (if not) the built-in JDK logger.
In addition to the 6 log levels available, this framework also supports parameter interpolation, similar to the JDKs String.format(String, Object...) method. What this means is, that the following block: if (log.isTraceEnabled()) { log.trace("This is a message " + message + " and some other value is " + value); }
... could be replaced with ...
if (log.isTraceEnabled()) log.tracef("This is a message %s and some other value is %s", message, value);
This greatly enhances code readability.
If you are passing a Throwable, note that this should be passed in before the vararg parameter list.

Since:

4.0

Author:

Manik Surtani

Field Summary

Fields
Modifier and Type	Field and Description
`static Log`	`CLUSTER`
`static Log`	`CONFIG`
`static Log`	`CONTAINER`
`static String`	`LOG_ROOT`
`static Log`	`PERSISTENCE`
`static Log`	`SECURITY`
`static Log`	`XSITE`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`advancedExternalizerDeprecated()`
`CacheConfigurationException`	`advanceExternalizerTypeClassesUndefined(String className)`
`void`	`afterCompletionFailed(Synchronization s, Throwable t)`
`void`	`ambiguousConfigurationFiles(String files)`
`CacheConfigurationException`	`attributeNotAllowedInInvalidationMode(String attributeName)`
`void`	`authorizationEnabledWithoutSecurityManager()`
`void`	`autoConfigDeprecated()`
`CacheConfigurationException`	`awaitInitialTransferOnlyForDistOrRepl()`
`CacheConfigurationException`	`backupForMissingParameters()`
`CacheConfigurationException`	`backupForNullCache()`
`CacheConfigurationException`	`backupMissingSite()`
`void`	`beforeCompletionFailed(Synchronization s, Throwable t)`
`CacheConfigurationException`	`biasedReadsAppliesOnlyToScattered()`
`void`	`cacheBackupsDataToSameSite(String siteName)`
`CacheConfigurationException`	`cacheExists(String cacheName)`
`IllegalLifecycleStateException`	`cacheIsStopping(String cacheName)`
`IllegalLifecycleStateException`	`cacheIsTerminated(String cacheName, String state)`
`IllegalLifecycleStateException`	`cacheManagerIsStopping()`
`void`	`cacheRecoveredAfterMerge(String cacheName, CacheTopology currentTopology, AvailabilityMode availabilityMode)`
`void`	`cancelledConflictResolution(String cacheName, CacheTopology currentTopology)`
`CacheConfigurationException`	`cannotChangeMaxCount()`
`CacheConfigurationException`	`cannotChangeMaxSize()`
`EncodingException`	`cannotConvertContent(Object content, MediaType contentType, MediaType destination)`
`EncodingException`	`cannotFindTranscoder(MediaType mediaType, MediaType another)`
`void`	`cannotMarshall(Class<?> aClass, Throwable t)`
`void`	`cannotObtainFailedCache(String name, Throwable t)`
`CacheConfigurationException`	`cannotProvideBothSizeAndCount()`
`CacheConfigurationException`	`cannotRenamePersistentFile(String absolutePath, File persistentFile, Throwable cause)`
`void`	`cannotRespondToCommit(GlobalTransaction globalTransaction, String cacheName)`
`void`	`cannotRespondToRollback(GlobalTransaction globalTransaction, String cacheName)`
`CacheConfigurationException`	`cannotUseDeprecatedAndReplacement(String legacyName)`
`AvailabilityException`	`clearDisallowedWhilePartitioned()`
`CacheConfigurationException`	`clusteredTransactionalStoreMustBeShared(String simpleName)`
`void`	`clusterListenerInstallationFailure(Throwable cause)`
`CacheException`	`clusterListenerRegisteredWithOnlyPreEvents(Class<?> listenerClass)`
`void`	`componentFailedToStop(Throwable e)`
`CacheConfigurationException`	`configAlreadyDefined(String cacheName)`
`IllegalStateException`	`configurationInUse(String configurationName)`
`CacheConfigurationException`	`configurationNameMatchesMultipleWildcards(String name)`
`CacheConfigurationException`	`configurationSerializationFailed(String cacheName, Configuration configuration, Exception e)`
`ContainerFullException`	`containerFull(long size)`
`TimeoutException`	`coordinatorTimeoutWaitingForView(int expectedViewId, int currentViewId, Object clusterManagerStatus)`
`void`	`couldNotCompleteInjectedTransaction(Throwable t)`
`void`	`couldNotFindAttribute(String name)`
`void`	`couldNotInstantiateTransactionManager(Exception e)`
`void`	`couldNotInterruptThread(UUID id)`
`void`	`couldNotInvokeSetOnAttribute(String attributeName, Object value)`
`void`	`couldNotRollbackPrepared1PcTransaction(LocalTransaction localTransaction, Throwable e1)`
`RuntimeException`	`creatingTmpCacheTimedOut(String cacheName, Address address)`
`CacheConfigurationException`	`crossSiteUnavailable()`
`CacheConfigurationException`	`customInterceptorMissingClass()`
`void`	`customInterceptorsDeprecated()`
`CacheConfigurationException`	`customStorageStrategyNotSet()`
`CacheConfigurationException`	`defaultCacheConfigurationWithoutName()`
`AvailabilityException`	`degradedModeKeysUnavailable(Collection<?> keys)`
`AvailabilityException`	`degradedModeKeyUnavailable(Object key)`
`AvailabilityException`	`degradedModeLockUnavailable(Object key)`
`CacheConfigurationException`	`directoryCannotBeCreated(String path)`
`void`	`disconnectJGroups(String cluster)`
`CacheConfigurationException`	`duplicateCacheName(String name)`
`CacheConfigurationException`	`duplicateExternalizerIdFound(int externalizerId, Class<?> typeClass, String otherExternalizer, int readerIndex)`
`CacheConfigurationException`	`duplicateExternalizerIdFound(int externalizerId, String otherExternalizer)`
`EncodingException`	`duplicateIdEncoder(short id)`
`EncodingException`	`duplicateIdWrapper(byte id)`
`CacheConfigurationException`	`duplicateJGroupsStack(String name)`
`CacheConfigurationException`	`duplicateRemoteSite(String remoteSite, String name)`
`void`	`elementDeprecatedUseOther(Element element, Element other)`
`EncodingException`	`encoderClassNotFound(Class<?> wrapperClass)`
`EncodingException`	`encoderIdNotFound(short id)`
`void`	`entriesMigrated(long count, String name, String prettyTime)`
`void`	`errorAsyncStoreNotStopped()`
`void`	`errorCommittingTx(Throwable e)`
`CacheConfigurationException`	`errorCreatingChannelFromConfigFile(String cfg, Exception e)`
`CacheConfigurationException`	`errorCreatingChannelFromConfigString(String cfg, Exception e)`
`CacheConfigurationException`	`errorCreatingChannelFromConfigurator(String configurator, Throwable t)`
`CacheConfigurationException`	`errorCreatingChannelFromXML(String cfg, Exception e)`
`CacheException`	`errorDeserializing(String className)`
`void`	`errorDoingRemoteCall(Exception e)`
`void`	`errorEnlistingResource(Throwable e)`
`void`	`errorExecutingParallelStoreTask(Throwable cause)`
`void`	`errorInstantiatingJGroupsChannelLookup(String channelLookupClassName, Exception e)`
`CacheConfigurationException`	`errorPersistingGlobalConfiguration(Throwable cause)`
`void`	`errorProcessing1pcPrepareCommand(Throwable e)`
`void`	`errorProcessing2pcCommitCommand(Throwable e)`
`void`	`errorProcessingPrepare(Throwable e)`
`void`	`errorProcessingRequest(long requestId, org.jgroups.Address origin, Throwable t)`
`void`	`errorProcessingResponse(long requestId, org.jgroups.Address sender, Throwable t)`
`PersistenceException`	`errorReadingFileStore(String path, long offset)`
`void`	`errorReadingRebalancingStatus(Address coordinator, Throwable t)`
`void`	`errorRollingBack(Throwable e)`
`void`	`errorSendingResponse(long requestId, org.jgroups.Address origin, ReplicableCommand command)`
`EncodingException`	`errorTranscoding(String transcoderName, Throwable cause)`
`void`	`errorUpdatingMembersList(int viewId, Throwable cause)`
`void`	`errorWritingValueForAttribute(String attributeName, Exception e)`
`void`	`evictionDisabled(String cacheName)`
`void`	`evictionExecutorDeprecated()`
`CacheConfigurationException`	`exceptionBasedEvictionOnlySupportedInTransactionalCaches()`
`void`	`exceptionDuringClusterListenerRetrieval(Address address, Throwable cause)`
`void`	`exceptionDuringConflictResolution(Object key, Throwable t)`
`void`	`exceptionHandlingCommand(ReplicableCommand cmd, Throwable t)`
`CacheListenerException`	`exceptionInvokingListener(String name, Method m, Object target, Throwable cause)`
`CacheException`	`exceptionProcessingEntryRetrievalValues(Throwable cause)`
`void`	`exceptionPurgingDataContainer(Throwable e)`
`void`	`executionError(String commandType, String cacheName, String affectedKeys, Throwable t)`
`CacheConfigurationException`	`existingConfigForInternalCache(String name)`
`void`	`expectedJustOneResponse(Map<Address,Response> lr)`
`CacheJoinException`	`extraneousMembersJoinRestoredCache(List<Address> extraneousMembers, String cacheName)`
`CacheConfigurationException`	`factoryCannotConstructComponent(String componentName)`
`void`	`failedConfirmingRevokedSegments(Throwable t)`
`void`	`failedConflictResolution(String cacheName, CacheTopology currentTopology, Throwable t)`
`void`	`failedInvalidatingRemoteCache(Throwable e)`
`void`	`failedInvokingCacheManagerListener(Throwable e)`
`void`	`failedLoadingKeysFromCacheStore(Throwable t)`
`void`	`failedLoadingValueFromCacheStore(Object key, Exception e)`
`void`	`failedOutBoundTransferExecution(Throwable e)`
`void`	`failedProcessingValuesDuringRebalance(Throwable t)`
`CacheConfigurationException`	`failedReadingPersistentState(IOException e, File stateFile)`
`void`	`failedSynchronizationRegistration(Exception e)`
`void`	`failedToCallStopAfterFailure(Throwable t)`
`void`	`failedToCreateInitialCtx(Throwable e)`
`void`	`failedToEnlistTransactionXaAdapter(Throwable e)`
`void`	`failedToInvalidateKeys(Throwable e)`
`void`	`failedToRecoverCacheState(String cacheName, Throwable cause)`
`void`	`failedToRecoverClusterState(Throwable cause)`
`void`	`failedToRequestSegments(String cacheName, Address source, Collection<Integer> segments, Throwable e)`
`void`	`failedToRestartXSiteStateTransfer(String siteName, Throwable cause)`
`void`	`failedToRetrieveTransactionsForSegments(String cacheName, Address source, Collection<Integer> segments, Throwable t)`
`void`	`failedToUpdateAttribute(String name, Object value)`
`TimeoutException`	`failedWaitingForTopology(int requestTopologyId)`
`CacheConfigurationException`	`failedWritingGlobalState(IOException e, File stateFile)`
`void`	`fallingBackToEmbeddedTm()`
`void`	`finishedConflictResolution(String cacheName, CacheTopology currentTopology)`
`void`	`finishedRebalance(String cacheName, CacheTopology topology)`
`CacheConfigurationException`	`forbiddenStoreLocation(Path location, Path global)`
`CacheConfigurationException`	`foreignExternalizerUsingNegativeId(AdvancedExternalizer<?> ext, int externalizerId)`
`CacheConfigurationException`	`foundMultipleDirectoryProviders()`
`IllegalStateException`	`getConflictsAlreadyInProgress()`
`IllegalStateException`	`getConflictsStateTransferInProgress(String cacheName)`
`CacheConfigurationException`	`globalSecurityAuthShouldBeEnabled()`
`CacheConfigurationException`	`globalStateCannotAcquireLockFile(Throwable cause, File lockFile)`
`CacheConfigurationException`	`globalStateDisabled()`
`void`	`globalStateLoad(String version, String timestamp)`
`void`	`globalStateWrite(String version, String timestamp)`
`CacheConfigurationException`	`groupingOnlyCompatibleWithObjectStorage(StorageType storageType)`
`CacheConfigurationException`	`groupingOnlyCompatibleWithObjectStorage(String keyMediaType, String valueMediaType)`
`void`	`ignoredAttribute(String componentName, String version, String attributeName, int line)`
`void`	`ignoredReplicationQueueAttribute(String attributeName, int line)`
`void`	`ignoreXmlAttribute(Object attribute, int line, int column)`
`void`	`ignoreXmlElement(Object element, int line, int column)`
`void`	`ignoringCacheTopology(Collection<Address> sender, CacheTopology topology)`
`void`	`ignoringInvalidateVersionsFromOldTopology(int invalidationTopology, int currentTopologyId)`
`void`	`ignoringSpecificMediaTypes()`
`void`	`ignoringUnsolicitedState(Address node, int segment, String cacheName)`
`UnsupportedOperationException`	`immutableConfiguration()`
`CacheConfigurationException`	`incompatibleClusterConfiguration(String cacheName, Configuration configuration, Configuration existing)`
`CacheConfigurationException`	`incompatiblePersistedConfiguration(String cacheName, Configuration configuration, Configuration existing)`
`void`	`incompleteGlobalState()`
`CacheConfigurationException`	`indexEnabledAndIndexModeAreExclusive()`
`void`	`indexModeDeprecated()`
`CacheConfigurationException`	`indexModeNotSupported(String indexMode)`
`CacheConfigurationException`	`interceptorClassAndInstanceDefined(String customInterceptorClassName, String customInterceptor)`
`UnsupportedOperationException`	`interceptorStackNotSupported()`
`CacheConfigurationException`	`internalExternalizerIdLimitExceeded(AdvancedExternalizer<?> ext, int externalizerId, int maxId)`
`void`	`interruptedAcquiringLock(long ms, InterruptedException e)`
`void`	`interruptedWaitingAsyncStorePush(InterruptedException e)`
`void`	`interruptedWaitingForCoordinator(InterruptedException e)`
`CacheConfigurationException`	`invalidationBatchSizeAppliesOnNonScattered()`
`CacheConfigurationException`	`invalidationPartitionHandlingNotSuported()`
`CacheConfigurationException`	`invalidChunkSize(int chunkSize)`
`CacheConfigurationException`	`invalidCompletedTxTimeout(long timeout)`
`CacheConfigurationException`	`invalidConfigurationIndexingWithInvalidation()`
`CacheConfigurationException`	`invalidConfigurationIndexingWithoutModule()`
`CacheException`	`invalidEncodingClass(Class<?> configured, Class<?> required)`
`CacheConfigurationException`	`invalidEvictionSize()`
`void`	`invalidMessageType(int messageType, org.jgroups.Address origin)`
`IllegalArgumentException`	`invalidPermission(Permission permission)`
`CacheConfigurationException`	`invalidPersistentState(String globalScope)`
`CacheConfigurationException`	`invalidPrincipalRoleMapper()`
`CacheConfigurationException`	`invalidReaperWakeUpInterval(long timeout)`
`CacheConfigurationException`	`invalidScope(String expected, String found)`
`CacheConfigurationException`	`invalidXSiteStateTransferTimeout()`
`CacheConfigurationException`	`invalidXSiteStateTransferWaitTime()`
`CacheConfigurationException`	`invocationBatchingCannotBeRecoverable()`
`CacheConfigurationException`	`invocationBatchingNeedsTransactionalCache()`
`CacheConfigurationException`	`invocationBatchingNotEnabled()`
`void`	`jbossMarshallingDetected()`
`CacheConfigurationException`	`jgroupsConfigurationNotFound(String cfg)`
`CacheConfigurationException`	`jgroupsInsertAfterRequiresPosition(String protocolName)`
`CacheConfigurationException`	`jgroupsNoStackPosition(String combineMode)`
`CacheConfigurationException`	`jgroupsNoSuchProtocol(String protocolName, String combineMode)`
`CacheConfigurationException`	`jgroupsRelayWithoutRemoteSites(String name)`
`CacheConfigurationException`	`jgroupsRemoteSitesWithoutRelay(String name)`
`JmxDomainConflictException`	`jmxMBeanAlreadyRegistered(String jmxDomain, Throwable cause)`
`void`	`keyMigrationFailed(String key, Throwable cause)`
`CacheConfigurationException`	`l1InvalidLifespan()`
`CacheConfigurationException`	`l1NotValidWithExpirationEviction()`
`CacheConfigurationException`	`l1OnlyForDistributedCache(String cacheMode)`
`CacheConfigurationException`	`loaderConfigurationDoesNotSpecifyLoaderClass(String className)`
`void`	`localAndPhysicalAddress(String cluster, Address address, List<Address> physicalAddresses)`
`UnsupportedOperationException`	`lockOperationsNotSupported()`
`CacheConfigurationException`	`managerConfigurationStorageUnavailable()`
`void`	`marshallersNotSupported()`
`CacheConfigurationException`	`missingBackupFailurePolicyClass()`
`CacheConfigurationException`	`missingCustomInterceptorPosition(String customInterceptorClassName)`
`CacheConfigurationException`	`missingDefaultCacheDeclaration(String defaultCache)`
`CacheException`	`missingForeignExternalizer(int foreignId)`
`void`	`missingGlobalStatePersistentLocation()`
`CacheConfigurationException`	`missingJGroupsStack(String name)`
`void`	`missingListPreparedTransactions(Object key, Object value)`
`CacheConfigurationException`	`missingTransportConfiguration()`
`MarshallingException`	`missingTypeForUnwrappedPayload()`
`void`	`moduleStopError(String module, Throwable t)`
`CacheConfigurationException`	`multipleCustomInterceptorPositions(String customInterceptorClassName)`
`CacheConfigurationException`	`multipleSitesWithSameName(String site)`
`void`	`noAnnotateMethodsFoundInListener(Class<?> listenerClass)`
`CacheConfigurationException`	`noConfiguration(String extend)`
`CacheConfigurationException`	`noDefaultCache()`
`CacheJoinException`	`nodeWithIncompatibleStateJoiningCache(Address joiner, String cacheName)`
`CacheJoinException`	`nodeWithoutPersistentStateJoiningCacheWithState(Address joiner, String cacheName)`
`CacheJoinException`	`nodeWithPersistentStateJoiningClusterWithoutState(Address joiner, String cacheName)`
`void`	`noFilterIndexingServiceProviderFound(String filterClassName)`
`void`	`noIndexableClassesDefined()`
`void`	`noLiveOwnersFoundForSegments(Collection<Integer> segments, String cacheName, Collection<Address> faultySources)`
`CacheConfigurationException`	`nonSharedStoreConfiguredAsShared(String storeType)`
`CacheConfigurationException`	`nonWritableStateFile(File stateFile)`
`CacheConfigurationException`	`noSuchCacheConfiguration(String name)`
`void`	`notStartingEvictionThread()`
`CacheConfigurationException`	`notSupportedInSimpleCache()`
`CacheConfigurationException`	`offHeapMemoryEvictionNotSupportedWithObject()`
`CacheConfigurationException`	`onlyOneFetchPersistentStoreAllowed()`
`CacheConfigurationException`	`onlyOnePreloadStoreAllowed()`
`CacheConfigurationException`	`parserDoesNotDeclareNamespaces(String name)`
`void`	`parserRootElementAlreadyRegistered(QName qName, String oldParser, String newParser)`
`AvailabilityException`	`partitionDegraded()`
`void`	`partitionHandlingConfigurationEnabledDeprecated()`
`CacheConfigurationException`	`passivationStoreCannotBeShared(String name)`
`void`	`passivationWithoutEviction()`
`PersistenceException`	`persistedDataMigrationFailed(Throwable cause)`
`void`	`persistedDataSuccessfulMigrated()`
`void`	`persistenceWithoutCacheLoaderInterceptor()`
`void`	`persistenceWithoutCacheWriteInterceptor()`
`IllegalStateException`	`persistentConsistentHashMismatch(String hashFactory, String consistentHashClass)`
`CacheConfigurationException`	`preloadAndPurgeOnStartupConflict()`
`void`	`preparedTxAlreadyExists(RecoveryAwareTransaction previous, RecoveryAwareRemoteTransaction remoteTransaction)`
`void`	`problemApplyingStateForKey(String msg, Object key, Throwable t)`
`void`	`problemClosingChannel(Exception e, String cluster)`
`void`	`queriedAttributeNotFound(String attributeName)`
`void`	`randomCacheModeSynonymsDeprecated(String candidate, String mode, List<String> synonyms)`
`SecurityException`	`readOnlyPermissionCollection()`
`void`	`rebalanceError(String cacheName, Address node, int topologyId, Throwable cause)`
`void`	`rebalancePhaseConfirmedOnNode(CacheTopology.Phase phase, String cacheName, Address node, int topologyId)`
`void`	`rebalanceStartError(String cacheName, Throwable cause)`
`void`	`rebalancingEnabled()`
`void`	`rebalancingSuspended()`
`void`	`receivedClusterView(String cluster, org.jgroups.View newView)`
`void`	`receivedMergedView(String cluster, org.jgroups.View newView)`
`void`	`receivedXSiteClusterView(Collection<String> view)`
`void`	`recoveryIgnored()`
`CacheConfigurationException`	`recoveryNotSupportedWithNonTxCache()`
`CacheConfigurationException`	`recoveryNotSupportedWithSynchronization()`
`RemoteException`	`remoteException(Address sender, Throwable t)`
`SuspectException`	`remoteNodeSuspected(Address address)`
`TimeoutException`	`remoteNodeTimedOut(Address address, long time, TimeUnit unit)`
`CacheException`	`remoteTransactionAlreadyCompleted(GlobalTransaction gtx)`
`CacheException`	`remoteTransactionAlreadyRolledBack(GlobalTransaction gtx)`
`CacheException`	`remoteTransactionOriginatorNotInView(GlobalTransaction gtx)`
`TimeoutException`	`remoteTransactionStatusMissing(GlobalTransaction gtx)`
`void`	`remoteTransactionTimeout(GlobalTransaction gtx, long ageMilliSeconds)`
`TimeoutException`	`requestTimedOut(long requestId, String targetsWithoutResponses)`
`void`	`retrievingTm(TransactionManager tm)`
`CacheConfigurationException`	`scatteredCacheIsNonTransactional()`
`CacheConfigurationException`	`scatteredCacheNeedsSingleOwner()`
`void`	`segmentedStoreUsesManyFileDescriptors(String storeName)`
`CacheConfigurationException`	`sharedStoreShouldNotBePurged(String name)`
`CacheConfigurationException`	`sharedStoreWithLocalCache()`
`CacheConfigurationException`	`singleOwnerNotSetToAllowReadWrites()`
`CacheConfigurationException`	`siteMustBeInBackups(String site)`
`void`	`staleEntriesWithoutFetchPersistentStateOrPurgeOnStartup()`
`void`	`startingConflictResolution(String cacheName, CacheTopology currentTopology)`
`void`	`startingJGroupsChannel(String cluster)`
`void`	`startingJGroupsChannel(String cluster, String stack)`
`void`	`startingRebalancePhase(String cacheName, CacheTopology cacheTopology)`
`void`	`startingUserMarshaller(String marshallerClass)`
`void`	`startMigratingPersistenceData()`
`CacheConfigurationException`	`statisticsEnabledNotAvailable()`
`void`	`stopOrderIgnored()`
`CacheConfigurationException`	`storeBothReadAndWriteOnly()`
`CacheConfigurationException`	`storeConfiguredHasBothReadAndWriteOnly(String storeClassName, NonBlockingStore.Characteristic configured, NonBlockingStore.Characteristic implSpecifies)`
`CacheConfigurationException`	`storeConfiguredSharedButCharacteristicNotPresent(String storeClassName)`
`CacheConfigurationException`	`storeConfiguredTransactionalButCharacteristicNotPresent(String storeClassName)`
`CacheConfigurationException`	`storeDoesNotSupportBeingSegmented(String name)`
`CacheConfigurationException`	`storeLocationRequired()`
`CacheConfigurationException`	`storeLocationRequired(String storeType, String attributeName)`
`CacheConfigurationException`	`storeNotSegmented(Class<?> implementedClass)`
`CacheConfigurationException`	`storeReadOnlyExceptions()`
`PersistenceException`	`storeStartupAttemptsExceeded(String storeName, Throwable t)`
`CacheConfigurationException`	`storeWriteOnlyExceptions()`
`void`	`suggestCustomInterceptorInheritance(String customInterceptorClassName)`
`CacheConfigurationException`	`templateConfigurationStartAttempt(String cacheName)`
`SuspectException`	`thirdPartySuspected(Address sender, SuspectException e)`
`CacheConfigurationException`	`threadPoolFactoryIsBlocking(String name, String poolName)`
`TimeoutException`	`timeoutWaitingForAcks(String timeout, long id)`
`TimeoutException`	`timeoutWaitingForInitialNodes(int initialClusterSize, List<?> members)`
`TimeoutException`	`timeoutWaitingForView(int expectedViewId, int currentViewId)`
`void`	`timeoutWaitingUntilTransactionPrepared(String globalTx)`
`void`	`topologyUpdateError(String cacheName, Throwable cause)`
`CacheConfigurationException`	`transactionalStoreCannotBeAsync(String simpleName)`
`CacheConfigurationException`	`transactionalStoreInNonTransactionalCache()`
`CacheConfigurationException`	`transactionalStoreInPassivatedCache()`
`void`	`transactionCleanupError(Throwable e)`
`void`	`transactionNotificationsDisabled()`
`void`	`tryingToBringOnlineNonexistentSite(String siteName)`
`CacheConfigurationException`	`twoPhaseCommitAsyncBackup()`
`TimeoutException`	`unableToAcquireLock(String timeout, Object key, Object requestor, Object owner)`
`CacheConfigurationException`	`unableToAddJGroupsStack(String name, Exception e)`
`IllegalArgumentException`	`unableToAddNullCustomStore()`
`IllegalArgumentException`	`unableToAddNullEntryMergePolicyFactory()`
`void`	`unableToApplyXSiteState(Throwable cause)`
`RuntimeException`	`unableToBroadcastInvalidation(Throwable e)`
`void`	`unableToCreateInterceptor(Class<?> type, Exception e)`
`IllegalStateException`	`unableToFindLocalTransactionFromRemoteSiteTransaction(GlobalTransaction globalTransaction)`
`CacheException`	`unableToFindRemoteSiteTransaction(GlobalTransaction globalTransaction)`
`CacheConfigurationException`	`unableToInstantiateClass(Class<?> storeConfigurationClass)`
`CacheConfigurationException`	`unableToInstantiateSerializer(Class<?> storeConfigurationClass)`
`void`	`unableToInvokeListenerMethod(Method m, Object target, Throwable e)`
`void`	`unableToInvokeListenerMethodAndRemoveListener(Method m, Object target, Throwable e)`
`void`	`unableToLockToInvalidate(Object key, Address address)`
`void`	`unableToPassivateEntry(Object key, Throwable e)`
`void`	`unableToProcessAsyncModifications(int retries)`
`void`	`unableToRemoveEntryAfterActivation(Object key, Throwable e)`
`void`	`unableToRollbackGlobalTx(GlobalTransaction gtx, Throwable e)`
`void`	`unableToRollbackInvalidationsDuringPrepare(Throwable e)`
`void`	`unableToSendXSiteState(String site, Throwable cause)`
`void`	`unableToSetAccessible(Method m, Exception e)`
`void`	`unableToSetValue(Exception e)`
`void`	`unableToUseJGroupsPropertiesProvided(TypedProperties props)`
`SecurityException`	`unauthorizedAccess(String subject, String permission)`
`CacheConfigurationException`	`undeclaredConfiguration(String template, String name)`
`CacheConfigurationException`	`undefinedThreadPoolName(String name)`
`void`	`unexpectedErrorFromIrac(Throwable t)`
`void`	`unexpectedErrorFromResourceManager(Throwable t)`
`void`	`unexpectedErrorInAsyncStoreCoordinator(Throwable t)`
`void`	`unexpectedErrorReplicating(Throwable t)`
`IllegalArgumentException`	`unexpectedInitialVersion(String className)`
`IllegalArgumentException`	`unexpectedResponse(Address target, Response response)`
`void`	`unfinishedTransactionsRemain(int localTransactions, int remoteTransactions)`
`void`	`unknownEncoding(String cacheName)`
`CacheException`	`unknownExternalizerReaderIndex(int readerIndex)`
`Exception`	`unknownMigrator(String migratorName)`
`void`	`unknownResponsesFromRemoteCache(Collection<Response> responses)`
`CacheConfigurationException`	`unknownTransactionConfiguration(TransactionMode mode, boolean xaEnabled, boolean recoveryEnabled, boolean batchingEnabled)`
`void`	`unrecognizedAttribute(String property)`
`void`	`unsuccessfulResponseForClusterListeners(Address address, Response response)`
`void`	`unsuccessfulResponseRetrievingTransactionsForSegments(Address address, Response response)`
`CacheConfigurationException`	`unsupportedAsyncCacheMode(CacheMode cacheMode)`
`void`	`unsupportedAsyncCacheMode(CacheMode unsupportedCacheMode, CacheMode forcedCacheMode)`
`CacheConfigurationException`	`unsupportedConfiguration(String element, String namespaceUri, String version)`
`EncodingException`	`unsupportedContent(String transcoderName, Object content)`
`void`	`updatingAvailabilityMode(String cacheName, AvailabilityMode oldMode, AvailabilityMode newMode, CacheTopology topology)`
`void`	`updatingStableTopology(String cacheName, CacheTopology currentTopology)`
`void`	`updatingTopology(String cacheName, CacheTopology currentTopology, AvailabilityMode availabilityMode)`
`void`	`usingBatchModeTransactionManager()`
`void`	`version(String version)`
`void`	`viewHandlingError(int viewId, Throwable t)`
`void`	`warnConfigurationForAnnotationMissing(String name)`
`void`	`warnCouldNotCommitLocalTx(Object transactionDescription, Throwable e)`
`void`	`warnCouldNotRollbackLocalTx(Object transactionDescription, Throwable e)`
`void`	`warnExceptionRemovingRecovery(Throwable e)`
`void`	`warnGridFSMetadataCacheRequiresSync()`
`void`	`warnL1NotHavingReaperThread()`
`void`	`warnUnableToPersistInternalCaches()`
`void`	`warnUsingDeprecatedClusterLoader()`
`void`	`warnUsingDeprecatedMemoryConfigs(String element)`
`void`	`warnXsiteBackupFailed(String cacheName, String key, Object value)`
`CacheConfigurationException`	`wildcardsNotAllowedInCacheNames(String name)`
`EncodingException`	`wrapperClassNotFound(Class<?> wrapperClass)`
`EncodingException`	`wrapperIdNotFound(byte id)`
`WriteSkewException`	`writeSkewOnRead(Object key, Object key2, EntryVersion lastVersion, EntryVersion remoteVersion)`
`void`	`wrongTypeForJGroupsChannelLookup(String channelLookupClassName, Exception e)`
`void`	`xaResourceEndFailed(XAResource resource, Throwable t)`
`void`	`xsiteAdminOperationError(String operationName, String siteName, Throwable t)`
`CacheConfigurationException`	`xsiteCacheNotFound(String remoteSite, ByteString cacheName)`
`CacheConfigurationException`	`xsiteCacheNotStarted(String origin, ByteString cacheName)`
`CacheConfigurationException`	`xsiteInLocalCache()`
`CacheConfigurationException`	`xsiteInLocalCache(String origin, ByteString cacheName)`
`void`	`xsiteInvalidConfigurationRemoteSite(String siteName)`

Methods inherited from interface org.jboss.logging.BasicLogger
debug, debug, debug, debug, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugf, debugv, debugv, debugv, debugv, debugv, debugv, debugv, debugv, error, error, error, error, errorf, errorf, errorf, errorf, errorf, errorf, errorf, errorf, errorv, errorv, errorv, errorv, errorv, errorv, errorv, errorv, fatal, fatal, fatal, fatal, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalf, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, fatalv, info, info, info, info, infof, infof, infof, infof, infof, infof, infof, infof, infov, infov, infov, infov, infov, infov, infov, infov, isDebugEnabled, isEnabled, isInfoEnabled, isTraceEnabled, log, log, log, log, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logf, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, logv, trace, trace, trace, trace, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracef, tracev, tracev, tracev, tracev, tracev, tracev, tracev, tracev, warn, warn, warn, warn, warnf, warnf, warnf, warnf, warnf, warnf, warnf, warnf, warnv, warnv, warnv, warnv, warnv, warnv, warnv, warnv

Field Detail

LOG_ROOT
```
static final String LOG_ROOT
```
See Also:

Constant Field Values

CONFIG
```
static final Log CONFIG
```

CLUSTER
```
static final Log CLUSTER
```

CONTAINER
```
static final Log CONTAINER
```

PERSISTENCE
```
static final Log PERSISTENCE
```

SECURITY
```
static final Log SECURITY
```

XSITE
```
static final Log XSITE
```

Method Detail

problemApplyingStateForKey

@LogMessage(level=ERROR)
 @Message(value="Problem %s encountered when applying state for key %s!",
         id=16)
void problemApplyingStateForKey(String msg,
                                                                                                                                                   Object key,
                                                                                                                                                   @Cause
                                                                                                                                                   Throwable t)

expectedJustOneResponse

@LogMessage(level=WARN)
 @Message(value="Expected just one response; got %s",
         id=21)
void expectedJustOneResponse(Map<Address,Response> lr)

notStartingEvictionThread

@LogMessage(level=INFO)
 @Message(value="wakeUpInterval is <= 0, not starting expired purge thread",
         id=25)
void notStartingEvictionThread()

exceptionPurgingDataContainer

@LogMessage(level=WARN)
 @Message(value="Caught exception purging data container!",
         id=26)
void exceptionPurgingDataContainer(@Cause
                                                                                                                                       Throwable e)

unableToPassivateEntry

@LogMessage(level=WARN)
 @Message(value="Unable to passivate entry under %s",
         id=28)
void unableToPassivateEntry(Object key,
                                                                                                                          @Cause
                                                                                                                          Throwable e)

jmxMBeanAlreadyRegistered

@Message(value="The \'%s\' JMX domain is already in use.",
         id=34)
JmxDomainConflictException jmxMBeanAlreadyRegistered(String jmxDomain,
                                                                                                                                @Cause
                                                                                                                                Throwable cause)

couldNotFindAttribute

@LogMessage(level=WARN)
 @Message(value="Did not find attribute %s",
         id=36)
void couldNotFindAttribute(String name)

failedToUpdateAttribute

@LogMessage(level=WARN)
 @Message(value="Failed to update attribute name %s with value %s",
         id=37)
void failedToUpdateAttribute(String name,
                                                                                                                                         Object value)

queriedAttributeNotFound

@LogMessage(level=WARN)
 @Message(value="Did not find queried attribute with name %s",
         id=42)
void queriedAttributeNotFound(String attributeName)

errorWritingValueForAttribute

@LogMessage(level=WARN)
 @Message(value="Exception while writing value for attribute %s",
         id=43)
void errorWritingValueForAttribute(String attributeName,
                                                                                                                                             @Cause
                                                                                                                                             Exception e)

couldNotInvokeSetOnAttribute

@LogMessage(level=WARN)
 @Message(value="Could not invoke set on attribute %s with value %s",
         id=44)
void couldNotInvokeSetOnAttribute(String attributeName,
                                                                                                                                                Object value)

unknownResponsesFromRemoteCache

@LogMessage(level=ERROR)
 @Message(value="Unknown responses from remote cache: %s",
         id=46)
void unknownResponsesFromRemoteCache(Collection<Response> responses)

errorDoingRemoteCall

@LogMessage(level=ERROR)
 @Message(value="Error while doing remote call",
         id=47)
void errorDoingRemoteCall(@Cause
                                                                                                                    Exception e)

interruptedWaitingAsyncStorePush

@LogMessage(level=ERROR)
 @Message(value="Interrupted or timeout while waiting for AsyncCacheWriter worker threads to push all state to the decorated store",
         id=48)
void interruptedWaitingAsyncStorePush(@Cause
                                                                                                                                                                                                                    InterruptedException e)

interruptedAcquiringLock

@LogMessage(level=ERROR)
 @Message(value="Interrupted on acquireLock for %d milliseconds!",
         id=52)
void interruptedAcquiringLock(long ms,
                                                                                                                                          @Cause
                                                                                                                                          InterruptedException e)

unableToProcessAsyncModifications

@LogMessage(level=WARN)
 @Message(value="Unable to process some async modifications after %d retries!",
         id=53)
void unableToProcessAsyncModifications(int retries)

unexpectedErrorInAsyncStoreCoordinator

@LogMessage(level=ERROR)
 @Message(value="Unexpected error in AsyncStoreCoordinator thread. AsyncCacheWriter is dead!",
         id=55)
void unexpectedErrorInAsyncStoreCoordinator(@Cause
                                                                                                                                                                                    Throwable t)

exceptionHandlingCommand

@LogMessage(level=WARN)
 @Message(value="Caught exception when handling command %s",
         id=71)
void exceptionHandlingCommand(ReplicableCommand cmd,
                                                                                                                                   @Cause
                                                                                                                                   Throwable t)

unexpectedErrorReplicating

@LogMessage(level=ERROR)
 @Message(value="Unexpected error while replicating",
         id=73)
void unexpectedErrorReplicating(@Cause
                                                                                                                               Throwable t)

startingJGroupsChannel

@LogMessage(level=INFO)
 @Message(value="Starting JGroups channel %s",
         id=78)
void startingJGroupsChannel(String cluster)

startingJGroupsChannel

@LogMessage(level=INFO)
 @Message(value="Starting JGroups channel %s with stack %s",
         id=78)
void startingJGroupsChannel(String cluster,
                                                                                                                                 String stack)

localAndPhysicalAddress

@LogMessage(level=INFO)
 @Message(value="Channel %s local address is %s, physical addresses are %s",
         id=79)
void localAndPhysicalAddress(String cluster,
                                                                                                                                                  Address address,
                                                                                                                                                  List<Address> physicalAddresses)

disconnectJGroups

@LogMessage(level=INFO)
 @Message(value="Disconnecting JGroups channel %s",
         id=80)
void disconnectJGroups(String cluster)

problemClosingChannel

@LogMessage(level=ERROR)
 @Message(value="Problem closing channel %s; setting it to null",
         id=81)
void problemClosingChannel(@Cause
                                                                                                                                      Exception e,
                                                                                                                                      String cluster)

wrongTypeForJGroupsChannelLookup

@LogMessage(level=ERROR)
 @Message(value="Class [%s] cannot be cast to JGroupsChannelLookup! Not using a channel lookup.",
         id=83)
void wrongTypeForJGroupsChannelLookup(String channelLookupClassName,
                                                                                                                                                                                 @Cause
                                                                                                                                                                                 Exception e)

errorInstantiatingJGroupsChannelLookup

@LogMessage(level=ERROR)
 @Message(value="Errors instantiating [%s]! Not using a channel lookup.",
         id=84)
void errorInstantiatingJGroupsChannelLookup(String channelLookupClassName,
                                                                                                                                                               @Cause
                                                                                                                                                               Exception e)

errorCreatingChannelFromConfigFile

@Message(value="Error while trying to create a channel using the specified configuration file: %s",
         id=85)
CacheConfigurationException errorCreatingChannelFromConfigFile(String cfg,
                                                                                                                                                                                   @Cause
                                                                                                                                                                                   Exception e)

errorCreatingChannelFromXML

@Message(value="Error while trying to create a channel using the specified configuration XML: %s",
         id=86)
CacheConfigurationException errorCreatingChannelFromXML(String cfg,
                                                                                                                                                                           @Cause
                                                                                                                                                                           Exception e)

errorCreatingChannelFromConfigString

@Message(value="Error while trying to create a channel using the specified configuration string: %s",
         id=87)
CacheConfigurationException errorCreatingChannelFromConfigString(String cfg,
                                                                                                                                                                                       @Cause
                                                                                                                                                                                       Exception e)

unableToUseJGroupsPropertiesProvided

@LogMessage(level=INFO)
 @Message(value="Unable to use any JGroups configuration mechanisms provided in properties %s. Using default JGroups configuration!",
         id=88)
void unableToUseJGroupsPropertiesProvided(TypedProperties props)

interruptedWaitingForCoordinator

@LogMessage(level=ERROR)
 @Message(value="getCoordinator(): Interrupted while waiting for members to be set",
         id=89)
void interruptedWaitingForCoordinator(@Cause
                                                                                                                                                                    InterruptedException e)

receivedMergedView

@LogMessage(level=INFO)
 @Message(value="Received new, MERGED cluster view for channel %s: %s",
         id=93)
void receivedMergedView(String cluster,
                                                                                                                                        org.jgroups.View newView)

receivedClusterView

@LogMessage(level=INFO)
 @Message(value="Received new cluster view for channel %s: %s",
         id=94)
void receivedClusterView(String cluster,
                                                                                                                                 org.jgroups.View newView)

errorProcessing1pcPrepareCommand

@LogMessage(level=ERROR)
 @Message(value="Error while processing a prepare in a single-phase transaction",
         id=97)
void errorProcessing1pcPrepareCommand(@Cause
                                                                                                                                                                 Throwable e)

errorRollingBack

@LogMessage(level=ERROR)
 @Message(value="Exception during rollback",
         id=98)
void errorRollingBack(@Cause
                                                                                                            Throwable e)

unfinishedTransactionsRemain

@LogMessage(level=WARN)
 @Message(value="Stopping, but there are %s local transactions and %s remote transactions that did not finish in time.",
         id=100)
void unfinishedTransactionsRemain(int localTransactions,
                                                                                                                                                                                                    int remoteTransactions)

failedSynchronizationRegistration

@LogMessage(level=WARN)
 @Message(value="Failed synchronization registration",
         id=101)
void failedSynchronizationRegistration(@Cause
                                                                                                                                       Exception e)

unableToRollbackGlobalTx

@LogMessage(level=WARN)
 @Message(value="Unable to roll back global transaction %s",
         id=102)
void unableToRollbackGlobalTx(GlobalTransaction gtx,
                                                                                                                                    @Cause
                                                                                                                                    Throwable e)

fallingBackToEmbeddedTm

@LogMessage(level=INFO)
 @Message(value="Using EmbeddedTransactionManager",
         id=104)
void fallingBackToEmbeddedTm()

failedToCreateInitialCtx

@LogMessage(level=ERROR)
 @Message(value="Failed creating initial JNDI context",
         id=105)
void failedToCreateInitialCtx(@Cause
                                                                                                                                Throwable e)

retrievingTm

@LogMessage(level=INFO)
 @Message(value="Retrieving transaction manager %s",
         id=107)
void retrievingTm(TransactionManager tm)

errorEnlistingResource

@LogMessage(level=ERROR)
 @Message(value="Error enlisting resource",
         id=108)
void errorEnlistingResource(@Cause
                                                                                                                  Throwable e)

beforeCompletionFailed

@LogMessage(level=ERROR)
 @Message(value="beforeCompletion() failed for %s",
         id=109)
void beforeCompletionFailed(Synchronization s,
                                                                                                                          @Cause
                                                                                                                          Throwable t)

unexpectedErrorFromResourceManager

@LogMessage(level=ERROR)
 @Message(value="Unexpected error from resource manager!",
         id=110)
void unexpectedErrorFromResourceManager(@Cause
                                                                                                                                             Throwable t)

afterCompletionFailed

@LogMessage(level=ERROR)
 @Message(value="afterCompletion() failed for %s",
         id=111)
void afterCompletionFailed(Synchronization s,
                                                                                                                        @Cause
                                                                                                                        Throwable t)

errorCommittingTx

@LogMessage(level=WARN)
 @Message(value="exception while committing",
         id=112)
void errorCommittingTx(@Cause
                                                                                                              Throwable e)

recoveryIgnored

@LogMessage(level=WARN)
 @Message(value="Recovery call will be ignored as recovery is disabled. More on recovery: http://community.jboss.org/docs/DOC-16646",
         id=115)
void recoveryIgnored()

missingListPreparedTransactions

@LogMessage(level=WARN)
 @Message(value="Missing the list of prepared transactions from node %s. Received response is %s",
         id=116)
void missingListPreparedTransactions(Object key,
                                                                                                                                                                                 Object value)

preparedTxAlreadyExists

@LogMessage(level=ERROR)
 @Message(value="There\'s already a prepared transaction with this xid: %s. New transaction is %s. Are there two different transactions having same Xid in the cluster?",
         id=117)
void preparedTxAlreadyExists(RecoveryAwareTransaction previous,
                                                                                                                                                                                                                                                 RecoveryAwareRemoteTransaction remoteTransaction)

unableToSetValue

@LogMessage(level=ERROR)
 @Message(value="Unable to set value!",
         id=121)
void unableToSetValue(@Cause
                                                                                                        Exception e)

failedToCallStopAfterFailure

@LogMessage(level=WARN)
 @Message(value="Attempted to stop() from FAILED state, but caught exception",
         id=126)
void failedToCallStopAfterFailure(@Cause
                                                                                                                                                          Throwable t)

version

@LogMessage(level=INFO)
 @Message(value="Infinispan version: %s",
         id=128)
void version(String version)

noAnnotateMethodsFoundInListener

@LogMessage(level=WARN)
 @Message(value="Attempted to register listener of class %s, but no valid, public methods annotated with method-level event annotations found! Ignoring listener.",
         id=133)
void noAnnotateMethodsFoundInListener(Class<?> listenerClass)

unableToInvokeListenerMethodAndRemoveListener

@LogMessage(level=WARN)
 @Message(value="Unable to invoke method %s on Object instance %s - removing this target object from list of listeners!",
         id=134)
void unableToInvokeListenerMethodAndRemoveListener(Method m,
                                                                                                                                                                                                                      Object target,
                                                                                                                                                                                                                      @Cause
                                                                                                                                                                                                                      Throwable e)

unableToLockToInvalidate

@LogMessage(level=WARN)
 @Message(value="Could not lock key %s in order to invalidate from L1 at node %s, skipping....",
         id=135)
void unableToLockToInvalidate(Object key,
                                                                                                                                                                        Address address)

executionError

@LogMessage(level=ERROR)
 @Message(value="Error executing command %s on %s, writing keys %s",
         id=136)
void executionError(String commandType,
                                                                                                                                   String cacheName,
                                                                                                                                   String affectedKeys,
                                                                                                                                   @Cause
                                                                                                                                   Throwable t)

failedInvalidatingRemoteCache

@LogMessage(level=INFO)
 @Message(value="Failed invalidating remote cache",
         id=137)
void failedInvalidatingRemoteCache(@Cause
                                                                                                                                Throwable e)

couldNotRollbackPrepared1PcTransaction

@LogMessage(level=WARN)
 @Message(value="Could not rollback prepared 1PC transaction. This transaction will be rolled back by the recovery process, if enabled. Transaction: %s",
         id=141)
void couldNotRollbackPrepared1PcTransaction(LocalTransaction localTransaction,
                                                                                                                                                                                                                                               @Cause
                                                                                                                                                                                                                                               Throwable e1)

failedLoadingValueFromCacheStore

@LogMessage(level=WARN)
 @Message(value="Failed loading value for key %s from cache store",
         id=144)
void failedLoadingValueFromCacheStore(Object key,
                                                                                                                                                   @Cause
                                                                                                                                                   Exception e)

failedToInvalidateKeys

@LogMessage(level=ERROR)
 @Message(value="Error invalidating keys from L1 after rehash",
         id=147)
void failedToInvalidateKeys(@Cause
                                                                                                                                      Throwable e)

staleEntriesWithoutFetchPersistentStateOrPurgeOnStartup

@LogMessage(level=WARN)
 @Message(value="Fetch persistent state and purge on startup are both disabled, cache may contain stale entries on startup",
         id=149)
void staleEntriesWithoutFetchPersistentStateOrPurgeOnStartup()

passivationWithoutEviction

@LogMessage(level=INFO)
 @Message(value="Passivation configured without an eviction policy being selected. Only manually evicted entities will be passivated.",
         id=152)
void passivationWithoutEviction()

couldNotCompleteInjectedTransaction

@LogMessage(level=WARN)
 @Message(value="Could not complete injected transaction.",
         id=160)
void couldNotCompleteInjectedTransaction(@Cause
                                                                                                                                              Throwable t)

usingBatchModeTransactionManager

@LogMessage(level=INFO)
 @Message(value="Using a batchMode transaction manager",
         id=161)
void usingBatchModeTransactionManager()

couldNotInstantiateTransactionManager

@LogMessage(level=INFO)
 @Message(value="Could not instantiate transaction manager",
         id=162)
void couldNotInstantiateTransactionManager(@Cause
                                                                                                                                                 Exception e)

randomCacheModeSynonymsDeprecated

@LogMessage(level=WARN)
 @Message(value="%s has been deprecated as a synonym for %s. Use one of %s instead",
         id=177)
void randomCacheModeSynonymsDeprecated(String candidate,
                                                                                                                                                                     String mode,
                                                                                                                                                                     List<String> synonyms)

errorProcessing2pcCommitCommand

@LogMessage(level=ERROR)
 @Message(value="Error while processing a commit in a two-phase transaction",
         id=188)
void errorProcessing2pcCommitCommand(@Cause
                                                                                                                                                             Throwable e)

componentFailedToStop

@LogMessage(level=WARN)
 @Message(value="While stopping a cache or cache manager, one of its components failed to stop",
         id=189)
void componentFailedToStop(@Cause
                                                                                                                                                                     Throwable e)

failedLoadingKeysFromCacheStore

@LogMessage(level=WARN)
 @Message(value="Failed loading keys from cache store",
         id=194)
void failedLoadingKeysFromCacheStore(@Cause
                                                                                                                                      Throwable t)

rebalanceError

@LogMessage(level=ERROR)
 @Message(value="Error during rebalance for cache %s on node %s, topology id = %d",
         id=195)
void rebalanceError(String cacheName,
                                                                                                                                                  Address node,
                                                                                                                                                  int topologyId,
                                                                                                                                                  @Cause
                                                                                                                                                  Throwable cause)

failedToRecoverClusterState

@LogMessage(level=WARN)
 @Message(value="Failed to recover cluster state after the current node became the coordinator (or after merge), will retry",
         id=196)
void failedToRecoverClusterState(@Cause
                                                                                                                                                                                                        Throwable cause)

errorUpdatingMembersList

@LogMessage(level=WARN)
 @Message(value="Error updating cluster member list for view %d, waiting for next view",
         id=197)
void errorUpdatingMembersList(int viewId,
                                                                                                                                                                @Cause
                                                                                                                                                                Throwable cause)

cacheBackupsDataToSameSite

@LogMessage(level=TRACE)
 @Message(value="This cache is configured to backup to its own site (%s).",
         id=201)
void cacheBackupsDataToSameSite(String siteName)

warnXsiteBackupFailed

@LogMessage(level=WARN)
 @Message(value="Problems backing up data for cache %s to site %s: %s",
         id=202)
void warnXsiteBackupFailed(String cacheName,
                                                                                                                                            String key,
                                                                                                                                            Object value)

cannotRespondToRollback

@LogMessage(level=WARN)
 @Message(value="The rollback request for tx %s cannot be processed by the cache %s as this cache is not transactional!",
         id=203)
void cannotRespondToRollback(GlobalTransaction globalTransaction,
                                                                                                                                                                                                String cacheName)

cannotRespondToCommit

@LogMessage(level=WARN)
 @Message(value="The commit request for tx %s cannot be processed by the cache %s as this cache is not transactional!",
         id=204)
void cannotRespondToCommit(GlobalTransaction globalTransaction,
                                                                                                                                                                                            String cacheName)

tryingToBringOnlineNonexistentSite

@LogMessage(level=WARN)
 @Message(value="Trying to bring back an non-existent site (%s)!",
         id=205)
void tryingToBringOnlineNonexistentSite(String siteName)

couldNotInterruptThread

@LogMessage(level=WARN)
 @Message(value="Could not interrupt as no thread found for command uuid %s",
         id=207)
void couldNotInterruptThread(UUID id)

noLiveOwnersFoundForSegments

@LogMessage(level=ERROR)
 @Message(value="No live owners found for segments %s of cache %s. Excluded owners: %s",
         id=208)
void noLiveOwnersFoundForSegments(Collection<Integer> segments,
                                                                                                                                                                     String cacheName,
                                                                                                                                                                     Collection<Address> faultySources)

failedToRetrieveTransactionsForSegments

@LogMessage(level=WARN)
 @Message(value="Failed to retrieve transactions of cache %s from node %s, segments %s",
         id=209)
void failedToRetrieveTransactionsForSegments(String cacheName,
                                                                                                                                                                               Address source,
                                                                                                                                                                               Collection<Integer> segments,
                                                                                                                                                                               @Cause
                                                                                                                                                                               Throwable t)

failedToRequestSegments

@LogMessage(level=WARN)
 @Message(value="Failed to request state of cache %s from node %s, segments %s",
         id=210)
void failedToRequestSegments(String cacheName,
                                                                                                                                                       Address source,
                                                                                                                                                       Collection<Integer> segments,
                                                                                                                                                       @Cause
                                                                                                                                                       Throwable e)

unableToRemoveEntryAfterActivation

@LogMessage(level=WARN)
 @Message(value="Unable to remove entry under %s from cache store after activation",
         id=214)
void unableToRemoveEntryAfterActivation(Object key,
                                                                                                                                                                      @Cause
                                                                                                                                                                      Throwable e)

unknownMigrator

@Message(value="Unknown migrator %s",
         id=215)
Exception unknownMigrator(String migratorName)

entriesMigrated

@LogMessage(level=INFO)
 @Message(value="%d entries migrated to cache %s in %s",
         id=216)
void entriesMigrated(long count,
                                                                                                                       String name,
                                                                                                                       String prettyTime)

remoteException

@Message(value="Received exception from %s, see cause for remote stack trace",
         id=217)
RemoteException remoteException(Address sender,
                                                                                                                                @Cause
                                                                                                                                Throwable t)

timeoutWaitingUntilTransactionPrepared

@LogMessage(level=INFO)
 @Message(value="Timeout while waiting for the transaction validation. The command will not be processed. Transaction is %s",
         id=218)
void timeoutWaitingUntilTransactionPrepared(String globalTx)

customInterceptorMissingClass

@Message(value="Custom interceptor missing class",
         id=222)
CacheConfigurationException customInterceptorMissingClass()

suggestCustomInterceptorInheritance

@LogMessage(level=WARN)
 @Message(value="Custom interceptor \'%s\' does not extend BaseCustomInterceptor, which is recommended",
         id=223)
void suggestCustomInterceptorInheritance(String customInterceptorClassName)

multipleCustomInterceptorPositions

@Message(value="Custom interceptor \'%s\' specifies more than one position",
         id=224)
CacheConfigurationException multipleCustomInterceptorPositions(String customInterceptorClassName)

missingCustomInterceptorPosition

@Message(value="Custom interceptor \'%s\' doesn\'t specify a position",
         id=225)
CacheConfigurationException missingCustomInterceptorPosition(String customInterceptorClassName)

failedToRecoverCacheState

@LogMessage(level=ERROR)
 @Message(value="Failed to recover cache %s state after the current node became the coordinator",
         id=228)
void failedToRecoverCacheState(String cacheName,
                                                                                                                                                                           @Cause
                                                                                                                                                                           Throwable cause)

unexpectedInitialVersion

@Message(value="Unexpected initial version type (only NumericVersion instances supported): %s",
         id=229)
IllegalArgumentException unexpectedInitialVersion(String className)

rebalanceStartError

@LogMessage(level=ERROR)
 @Message(value="Failed to start rebalance for cache %s",
         id=230)
void rebalanceStartError(String cacheName,
                                                                                                                             @Cause
                                                                                                                             Throwable cause)

parserRootElementAlreadyRegistered

@LogMessage(level=WARN)
 @Message(value="Root element for %s already registered in ParserRegistry by %s. Cannot install %s.",
         id=234)
void parserRootElementAlreadyRegistered(QName qName,
                                                                                                                                                                                       String oldParser,
                                                                                                                                                                                       String newParser)

parserDoesNotDeclareNamespaces

@Message(value="Configuration parser %s does not declare any Namespace annotations",
         id=235)
CacheConfigurationException parserDoesNotDeclareNamespaces(String name)

directoryCannotBeCreated

@Message(value="Directory %s does not exist and cannot be created!",
         id=238)
CacheConfigurationException directoryCannotBeCreated(String path)

missingForeignExternalizer

@Message(value="Missing foreign externalizer with id=%s, either externalizer was not configured by client, or module lifecycle implementation adding externalizer was not loaded properly",
         id=242)
CacheException missingForeignExternalizer(int foreignId)

unknownExternalizerReaderIndex

@Message(value="Type of data read is unknown. Id=%d is not amongst known reader indexes.",
         id=243)
CacheException unknownExternalizerReaderIndex(int readerIndex)

advanceExternalizerTypeClassesUndefined

@Message(value="AdvancedExternalizer\'s getTypeClasses for externalizer %s must return a non-empty set",
         id=244)
CacheConfigurationException advanceExternalizerTypeClassesUndefined(String className)

duplicateExternalizerIdFound

@Message(value="Duplicate id found! AdvancedExternalizer id=%d for %s is shared by another externalizer (%s). Reader index is %d",
         id=245)
CacheConfigurationException duplicateExternalizerIdFound(int externalizerId,
                                                                                                                                                                                                             Class<?> typeClass,
                                                                                                                                                                                                             String otherExternalizer,
                                                                                                                                                                                                             int readerIndex)

internalExternalizerIdLimitExceeded

@Message(value="Internal %s externalizer is using an id(%d) that exceeded the limit. It needs to be smaller than %d",
         id=246)
CacheConfigurationException internalExternalizerIdLimitExceeded(AdvancedExternalizer<?> ext,
                                                                                                                                                                                                       int externalizerId,
                                                                                                                                                                                                       int maxId)

foreignExternalizerUsingNegativeId

@Message(value="Foreign %s externalizer is using a negative id(%d). Only positive id values are allowed.",
         id=247)
CacheConfigurationException foreignExternalizerUsingNegativeId(AdvancedExternalizer<?> ext,
                                                                                                                                                                                           int externalizerId)

loaderConfigurationDoesNotSpecifyLoaderClass

@Message(value="The cache loader configuration %s does not specify the loader class using @ConfigurationFor",
         id=249)
CacheConfigurationException loaderConfigurationDoesNotSpecifyLoaderClass(String className)

errorExecutingParallelStoreTask

@LogMessage(level=ERROR)
 @Message(value="Error executing parallel store task",
         id=252)
void errorExecutingParallelStoreTask(@Cause
                                                                                                                                      Throwable cause)

errorProcessingPrepare

@LogMessage(level=ERROR)
 @Message(value="Error while processing prepare",
         id=255)
void errorProcessingPrepare(@Cause
                                                                                                                        Throwable e)

errorAsyncStoreNotStopped

@LogMessage(level=ERROR)
 @Message(value="Async store executor did not stop properly",
         id=259)
void errorAsyncStoreNotStopped()

failedOutBoundTransferExecution

@LogMessage(level=ERROR)
 @Message(value="Failed to execute outbound transfer",
         id=261)
void failedOutBoundTransferExecution(@Cause
                                                                                                                                      Throwable e)

failedToEnlistTransactionXaAdapter

@LogMessage(level=ERROR)
 @Message(value="Failed to enlist TransactionXaAdapter to transaction",
         id=262)
void failedToEnlistTransactionXaAdapter(@Cause
                                                                                                                                                          Throwable e)

warnL1NotHavingReaperThread

@LogMessage(level=WARN)
 @Message(value="Not using an L1 invalidation reaper thread. This could lead to memory leaks as the requestors map may grow indefinitely!",
         id=264)
void warnL1NotHavingReaperThread()

unableToCreateInterceptor

@LogMessage(level=WARN)
 @Message(value="Problems creating interceptor %s",
         id=267)
void unableToCreateInterceptor(Class<?> type,
                                                                                                                            @Cause
                                                                                                                            Exception e)

unableToRollbackInvalidationsDuringPrepare

@LogMessage(level=WARN)
 @Message(value="Unable to broadcast invalidations as a part of the prepare phase. Rolling back.",
         id=268)
void unableToRollbackInvalidationsDuringPrepare(@Cause
                                                                                                                                                                                            Throwable e)

warnGridFSMetadataCacheRequiresSync

@LogMessage(level=WARN)
 @Message(value="Cache used for Grid metadata should be synchronous.",
         id=269)
void warnGridFSMetadataCacheRequiresSync()

warnCouldNotCommitLocalTx

@LogMessage(level=WARN)
 @Message(value="Could not commit local tx %s",
         id=270)
void warnCouldNotCommitLocalTx(Object transactionDescription,
                                                                                                                        @Cause
                                                                                                                        Throwable e)

warnCouldNotRollbackLocalTx

@LogMessage(level=WARN)
 @Message(value="Could not rollback local tx %s",
         id=271)
void warnCouldNotRollbackLocalTx(Object transactionDescription,
                                                                                                                            @Cause
                                                                                                                            Throwable e)

warnExceptionRemovingRecovery

@LogMessage(level=WARN)
 @Message(value="Exception removing recovery information",
         id=272)
void warnExceptionRemovingRecovery(@Cause
                                                                                                                                       Throwable e)

invalidConfigurationIndexingWithInvalidation

@Message(value="Indexing can not be enabled on caches in Invalidation mode",
         id=273)
CacheConfigurationException invalidConfigurationIndexingWithInvalidation()

persistenceWithoutCacheLoaderInterceptor

@LogMessage(level=ERROR)
 @Message(value="Persistence enabled without any CacheLoaderInterceptor in InterceptorChain!",
         id=274)
void persistenceWithoutCacheLoaderInterceptor()

persistenceWithoutCacheWriteInterceptor

@LogMessage(level=ERROR)
 @Message(value="Persistence enabled without any CacheWriteInterceptor in InterceptorChain!",
         id=275)
void persistenceWithoutCacheWriteInterceptor()

keyMigrationFailed

@LogMessage(level=WARN)
 @Message(value="Could not migrate key %s",
         id=277)
void keyMigrationFailed(String key,
                                                                                                             @Cause
                                                                                                             Throwable cause)

invalidConfigurationIndexingWithoutModule

@Message(value="Indexing can only be enabled if infinispan-query.jar is available on your classpath, and this jar has not been detected.",
         id=278)
CacheConfigurationException invalidConfigurationIndexingWithoutModule()

errorReadingFileStore

@Message(value="Failed to read stored entries from file. Error in file %s at offset %d",
         id=279)
PersistenceException errorReadingFileStore(String path,
                                                                                                                                                     long offset)

exceptionInvokingListener

@Message(value="Caught exception [%s] while invoking method [%s] on listener instance: %s",
         id=280)
CacheListenerException exceptionInvokingListener(String name,
                                                                                                                                                              Method m,
                                                                                                                                                              Object target,
                                                                                                                                                              @Cause
                                                                                                                                                              Throwable cause)

thirdPartySuspected

@Message(value="%s reported that a third node was suspected, see cause for info on the node that was suspected",
         id=281)
SuspectException thirdPartySuspected(Address sender,
                                                                                                                                                                       @Cause
                                                                                                                                                                       SuspectException e)

invocationBatchingNeedsTransactionalCache

@Message(value="Cannot enable Invocation Batching when the Transaction Mode is NON_TRANSACTIONAL, set the transaction mode to TRANSACTIONAL",
         id=282)
CacheConfigurationException invocationBatchingNeedsTransactionalCache()

invocationBatchingCannotBeRecoverable

@Message(value="A cache configured with invocation batching can\'t have recovery enabled",
         id=283)
CacheConfigurationException invocationBatchingCannotBeRecoverable()

clusterListenerInstallationFailure

@LogMessage(level=WARN)
 @Message(value="Problem encountered while installing cluster listener",
         id=284)
void clusterListenerInstallationFailure(@Cause
                                                                                                                                                          Throwable cause)

unsuccessfulResponseForClusterListeners

@LogMessage(level=WARN)
 @Message(value="Issue when retrieving cluster listeners from %s response was %s",
         id=285)
void unsuccessfulResponseForClusterListeners(Address address,
                                                                                                                                                                         Response response)

exceptionDuringClusterListenerRetrieval

@LogMessage(level=WARN)
 @Message(value="Issue when retrieving cluster listeners from %s",
         id=286)
void exceptionDuringClusterListenerRetrieval(Address address,
                                                                                                                                                         @Cause
                                                                                                                                                         Throwable cause)

unauthorizedAccess

@Message(value="Unauthorized access: subject \'%s\' lacks \'%s\' permission",
         id=287)
SecurityException unauthorizedAccess(String subject,
                                                                                                                                    String permission)

invalidPrincipalRoleMapper

@Message(value="A principal-to-role mapper has not been specified",
         id=288)
CacheConfigurationException invalidPrincipalRoleMapper()

unableToSendXSiteState

@LogMessage(level=WARN)
 @Message(value="Unable to send X-Site state chunk to \'%s\'.",
         id=289)
void unableToSendXSiteState(String site,
                                                                                                                                     @Cause
                                                                                                                                     Throwable cause)

unableToApplyXSiteState

@LogMessage(level=WARN)
 @Message(value="Unable to apply X-Site state chunk.",
         id=291)
void unableToApplyXSiteState(@Cause
                                                                                                                             Throwable cause)

unrecognizedAttribute

@LogMessage(level=WARN)
 @Message(value="Unrecognized attribute \'%s\'. Please check your configuration. Ignoring!",
         id=292)
void unrecognizedAttribute(String property)

ignoreXmlAttribute

@LogMessage(level=INFO)
 @Message(value="Ignoring XML attribute %s at [%d,%d], please remove from configuration file",
         id=293)
void ignoreXmlAttribute(Object attribute,
                                                                                                                                                                int line,
                                                                                                                                                                int column)

ignoreXmlElement

@LogMessage(level=INFO)
 @Message(value="Ignoring XML element %s at [%d,%d], please remove from configuration file",
         id=294)
void ignoreXmlElement(Object element,
                                                                                                                                                            int line,
                                                                                                                                                            int column)

undefinedThreadPoolName

@Message(value="No thread pool with name %s found",
         id=295)
CacheConfigurationException undefinedThreadPoolName(String name)

invalidPermission

@Message(value="Attempt to add a %s permission to a SecurityPermissionCollection",
         id=296)
IllegalArgumentException invalidPermission(Permission permission)

readOnlyPermissionCollection

@Message(value="Attempt to add a permission to a read-only SecurityPermissionCollection",
         id=297)
SecurityException readOnlyPermissionCollection()

authorizationEnabledWithoutSecurityManager

@LogMessage(level=DEBUG)
 @Message(value="Using internal security checker",
         id=298)
void authorizationEnabledWithoutSecurityManager()

unableToAcquireLock

@Message(value="Unable to acquire lock after %s for key %s and requestor %s. Lock is held by %s",
         id=299)
TimeoutException unableToAcquireLock(String timeout,
                                                                                                                                                        Object key,
                                                                                                                                                        Object requestor,
                                                                                                                                                        Object owner)

exceptionProcessingEntryRetrievalValues

@Message(value="There was an exception while processing retrieval of entry values",
         id=300)
CacheException exceptionProcessingEntryRetrievalValues(@Cause
                                                                                                                                                            Throwable cause)

unsuccessfulResponseRetrievingTransactionsForSegments

@LogMessage(level=WARN)
 @Message(value="Issue when retrieving transactions from %s, response was %s",
         id=302)
void unsuccessfulResponseRetrievingTransactionsForSegments(Address address,
                                                                                                                                                                                   Response response)

ambiguousConfigurationFiles

@LogMessage(level=WARN)
 @Message(value="More than one configuration file with specified name on classpath. The first one will be used:\n %s",
         id=304)
void ambiguousConfigurationFiles(String files)

partitionDegraded

@Message(value="Cluster is operating in degraded mode because of node failures.",
         id=305)
AvailabilityException partitionDegraded()

degradedModeKeyUnavailable

@Message(value="Key \'%s\' is not available. Not all owners are in this partition",
         id=306)
AvailabilityException degradedModeKeyUnavailable(Object key)

clearDisallowedWhilePartitioned

@Message(value="Cannot clear when the cluster is partitioned",
         id=307)
AvailabilityException clearDisallowedWhilePartitioned()

rebalancingEnabled

@LogMessage(level=INFO)
 @Message(value="Rebalancing enabled",
         id=308)
void rebalancingEnabled()

rebalancingSuspended

@LogMessage(level=INFO)
 @Message(value="Rebalancing suspended",
         id=309)
void rebalancingSuspended()

startingRebalancePhase

@LogMessage(level=DEBUG)
 @Message(value="Starting new rebalance phase for cache %s, topology %s",
         id=310)
void startingRebalancePhase(String cacheName,
                                                                                                                                                CacheTopology cacheTopology)

stopOrderIgnored

@LogMessage(level=WARN)
 @Message(value="Cyclic dependency detected between caches, stop order ignored",
         id=321)
void stopOrderIgnored()

failedToRestartXSiteStateTransfer

@LogMessage(level=WARN)
 @Message(value="Unable to re-start x-site state transfer to site %s",
         id=322)
void failedToRestartXSiteStateTransfer(String siteName,
                                                                                                                                                       @Cause
                                                                                                                                                       Throwable cause)

cacheIsTerminated

@Message(value="%s is in \'%s\' state and so it does not accept new invocations. Either restart it or recreate the cache container.",
         id=323)
IllegalLifecycleStateException cacheIsTerminated(String cacheName,
                                                                                                                                                                                                        String state)

cacheIsStopping

@Message(value="%s is in \'STOPPING\' state and this is an invocation not belonging to an on-going transaction, so it does not accept new invocations. Either restart it or recreate the cache container.",
         id=324)
IllegalLifecycleStateException cacheIsStopping(String cacheName)

creatingTmpCacheTimedOut

@Message(value="Creating tmp cache %s timed out waiting for rebalancing to complete on node %s ",
         id=325)
RuntimeException creatingTmpCacheTimedOut(String cacheName,
                                                                                                                                                             Address address)

remoteTransactionTimeout

@LogMessage(level=WARN)
 @Message(value="Remote transaction %s timed out. Rolling back after %d ms",
         id=326)
void remoteTransactionTimeout(GlobalTransaction gtx,
                                                                                                                                                    long ageMilliSeconds)

unsupportedConfiguration

@Message(value="Cannot find a parser for element \'%s\' in namespace \'%s\'. Check that your configuration is up-to date for Infinispan \'%s\' and if you have the proper dependency in the classpath",
         id=327)
CacheConfigurationException unsupportedConfiguration(String element,
                                                                                                                                                                                                                                                                              String namespaceUri,
                                                                                                                                                                                                                                                                              String version)

rebalancePhaseConfirmedOnNode

@LogMessage(level=DEBUG)
 @Message(value="Rebalance phase %s confirmed for cache %s on node %s, topology id = %d",
         id=328)
void rebalancePhaseConfirmedOnNode(CacheTopology.Phase phase,
                                                                                                                                                                       String cacheName,
                                                                                                                                                                       Address node,
                                                                                                                                                                       int topologyId)

errorReadingRebalancingStatus

@LogMessage(level=WARN)
 @Message(value="Unable to read rebalancing status from coordinator %s",
         id=329)
void errorReadingRebalancingStatus(Address coordinator,
                                                                                                                                                     @Cause
                                                                                                                                                     Throwable t)

unableToInvokeListenerMethod

@LogMessage(level=WARN)
 @Message(value="Unable to invoke method %s on Object instance %s ",
         id=331)
void unableToInvokeListenerMethod(Method m,
                                                                                                                                                Object target,
                                                                                                                                                @Cause
                                                                                                                                                Throwable e)

twoPhaseCommitAsyncBackup

@Message(value="Two-phase commit can only be used with synchronous backup strategy.",
         id=335)
CacheConfigurationException twoPhaseCommitAsyncBackup()

finishedRebalance

@LogMessage(level=DEBUG)
 @Message(value="Finished rebalance for cache %s, topology %s",
         id=336)
void finishedRebalance(String cacheName,
                                                                                                                                 CacheTopology topology)

backupMissingSite

@Message(value="The \'site\' must be specified!",
         id=337)
CacheConfigurationException backupMissingSite()

missingBackupFailurePolicyClass

@Message(value="It is required to specify a \'failurePolicyClass\' when using a custom backup failure policy!",
         id=338)
CacheConfigurationException missingBackupFailurePolicyClass()

backupForNullCache

@Message(value="Null name not allowed (use \'defaultRemoteCache()\' in case you want to specify the default cache name).",
         id=339)
CacheConfigurationException backupForNullCache()

backupForMissingParameters

@Message(value="Both \'remoteCache\' and \'remoteSite\' must be specified for a backup\'!",
         id=340)
CacheConfigurationException backupForMissingParameters()

missingTransportConfiguration

@Message(value="Must have a transport set in the global configuration in order to define a clustered cache",
         id=343)
CacheConfigurationException missingTransportConfiguration()

invalidReaperWakeUpInterval

@Message(value="reaperWakeUpInterval must be >= 0, we got %d",
         id=344)
CacheConfigurationException invalidReaperWakeUpInterval(long timeout)

invalidCompletedTxTimeout

@Message(value="completedTxTimeout must be >= 0, we got %d",
         id=345)
CacheConfigurationException invalidCompletedTxTimeout(long timeout)

l1OnlyForDistributedCache

@Message(value="Enabling the L1 cache is only supported when using DISTRIBUTED as a cache mode.  Your cache mode is set to %s",
         id=350)
CacheConfigurationException l1OnlyForDistributedCache(String cacheMode)

l1InvalidLifespan

@Message(value="Using a L1 lifespan of 0 or a negative value is meaningless",
         id=351)
CacheConfigurationException l1InvalidLifespan()

l1NotValidWithExpirationEviction

@Message(value="Enabling the L1 cache is not supported when using EXCEPTION based eviction.",
         id=352)
CacheConfigurationException l1NotValidWithExpirationEviction()

interceptorClassAndInstanceDefined

@Message(value="Cannot define both interceptor class (%s) and interceptor instance (%s)",
         id=354)
CacheConfigurationException interceptorClassAndInstanceDefined(String customInterceptorClassName,
                                                                                                                                                                          String customInterceptor)

unableToInstantiateClass

@Message(value="Unable to instantiate loader/writer instance for StoreConfiguration %s",
         id=355)
CacheConfigurationException unableToInstantiateClass(Class<?> storeConfigurationClass)

xaResourceEndFailed

@LogMessage(level=ERROR)
 @Message(value="end() failed for %s",
         id=357)
void xaResourceEndFailed(XAResource resource,
                                                                                                          @Cause
                                                                                                          Throwable t)

existingConfigForInternalCache

@Message(value="A cache configuration named %s already exists. This cannot be configured externally by the user.",
         id=358)
CacheConfigurationException existingConfigForInternalCache(String name)

degradedModeKeysUnavailable

@Message(value="Keys \'%s\' are not available. Not all owners are in this partition",
         id=359)
AvailabilityException degradedModeKeysUnavailable(Collection<?> keys)

evictionExecutorDeprecated

@LogMessage(level=WARN)
 @Message(value="The xml element eviction-executor has been deprecated and replaced by expiration-executor, please update your configuration file.",
         id=360)
void evictionExecutorDeprecated()

remoteTransactionAlreadyRolledBack

@Message(value="Cannot commit remote transaction %s as it was already rolled back",
         id=361)
CacheException remoteTransactionAlreadyRolledBack(GlobalTransaction gtx)

remoteTransactionStatusMissing

@Message(value="Could not find status for remote transaction %s, please increase transaction.completedTxTimeout",
         id=362)
TimeoutException remoteTransactionStatusMissing(GlobalTransaction gtx)

noFilterIndexingServiceProviderFound

@LogMessage(level=WARN)
 @Message(value="No filter indexing service provider found for indexed filter of type %s",
         id=363)
void noFilterIndexingServiceProviderFound(String filterClassName)

clusterListenerRegisteredWithOnlyPreEvents

@Message(value="Attempted to register cluster listener of class %s, but listener is annotated as only observing pre events!",
         id=364)
CacheException clusterListenerRegisteredWithOnlyPreEvents(Class<?> listenerClass)

jgroupsConfigurationNotFound

@Message(value="Could not find the specified JGroups configuration file \'%s\'",
         id=365)
CacheConfigurationException jgroupsConfigurationNotFound(String cfg)

unableToAddNullCustomStore

@Message(value="Unable to add a \'null\' Custom Cache Store",
         id=366)
IllegalArgumentException unableToAddNullCustomStore()

configurationInUse

@Message(value="Cannot remove cache configuration \'%s\' because it is in use",
         id=371)
IllegalStateException configurationInUse(String configurationName)

statisticsEnabledNotAvailable

@Message(value="Statistics are enabled while attribute \'available\' is set to false.",
         id=372)
CacheConfigurationException statisticsEnabledNotAvailable()

templateConfigurationStartAttempt

@Message(value="Attempted to start a cache using configuration template \'%s\'",
         id=373)
CacheConfigurationException templateConfigurationStartAttempt(String cacheName)

undeclaredConfiguration

@Message(value="No such template \'%s\' when declaring \'%s\'",
         id=374)
CacheConfigurationException undeclaredConfiguration(String template,
                                                                                                                                     String name)

noConfiguration

@Message(value="Cannot use configuration \'%s\' as a template",
         id=375)
CacheConfigurationException noConfiguration(String extend)

interceptorStackNotSupported

@Message(value="Interceptor stack is not supported in simple cache",
         id=376)
UnsupportedOperationException interceptorStackNotSupported()

lockOperationsNotSupported

@Message(value="Explicit lock operations are not supported in simple cache",
         id=377)
UnsupportedOperationException lockOperationsNotSupported()

invocationBatchingNotEnabled

@Message(value="Invocation batching not enabled in current configuration! Please enable it.",
         id=378)
CacheConfigurationException invocationBatchingNotEnabled()

notSupportedInSimpleCache

@Message(value="This configuration is not supported for simple cache",
         id=381)
CacheConfigurationException notSupportedInSimpleCache()

missingGlobalStatePersistentLocation

@LogMessage(level=WARN)
 @Message(value="Global state persistence was enabled without specifying a location",
         id=382)
void missingGlobalStatePersistentLocation()

unableToBroadcastInvalidation

@Message(value="Unable to broadcast invalidation messages",
         id=384)
RuntimeException unableToBroadcastInvalidation(@Cause
                                                                                                                            Throwable e)

failedReadingPersistentState

@Message(value="Failed to read persisted state from file %s. Aborting.",
         id=386)
CacheConfigurationException failedReadingPersistentState(@Cause
                                                                                                                                                   IOException e,
                                                                                                                                                   File stateFile)

failedWritingGlobalState

@Message(value="Failed to write state to file %s.",
         id=387)
CacheConfigurationException failedWritingGlobalState(@Cause
                                                                                                                          IOException e,
                                                                                                                          File stateFile)

nonWritableStateFile

@Message(value="The state file %s is not writable. Aborting.",
         id=388)
CacheConfigurationException nonWritableStateFile(File stateFile)

globalStateLoad

@LogMessage(level=INFO)
 @Message(value="Loaded global state, version=%s timestamp=%s",
         id=389)
void globalStateLoad(String version,
                                                                                                                              String timestamp)

globalStateWrite

@LogMessage(level=INFO)
 @Message(value="Persisted state, version=%s timestamp=%s",
         id=390)
void globalStateWrite(String version,
                                                                                                                           String timestamp)

recoveryNotSupportedWithNonTxCache

@Message(value="Recovery not supported with non transactional cache",
         id=391)
CacheConfigurationException recoveryNotSupportedWithNonTxCache()

recoveryNotSupportedWithSynchronization

@Message(value="Recovery not supported with Synchronization",
         id=392)
CacheConfigurationException recoveryNotSupportedWithSynchronization()

transactionNotificationsDisabled

@LogMessage(level=INFO)
 @Message(value="Transaction notifications are disabled.  This prevents cluster listeners from working properly!",
         id=395)
void transactionNotificationsDisabled()

ignoringUnsolicitedState

@LogMessage(level=DEBUG)
 @Message(value="Received unsolicited state from node %s for segment %d of cache %s",
         id=396)
void ignoringUnsolicitedState(Address node,
                                                                                                                                                              int segment,
                                                                                                                                                              String cacheName)

persistentConsistentHashMismatch

@Message(value="CH Factory \'%s\' cannot restore a persisted CH of class \'%s\'",
         id=398)
IllegalStateException persistentConsistentHashMismatch(String hashFactory,
                                                                                                                                                          String consistentHashClass)

timeoutWaitingForInitialNodes

@Message(value="Timeout while waiting for %d members in cluster. Last view had %s",
         id=399)
TimeoutException timeoutWaitingForInitialNodes(int initialClusterSize,
                                                                                                                                                    List<?> members)

remoteNodeSuspected

@Message(value="Node %s was suspected",
         id=400)
SuspectException remoteNodeSuspected(Address address)

remoteNodeTimedOut

@Message(value="Node %s timed out, time : %s %s",
         id=401)
TimeoutException remoteNodeTimedOut(Address address,
                                                                                                       long time,
                                                                                                       TimeUnit unit)

coordinatorTimeoutWaitingForView

@Message(value="Timeout waiting for view %d. Current view is %d, current status is %s",
         id=402)
TimeoutException coordinatorTimeoutWaitingForView(int expectedViewId,
                                                                                                                                                           int currentViewId,
                                                                                                                                                           Object clusterManagerStatus)

noIndexableClassesDefined

@LogMessage(level=WARN)
 @Message(value="No indexable classes were defined for this indexed cache; switching to autodetection (support for autodetection will be removed in Infinispan 11).",
         id=403)
void noIndexableClassesDefined()

failedInvokingCacheManagerListener

@LogMessage(level=ERROR)
 @Message(value="Caught exception while invoking a cache manager listener!",
         id=405)
void failedInvokingCacheManagerListener(@Cause
                                                                                                                                                               Throwable e)

ignoredReplicationQueueAttribute

@LogMessage(level=WARN)
 @Message(value="The replication queue is no longer supported since version 9.0. Attribute %s on line %d will be ignored.",
         id=406)
void ignoredReplicationQueueAttribute(String attributeName,
                                                                                                                                                                                                           int line)

extraneousMembersJoinRestoredCache

@Message(value="Extraneous members %s are attempting to join cache %s, as they were not members of the persisted state",
         id=407)
CacheJoinException extraneousMembersJoinRestoredCache(List<Address> extraneousMembers,
                                                                                                                                                                                                String cacheName)

nodeWithPersistentStateJoiningClusterWithoutState

@Message(value="Node %s with persistent state attempting to join cache %s on cluster without state",
         id=408)
CacheJoinException nodeWithPersistentStateJoiningClusterWithoutState(Address joiner,
                                                                                                                                                                                           String cacheName)

nodeWithoutPersistentStateJoiningCacheWithState

@Message(value="Node %s without persistent state attempting to join cache %s on cluster with state",
         id=409)
CacheJoinException nodeWithoutPersistentStateJoiningCacheWithState(Address joiner,
                                                                                                                                                                                         String cacheName)

nodeWithIncompatibleStateJoiningCache

@Message(value="Node %s attempting to join cache %s with incompatible state",
         id=410)
CacheJoinException nodeWithIncompatibleStateJoiningCache(Address joiner,
                                                                                                                                                        String cacheName)

unknownTransactionConfiguration

@Message(value="Cannot determine a synthetic transaction configuration from mode=%s, xaEnabled=%s, recoveryEnabled=%s, batchingEnabled=%s",
         id=412)
CacheConfigurationException unknownTransactionConfiguration(TransactionMode mode,
                                                                                                                                                                                                                         boolean xaEnabled,
                                                                                                                                                                                                                         boolean recoveryEnabled,
                                                                                                                                                                                                                         boolean batchingEnabled)

unableToInstantiateSerializer

@Message(value="Unable to instantiate serializer for %s",
         id=413)
CacheConfigurationException unableToInstantiateSerializer(Class<?> storeConfigurationClass)

globalSecurityAuthShouldBeEnabled

@Message(value="Global security authorization should be enabled if cache authorization enabled.",
         id=414)
CacheConfigurationException globalSecurityAuthShouldBeEnabled()

ignoredAttribute

@LogMessage(level=WARN)
 @Message(value="The %s is no longer supported since version %s. Attribute %s on line %d will be ignored.",
         id=415)
void ignoredAttribute(String componentName,
                                                                                                                                                                           String version,
                                                                                                                                                                           String attributeName,
                                                                                                                                                                           int line)

transactionalStoreInNonTransactionalCache

@Message(value="It is not possible for a store to be transactional in a non-transactional cache. ",
         id=417)
CacheConfigurationException transactionalStoreInNonTransactionalCache()

transactionalStoreInPassivatedCache

@Message(value="It is not possible for a store to be transactional when passivation is enabled. ",
         id=418)
CacheConfigurationException transactionalStoreInPassivatedCache()

evictionDisabled

@LogMessage(level=WARN)
 @Message(value="Eviction of an entry invoked without an explicit eviction strategy for cache %s",
         id=419)
void evictionDisabled(String cacheName)

attributeNotAllowedInInvalidationMode

@Message(value="Cannot enable \'%s\' in invalidation caches!",
         id=420)
CacheConfigurationException attributeNotAllowedInInvalidationMode(String attributeName)

viewHandlingError

@LogMessage(level=ERROR)
 @Message(value="Error while handling view %s",
         id=421)
void viewHandlingError(int viewId,
                                                                                                                 @Cause
                                                                                                                 Throwable t)

failedWaitingForTopology

@Message(value="Failed waiting for topology %d",
         id=422)
TimeoutException failedWaitingForTopology(int requestTopologyId)

duplicateExternalizerIdFound

@Message(value="Duplicate id found! AdvancedExternalizer id=%d is shared by another externalizer (%s)",
         id=423)
CacheConfigurationException duplicateExternalizerIdFound(int externalizerId,
                                                                                                                                                                                  String otherExternalizer)

invalidEvictionSize

@Message(value="Memory eviction is enabled, please specify a maximum size or count greater than zero",
         id=424)
CacheConfigurationException invalidEvictionSize()

timeoutWaitingForAcks

@Message(value="Timeout after %s waiting for acks. Id=%s",
         id=427)
TimeoutException timeoutWaitingForAcks(String timeout,
                                                                                                                   long id)

elementDeprecatedUseOther

@LogMessage(level=WARN)
 @Message(value="The \'%s\' element has been deprecated. Please use the \'%s\' element instead",
         id=428)
void elementDeprecatedUseOther(Element element,
                                                                                                                                                                         Element other)

writeSkewOnRead

@Message(value="On key %s previous read version (%s) is different from currently read version (%s)",
         id=429)
WriteSkewException writeSkewOnRead(@Param
                                                                                                                                                         Object key,
                                                                                                                                                         Object key2,
                                                                                                                                                         EntryVersion lastVersion,
                                                                                                                                                         EntryVersion remoteVersion)

nonSharedStoreConfiguredAsShared

@Message(value="%s cannot be shared",
         id=430)
CacheConfigurationException nonSharedStoreConfiguredAsShared(String storeType)

missingDefaultCacheDeclaration

@Message(value="Missing configuration for default cache \'%s\' declared on container",
         id=432)
CacheConfigurationException missingDefaultCacheDeclaration(String defaultCache)

noDefaultCache

@Message(value="A default cache has been requested, but no cache has been set as default for this container",
         id=433)
CacheConfigurationException noDefaultCache()

defaultCacheConfigurationWithoutName

@Message(value="Cache manager initialized with a default cache configuration but without a name for it. Set it in the GlobalConfiguration.",
         id=435)
CacheConfigurationException defaultCacheConfigurationWithoutName()

noSuchCacheConfiguration

@Message(value="Cache \'%s\' has been requested, but no matching cache configuration exists",
         id=436)
CacheConfigurationException noSuchCacheConfiguration(String name)

warnConfigurationForAnnotationMissing

@LogMessage(level=WARN)
 @Message(value="Unable to validate %s with the implementing store as the @ConfigurationFor annotation is missing",
         id=437)
void warnConfigurationForAnnotationMissing(String name)

duplicateCacheName

@Message(value="Cache with name %s is defined more than once!",
         id=438)
CacheConfigurationException duplicateCacheName(String name)

receivedXSiteClusterView

@LogMessage(level=INFO)
 @Message(value="Received new x-site view: %s",
         id=439)
void receivedXSiteClusterView(Collection<String> view)

errorSendingResponse

@LogMessage(level=ERROR)
 @Message(value="Error sending response for request %d@%s, command %s",
         id=440)
void errorSendingResponse(long requestId,
                                                                                                                                            org.jgroups.Address origin,
                                                                                                                                            ReplicableCommand command)

unsupportedAsyncCacheMode

@Message(value="Unsupported async cache mode \'%s\' for transactional caches",
         id=441)
CacheConfigurationException unsupportedAsyncCacheMode(CacheMode cacheMode)

clusteredTransactionalStoreMustBeShared

@Message(value="Invalid cache loader configuration for \'%s\'. In order for a cache loader to be transactional, it must also be shared.",
         id=443)
CacheConfigurationException clusteredTransactionalStoreMustBeShared(String simpleName)

transactionalStoreCannotBeAsync

@Message(value="Invalid cache loader configuration for \'%s\'. A cache loader cannot be both Asynchronous and transactional.",
         id=444)
CacheConfigurationException transactionalStoreCannotBeAsync(String simpleName)

onlyOneFetchPersistentStoreAllowed

@Message(value="At most one store can be set to \'fetchPersistentState\'!",
         id=445)
CacheConfigurationException onlyOneFetchPersistentStoreAllowed()

multipleSitesWithSameName

@Message(value="Multiple sites with name \'%s\' are configured. That is not allowed!",
         id=446)
CacheConfigurationException multipleSitesWithSameName(String site)

siteMustBeInBackups

@Message(value="The site \'%s\' must be defined within the set of backups!",
         id=447)
CacheConfigurationException siteMustBeInBackups(String site)

awaitInitialTransferOnlyForDistOrRepl

@Message(value="\'awaitInitialTransfer\' can be enabled only if cache mode is distributed or replicated.",
         id=448)
CacheConfigurationException awaitInitialTransferOnlyForDistOrRepl()

invalidXSiteStateTransferTimeout

@Message(value="XSite state transfer timeout must be higher or equals than 1 (one).",
         id=449)
CacheConfigurationException invalidXSiteStateTransferTimeout()

invalidXSiteStateTransferWaitTime

@Message(value="XSite state transfer waiting time between retries must be higher or equals than 1 (one).",
         id=450)
CacheConfigurationException invalidXSiteStateTransferWaitTime()

timeoutWaitingForView

@Message(value="Timed out waiting for view %d, current view is %d",
         id=451)
TimeoutException timeoutWaitingForView(int expectedViewId,
                                                                                                                            int currentViewId)

topologyUpdateError

@LogMessage(level=ERROR)
 @Message(value="Failed to update topology for cache %s",
         id=452)
void topologyUpdateError(String cacheName,
                                                                                                                             @Cause
                                                                                                                             Throwable cause)

configAlreadyDefined

@Message(value="Attempt to define configuration for cache %s which already exists",
         id=453)
CacheConfigurationException configAlreadyDefined(String cacheName)

transactionCleanupError

@LogMessage(level=ERROR)
 @Message(value="Failure during leaver transactions cleanup",
         id=455)
void transactionCleanupError(@Cause
                                                                                                                                     Throwable e)

invalidEncodingClass

@Message(value="Class %s should be a subclass of %s",
         id=461)
CacheException invalidEncodingClass(Class<?> configured,
                                                                                                           Class<?> required)

getConflictsAlreadyInProgress

@Message(value="ConflictManager.getConflicts() already in progress",
         id=462)
IllegalStateException getConflictsAlreadyInProgress()

getConflictsStateTransferInProgress

@Message(value="Unable to retrieve conflicts as StateTransfer is currently in progress for cache \'%s\'",
         id=463)
IllegalStateException getConflictsStateTransferInProgress(String cacheName)

partitionHandlingConfigurationEnabledDeprecated

@LogMessage(level=WARN)
 @Message(value="The partition handling \'enabled\' attribute has been deprecated. Please update your configuration to use \'when-split\' instead",
         id=464)
void partitionHandlingConfigurationEnabledDeprecated()

exceptionDuringConflictResolution

@LogMessage(level=WARN)
 @Message(value="Exception encountered when trying to resolve conflict on Keys \'%s\': %s",
         id=466)
void exceptionDuringConflictResolution(Object key,
                                                                                                                                                                            Throwable t)

scatteredCacheNeedsSingleOwner

@Message(value="Scattered cache supports only single owner.",
         id=467)
CacheConfigurationException scatteredCacheNeedsSingleOwner()

invalidationBatchSizeAppliesOnNonScattered

@Message(value="Invalidation batch size configuration options applies only to scattered caches.",
         id=468)
CacheConfigurationException invalidationBatchSizeAppliesOnNonScattered()

scatteredCacheIsNonTransactional

@Message(value="Scattered cache does not support transactional mode.",
         id=469)
CacheConfigurationException scatteredCacheIsNonTransactional()

failedConfirmingRevokedSegments

@LogMessage(level=ERROR)
 @Message(value="Failed confirming revoked segments. State transfer cannot continue.",
         id=470)
void failedConfirmingRevokedSegments(@Cause
                                                                                                                                                                      Throwable t)

failedProcessingValuesDuringRebalance

@LogMessage(level=ERROR)
 @Message(value="Failed processing values received from remote node during rebalance.",
         id=471)
void failedProcessingValuesDuringRebalance(@Cause
                                                                                                                                                                             Throwable t)

cacheManagerIsStopping

@Message(value="Cache manager is stopping",
         id=472)
IllegalLifecycleStateException cacheManagerIsStopping()

invalidMessageType

@LogMessage(level=ERROR)
 @Message(value="Invalid message type %s received from %s",
         id=473)
void invalidMessageType(int messageType,
                                                                                                                              org.jgroups.Address origin)

errorProcessingRequest

@LogMessage(level=ERROR)
 @Message(value="Error processing request %d@%s",
         id=474)
void errorProcessingRequest(long requestId,
                                                                                                                        org.jgroups.Address origin,
                                                                                                                        @Cause
                                                                                                                        Throwable t)

errorProcessingResponse

@LogMessage(level=ERROR)
 @Message(value="Error processing response for request %d from %s",
         id=475)
void errorProcessingResponse(long requestId,
                                                                                                                                           org.jgroups.Address sender,
                                                                                                                                           @Cause
                                                                                                                                           Throwable t)

requestTimedOut

@Message(value="Timed out waiting for responses for request %d from %s",
         id=476)
TimeoutException requestTimedOut(long requestId,
                                                                                                                           String targetsWithoutResponses)

xsiteAdminOperationError

@LogMessage(level=ERROR)
 @Message(value="Unable to perform operation %s for site %s",
         id=477)
void xsiteAdminOperationError(String operationName,
                                                                                                                                      String siteName,
                                                                                                                                      @Cause
                                                                                                                                      Throwable t)

unableToFindRemoteSiteTransaction

@Message(value="Couldn\'t find a local transaction corresponding to remote site transaction %s",
         id=478)
CacheException unableToFindRemoteSiteTransaction(GlobalTransaction globalTransaction)

unableToFindLocalTransactionFromRemoteSiteTransaction

@Message(value="LocalTransaction not found but present in the tx table for remote site transaction %s",
         id=479)
IllegalStateException unableToFindLocalTransactionFromRemoteSiteTransaction(GlobalTransaction globalTransaction)

ignoringInvalidateVersionsFromOldTopology

@LogMessage(level=WARN)
 @Message(value="Ignoring versions invalidation from topology %d, current topology is %d",
         id=480)
void ignoringInvalidateVersionsFromOldTopology(int invalidationTopology,
                                                                                                                                                                                   int currentTopologyId)

remoteTransactionOriginatorNotInView

@Message(value="Cannot create remote transaction %s, the originator is not in the cluster view",
         id=481)
CacheException remoteTransactionOriginatorNotInView(GlobalTransaction gtx)

remoteTransactionAlreadyCompleted

@Message(value="Cannot create remote transaction %s, already completed",
         id=482)
CacheException remoteTransactionAlreadyCompleted(GlobalTransaction gtx)

wildcardsNotAllowedInCacheNames

@Message(value="Wildcards not allowed in cache names: \'%s\'",
         id=484)
CacheConfigurationException wildcardsNotAllowedInCacheNames(String name)

configurationNameMatchesMultipleWildcards

@Message(value="Configuration \'%s\' matches multiple wildcard templates",
         id=485)
CacheConfigurationException configurationNameMatchesMultipleWildcards(String name)

duplicateIdWrapper

@Message(value="Cannot register Wrapper: duplicate Id %d",
         id=486)
EncodingException duplicateIdWrapper(byte id)

wrapperClassNotFound

@Message(value="Wrapper with class \'%s\' not found",
         id=487)
EncodingException wrapperClassNotFound(Class<?> wrapperClass)

wrapperIdNotFound

@Message(value="Wrapper with Id %d not found",
         id=488)
EncodingException wrapperIdNotFound(byte id)

duplicateIdEncoder

@Message(value="Cannot register Encoder: duplicate Id %d",
         id=489)
EncodingException duplicateIdEncoder(short id)

encoderClassNotFound

@Message(value="Encoder with class \'%s\' not found",
         id=490)
EncodingException encoderClassNotFound(Class<?> wrapperClass)

encoderIdNotFound

@Message(value="Encoder with Id %d not found",
         id=491)
EncodingException encoderIdNotFound(short id)

cannotFindTranscoder

@Message(value="Cannot find transcoder between \'%s\' to \'%s\'",
         id=492)
EncodingException cannotFindTranscoder(MediaType mediaType,
                                                                                                                          MediaType another)

errorTranscoding

@Message(value="%s encountered error transcoding content",
         id=495)
EncodingException errorTranscoding(String transcoderName,
                                                                                                               @Cause
                                                                                                               Throwable cause)

unsupportedContent

@Message(value="%s encountered unsupported content \'%s\' during transcoding",
         id=497)
EncodingException unsupportedContent(String transcoderName,
                                                                                                                                     Object content)

configurationSerializationFailed

@Message(value="Could not serialize the configuration of cache \'%s\' (%s)",
         id=499)
CacheConfigurationException configurationSerializationFailed(String cacheName,
                                                                                                                                                           Configuration configuration,
                                                                                                                                                           @Cause
                                                                                                                                                           Exception e)

incompatibleClusterConfiguration

@Message(value="Cannot create clustered configuration for cache \'%s\' because configuration %n%s%n is incompatible with the existing configuration %n%s",
         id=500)
CacheConfigurationException incompatibleClusterConfiguration(String cacheName,
                                                                                                                                                                                                                                         Configuration configuration,
                                                                                                                                                                                                                                         Configuration existing)

globalStateDisabled

@Message(value="Cannot persist cache configuration as global state is disabled",
         id=501)
CacheConfigurationException globalStateDisabled()

errorPersistingGlobalConfiguration

@Message(value="Error while persisting global configuration state",
         id=502)
CacheConfigurationException errorPersistingGlobalConfiguration(@Cause
                                                                                                                                                    Throwable cause)

offHeapMemoryEvictionNotSupportedWithObject

@Message(value="Size (bytes) based eviction needs either off-heap or a binary compatible storage configured in the cache encoding",
         id=504)
CacheConfigurationException offHeapMemoryEvictionNotSupportedWithObject()

biasedReadsAppliesOnlyToScattered

@Message(value="Biased reads are supported only in scattered cache. Maybe you were looking for L1?",
         id=506)
CacheConfigurationException biasedReadsAppliesOnlyToScattered()

cacheExists

@Message(value="Cache %s already exists",
         id=507)
CacheConfigurationException cacheExists(String cacheName)

cannotRenamePersistentFile

@Message(value="Cannot rename file %s to %s",
         id=508)
CacheConfigurationException cannotRenamePersistentFile(String absolutePath,
                                                                                                                      File persistentFile,
                                                                                                                      @Cause
                                                                                                                      Throwable cause)

unableToAddNullEntryMergePolicyFactory

@Message(value="Unable to add a \'null\' EntryMergePolicyFactory",
         id=509)
IllegalArgumentException unableToAddNullEntryMergePolicyFactory()

customStorageStrategyNotSet

@Message(value="ConfigurationStrategy set to CUSTOM, but none specified",
         id=510)
CacheConfigurationException customStorageStrategyNotSet()

managerConfigurationStorageUnavailable

@Message(value="ConfigurationStrategy cannot be set to MANAGED in embedded mode",
         id=511)
CacheConfigurationException managerConfigurationStorageUnavailable()

globalStateCannotAcquireLockFile

@Message(value="Cannot acquire lock \'%s\' for persistent global state",
         id=512)
CacheConfigurationException globalStateCannotAcquireLockFile(@Cause
                                                                                                                                                       Throwable cause,
                                                                                                                                                       File lockFile)

exceptionBasedEvictionOnlySupportedInTransactionalCaches

@Message(value="Exception based eviction requires a transactional cache that doesn\'t allow for 1 phase commit or synchronizations",
         id=513)
CacheConfigurationException exceptionBasedEvictionOnlySupportedInTransactionalCaches()

containerFull

@Message(value="Container eviction limit %d reached, write operation(s) is blocked",
         id=514)
ContainerFullException containerFull(long size)

immutableConfiguration

@Message(value="The configuration is immutable",
         id=515)
UnsupportedOperationException immutableConfiguration()

invalidPersistentState

@Message(value="The state file for \'%s\' is invalid. Startup halted to prevent further corruption of persistent state",
         id=516)
CacheConfigurationException invalidPersistentState(String globalScope)

ignoringCacheTopology

@LogMessage(level=WARN)
 @Message(value="Ignoring cache topology from %s during merge: %s",
         id=517)
void ignoringCacheTopology(Collection<Address> sender,
                                                                                                                                        CacheTopology topology)

updatingTopology

@LogMessage(level=DEBUG)
 @Message(value="Updating topology for cache %s, topology %s, availability mode %s",
         id=518)
void updatingTopology(String cacheName,
                                                                                                                                                     CacheTopology currentTopology,
                                                                                                                                                     AvailabilityMode availabilityMode)

updatingStableTopology

@LogMessage(level=DEBUG)
 @Message(value="Updating stable topology for cache %s, topology %s",
         id=519)
void updatingStableTopology(String cacheName,
                                                                                                                                            CacheTopology currentTopology)

updatingAvailabilityMode

@LogMessage(level=DEBUG)
 @Message(value="Updating availability mode for cache %s from %s to %s, topology %s",
         id=520)
void updatingAvailabilityMode(String cacheName,
                                                                                                                                                              AvailabilityMode oldMode,
                                                                                                                                                              AvailabilityMode newMode,
                                                                                                                                                              CacheTopology topology)

cacheRecoveredAfterMerge

@LogMessage(level=DEBUG)
 @Message(value="Cache %s recovered after merge with topology = %s, availability mode %s",
         id=521)
void cacheRecoveredAfterMerge(String cacheName,
                                                                                                                                                                   CacheTopology currentTopology,
                                                                                                                                                                   AvailabilityMode availabilityMode)

startingConflictResolution

@LogMessage(level=DEBUG)
 @Message(value="Conflict resolution starting for cache %s with topology %s",
         id=522)
void startingConflictResolution(String cacheName,
                                                                                                                                                        CacheTopology currentTopology)

finishedConflictResolution

@LogMessage(level=DEBUG)
 @Message(value="Conflict resolution finished for cache %s with topology %s",
         id=523)
void finishedConflictResolution(String cacheName,
                                                                                                                                                        CacheTopology currentTopology)

failedConflictResolution

@LogMessage(level=DEBUG)
 @Message(value="Conflict resolution failed for cache %s with topology %s",
         id=524)
void failedConflictResolution(String cacheName,
                                                                                                                                                    CacheTopology currentTopology,
                                                                                                                                                    @Cause
                                                                                                                                                    Throwable t)

cancelledConflictResolution

@LogMessage(level=DEBUG)
 @Message(value="Conflict resolution cancelled for cache %s with topology %s",
         id=525)
void cancelledConflictResolution(String cacheName,
                                                                                                                                                          CacheTopology currentTopology)

storeStartupAttemptsExceeded

@Message(value="Maximum startup attempts exceeded for store %s",
         id=527)
PersistenceException storeStartupAttemptsExceeded(String storeName,
                                                                                                                                    @Cause
                                                                                                                                    Throwable t)

degradedModeLockUnavailable

@Message(value="Cannot acquire lock %s as this partition is DEGRADED",
         id=528)
AvailabilityException degradedModeLockUnavailable(Object key)

errorDeserializing

@Message(value="Class \'%s\' blocked by deserialization white list. Include the class name in the server white list to authorize.",
         id=529)
CacheException errorDeserializing(String className)

unsupportedAsyncCacheMode

@LogMessage(level=WARN)
 @Message(value="Unsupported async cache mode \'%s\' for transactional caches, forcing %s",
         id=530)
void unsupportedAsyncCacheMode(CacheMode unsupportedCacheMode,
                                                                                                                                                                    CacheMode forcedCacheMode)

storeNotSegmented

@Message(value="Store or loader %s must implement SegmentedLoadWriteStore or its config must extend AbstractSegmentedStoreConfiguration if configured as segmented",
         id=531)
CacheConfigurationException storeNotSegmented(Class<?> implementedClass)

passivationStoreCannotBeShared

@Message(value="Invalid cache loader configuration for \'%s\'.  If a cache loader is configured with passivation, the cache loader cannot be shared in a cluster!",
         id=532)
CacheConfigurationException passivationStoreCannotBeShared(String name)

cannotConvertContent

@Message(value="Content \'%s (MediaType: \'%s\') cannot be converted to \'%s\'",
         id=533)
EncodingException cannotConvertContent(Object content,
                                                                                                                                         MediaType contentType,
                                                                                                                                         MediaType destination)

groupingOnlyCompatibleWithObjectStorage

@Message(value="Grouping requires OBJECT storage type but was: %s",
         id=534)
CacheConfigurationException groupingOnlyCompatibleWithObjectStorage(StorageType storageType)

groupingOnlyCompatibleWithObjectStorage

@Message(value="Grouping requires application/x-java-object storage type but was: {key=%s, value=%s}",
         id=535)
CacheConfigurationException groupingOnlyCompatibleWithObjectStorage(String keyMediaType,
                                                                                                                                                                                            String valueMediaType)

factoryCannotConstructComponent

@Message(value="Factory doesn\'t know how to construct component %s",
         id=537)
CacheConfigurationException factoryCannotConstructComponent(String componentName)

moduleStopError

@LogMessage(level=ERROR)
 @Message(value="Error stopping module %s",
         id=538)
void moduleStopError(String module,
                                                                                                           @Cause
                                                                                                           Throwable t)

duplicateJGroupsStack

@Message(value="Duplicate JGroups stack \'%s\'",
         id=539)
CacheConfigurationException duplicateJGroupsStack(String name)

missingJGroupsStack

@Message(value="No such JGroups stack \'%s\'",
         id=540)
CacheConfigurationException missingJGroupsStack(String name)

errorCreatingChannelFromConfigurator

@Message(value="Error while trying to create a channel using the specified configuration \'%s\'",
         id=541)
CacheConfigurationException errorCreatingChannelFromConfigurator(String configurator,
                                                                                                                                                                                    @Cause
                                                                                                                                                                                    Throwable t)

invalidScope

@Message(value="Invalid parser scope. Expected \'%s\' but was \'%s\'",
         id=542)
CacheConfigurationException invalidScope(String expected,
                                                                                                                                 String found)

jgroupsNoStackPosition

@Message(value="Cannot use stack.position when stack.combine is \'%s\'",
         id=543)
CacheConfigurationException jgroupsNoStackPosition(String combineMode)

jgroupsNoSuchProtocol

@Message(value="The protocol \'%s\' does not exist in the base stack for operation \'%s\'",
         id=544)
CacheConfigurationException jgroupsNoSuchProtocol(String protocolName,
                                                                                                                                                               String combineMode)

jgroupsInsertAfterRequiresPosition

@Message(value="Inserting protocol \'%s\' in a JGroups stack requires the \'stack.position\' attribute",
         id=545)
CacheConfigurationException jgroupsInsertAfterRequiresPosition(String protocolName)

duplicateRemoteSite

@Message(value="Duplicate remote site \'%s\' in stack \'%s\'",
         id=546)
CacheConfigurationException duplicateRemoteSite(String remoteSite,
                                                                                                                                String name)

jgroupsRemoteSitesWithoutRelay

@Message(value="JGroups stack \'%s\' declares remote sites but does not have a RELAY2 protocol",
         id=547)
CacheConfigurationException jgroupsRemoteSitesWithoutRelay(String name)

jgroupsRelayWithoutRemoteSites

@Message(value="JGroups stack \'%s\' has a RELAY2 protocol without remote sites",
         id=548)
CacheConfigurationException jgroupsRelayWithoutRemoteSites(String name)

sharedStoreWithLocalCache

@Message(value="A store cannot be shared when utilised with a local cache.",
         id=549)
CacheConfigurationException sharedStoreWithLocalCache()

invalidationPartitionHandlingNotSuported

@Message(value="Invalidation mode only supports when-split=ALLOW_READ_WRITES",
         id=550)
CacheConfigurationException invalidationPartitionHandlingNotSuported()

customInterceptorsDeprecated

@LogMessage(level=WARN)
 @Message(value="The custom interceptors configuration has been deprecated and will be ignored in the future",
         id=551)
void customInterceptorsDeprecated()

marshallersNotSupported

@LogMessage(level=WARN)
 @Message(value="Ignoring \'marshaller\' attribute. Common marshallers are already available at runtime, and to deploy a custom marshaller, consult the \'Encoding\' section in the user guide",
         id=553)
void marshallersNotSupported()

jbossMarshallingDetected

@LogMessage(level=WARN)
 @Message(value="jboss-marshalling is deprecated and planned for removal",
         id=554)
void jbossMarshallingDetected()

unableToSetAccessible

@LogMessage(level=ERROR)
 @Message(value="Unable to set method %s accessible",
         id=555)
void unableToSetAccessible(Method m,
                                                                                                                           @Cause
                                                                                                                           Exception e)

startingUserMarshaller

@LogMessage(level=INFO)
 @Message(value="Starting user marshaller \'%s\'",
         id=556)
void startingUserMarshaller(String marshallerClass)

unableToAddJGroupsStack

@Message(value="Unable to configure JGroups Stack \'%s\'",
         id=557)
CacheConfigurationException unableToAddJGroupsStack(String name,
                                                                                                                                @Cause
                                                                                                                                Exception e)

forbiddenStoreLocation

@Message(value="The store location \'%s\' is not a child of the global persistent location \'%s\'",
         id=558)
CacheConfigurationException forbiddenStoreLocation(Path location,
                                                                                                                                                                        Path global)

cannotMarshall

@LogMessage(level=WARN)
 @Message(value="Cannot marshall \'%s\'",
         id=559)
void cannotMarshall(Class<?> aClass,
                                                                                                       @Cause
                                                                                                       Throwable t)

advancedExternalizerDeprecated

@LogMessage(level=WARN)
 @Message(value="The AdvancedExternalizer configuration has been deprecated and will be removed in the future",
         id=560)
void advancedExternalizerDeprecated()

invalidChunkSize

@Message(value="Chunk size must be positive, got %d",
         id=561)
CacheConfigurationException invalidChunkSize(int chunkSize)

sharedStoreShouldNotBePurged

@Message(value="Invalid cache loader configuration for \'%s\'.  If a cache loader is configured with purgeOnStartup, the cache loader cannot be shared in a cluster!",
         id=562)
CacheConfigurationException sharedStoreShouldNotBePurged(String name)

storeDoesNotSupportBeingSegmented

@Message(value="Invalid cache loader configuration for \'%s\'.  This implementation does not support being segmented!",
         id=563)
CacheConfigurationException storeDoesNotSupportBeingSegmented(String name)

segmentedStoreUsesManyFileDescriptors

@LogMessage(level=WARN)
 @Message(value="Configured store \'%s\' is segmented and may use a large number of file descriptors",
         id=564)
void segmentedStoreUsesManyFileDescriptors(String storeName)

indexModeNotSupported

@Message(value="Index.%s is no longer supported. Please update your configuration!",
         id=565)
CacheConfigurationException indexModeNotSupported(String indexMode)

threadPoolFactoryIsBlocking

@Message(value="Thread Pool Factory %s is blocking, but pool %s requires non blocking threads",
         id=566)
CacheConfigurationException threadPoolFactoryIsBlocking(String name,
                                                                                                                                                                         String poolName)

warnUnableToPersistInternalCaches

@LogMessage(level=WARN)
 @Message(value="Unable to persist Infinispan internal caches as no global state enabled",
         id=569)
 @Once
void warnUnableToPersistInternalCaches()

unexpectedResponse

@Message(value="Unexpected response from %s: %s",
         id=570)
IllegalArgumentException unexpectedResponse(Address target,
                                                                                                               Response response)

crossSiteUnavailable

@Message(value="RELAY2 not found in ProtocolStack. Unable to do cross-site requests.",
         id=571)
CacheConfigurationException crossSiteUnavailable()

indexModeDeprecated

@LogMessage(level=WARN)
 @Message(value="index mode attribute is deprecated and should no longer be specified because its value is automatically detected. Most previously supported values are no longer supported. Please check the upgrade guide.",
         id=572)
void indexModeDeprecated()

incompatiblePersistedConfiguration

@Message(value="Cannot recreate persisted configuration for cache \'%s\' because configuration %n%s%n is incompatible with the existing configuration %n%s",
         id=573)
CacheConfigurationException incompatiblePersistedConfiguration(String cacheName,
                                                                                                                                                                                                                                             Configuration configuration,
                                                                                                                                                                                                                                             Configuration existing)

incompleteGlobalState

@LogMessage(level=WARN)
 @Message(value="Global state cannot persisted because it is incomplete (usually caused by errors at startup).",
         id=574)
void incompleteGlobalState()

singleOwnerNotSetToAllowReadWrites

@Message(value="PartitionStrategy must be ALLOW_READ_WRITES when numOwners is 1",
         id=575)
CacheConfigurationException singleOwnerNotSetToAllowReadWrites()

xsiteInLocalCache

@Message(value="Cross-site Replication not available for local cache.",
         id=576)
CacheConfigurationException xsiteInLocalCache()

missingTypeForUnwrappedPayload

@Message(value="Converting from unwrapped protostream payload requires the \'type\' parameter to be supplied in the destination MediaType",
         id=577)
MarshallingException missingTypeForUnwrappedPayload()

startMigratingPersistenceData

@LogMessage(level=INFO)
 @Message(value="Migrating persisted data to new format...",
         id=578)
void startMigratingPersistenceData()

persistedDataSuccessfulMigrated

@LogMessage(level=INFO)
 @Message(value="Persisted data successfully migrated.",
         id=579)
void persistedDataSuccessfulMigrated()

persistedDataMigrationFailed

@Message(value="Failed to migrate persisted data.",
         id=580)
PersistenceException persistedDataMigrationFailed(@Cause
                                                                                                                       Throwable cause)

indexEnabledAndIndexModeAreExclusive

@Message(value="The indexing \'enabled\' and the legacy \'index\' configs attributes are mutually exclusive",
         id=581)
CacheConfigurationException indexEnabledAndIndexModeAreExclusive()

foundMultipleDirectoryProviders

@Message(value="A single indexing directory provider is allowed per cache configuration. Setting multiple individual providers for the indexes belonging to a cache is not allowed.",
         id=582)
CacheConfigurationException foundMultipleDirectoryProviders()

cannotProvideBothSizeAndCount

@Message(value="Cannot configure both maxCount and maxSize in memory configuration",
         id=583)
CacheConfigurationException cannotProvideBothSizeAndCount()

cannotUseDeprecatedAndReplacement

@Message(value="The memory attribute(s) %s have been deprecated and cannot be used in conjunction with the new configuration",
         id=584)
CacheConfigurationException cannotUseDeprecatedAndReplacement(String legacyName)

ignoringSpecificMediaTypes

@LogMessage(level=WARN)
 @Message(value="Single media-type was specified for keys and values, ignoring individual configurations",
         id=585)
void ignoringSpecificMediaTypes()

warnUsingDeprecatedMemoryConfigs

@LogMessage(level=WARN)
 @Message(value="The memory configuration element \'%s\' has been deprecated. Please update your configuration",
         id=586)
void warnUsingDeprecatedMemoryConfigs(String element)

cannotChangeMaxSize

@Message(value="Cannot change max-size since max-count is already defined",
         id=587)
CacheConfigurationException cannotChangeMaxSize()

cannotChangeMaxCount

@Message(value="Cannot change max-count since max-size is already defined",
         id=588)
CacheConfigurationException cannotChangeMaxCount()

preloadAndPurgeOnStartupConflict

@Message(value="A store cannot be configured with both preload and purgeOnStartup",
         id=589)
CacheConfigurationException preloadAndPurgeOnStartupConflict()

storeBothReadAndWriteOnly

@Message(value="Store cannot be configured with both read and write only!",
         id=590)
CacheConfigurationException storeBothReadAndWriteOnly()

storeReadOnlyExceptions

@Message(value="Store cannot be configured with purgeOnStartup or shared if it is read only!",
         id=591)
CacheConfigurationException storeReadOnlyExceptions()

storeWriteOnlyExceptions

@Message(value="Store cannot be configured with fetchPersistenceState or preload if it is write only!",
         id=592)
CacheConfigurationException storeWriteOnlyExceptions()

storeConfiguredHasBothReadAndWriteOnly

@Message(value="Store %s cannot be configured to be %s as the implementation specifies it is already %s!",
         id=593)
CacheConfigurationException storeConfiguredHasBothReadAndWriteOnly(String storeClassName,
                                                                                                                                                                                               NonBlockingStore.Characteristic configured,
                                                                                                                                                                                               NonBlockingStore.Characteristic implSpecifies)

onlyOnePreloadStoreAllowed

@Message(value="At most one store can be set to \'preload\'!",
         id=594)
CacheConfigurationException onlyOnePreloadStoreAllowed()

warnUsingDeprecatedClusterLoader

@LogMessage(level=WARN)
 @Message(value="ClusterLoader has been deprecated and will be removed in a future version with no direct replacement",
         id=595)
void warnUsingDeprecatedClusterLoader()

autoConfigDeprecated

@LogMessage(level=WARN)
 @Message(value="Indexing auto-config attribute is deprecated. Please check the upgrade guide.",
         id=596)
void autoConfigDeprecated()

storeConfiguredTransactionalButCharacteristicNotPresent

@Message(value="Store %s cannot be configured to be transactional as it does not contain the TRANSACTIONAL characteristic",
         id=597)
CacheConfigurationException storeConfiguredTransactionalButCharacteristicNotPresent(String storeClassName)

storeLocationRequired

@Message(value="Store must specify a location when global state is disabled",
         id=598)
CacheConfigurationException storeLocationRequired()

storeLocationRequired

@Message(value="Store \'%s\' must specify the \'%s\' attribute when global state is disabled",
         id=598)
CacheConfigurationException storeLocationRequired(String storeType,
                                                                                                                                                                  String attributeName)

unknownEncoding

@LogMessage(level=WARN)
 @Message(value="Configuration for cache \'%s\' does not define the encoding for keys or values. If you use operations that require data conversion or queries, you should configure the cache with a specific MediaType for keys or values.",
         id=599)
void unknownEncoding(String cacheName)

storeConfiguredSharedButCharacteristicNotPresent

@Message(value="Store %s cannot be configured to be shared as it does not contain the SHARED characteristic",
         id=600)
CacheConfigurationException storeConfiguredSharedButCharacteristicNotPresent(String storeClassName)

xsiteCacheNotFound

@Message(value="Unable to handle cross-site request from site \'%s\'. Cache \'%s\' not found.",
         id=603)
CacheConfigurationException xsiteCacheNotFound(String remoteSite,
                                                                                                                                                                ByteString cacheName)

xsiteCacheNotStarted

@Message(value="Unable to handle cross-site request from site \'%s\'. Cache \'%s\' is stopped.",
         id=604)
CacheConfigurationException xsiteCacheNotStarted(String origin,
                                                                                                                                                                   ByteString cacheName)

xsiteInLocalCache

@Message(value="Unable to handle cross-site request from site \'%s\'. Cache \'%s\' is not clustered.",
         id=605)
CacheConfigurationException xsiteInLocalCache(String origin,
                                                                                                                                                                      ByteString cacheName)

xsiteInvalidConfigurationRemoteSite

@LogMessage(level=ERROR)
 @Message(value="Remote site \'%s\' has an invalid cache configuration. Changing to offline.",
         id=606)
void xsiteInvalidConfigurationRemoteSite(String siteName)

unexpectedErrorFromIrac

@LogMessage(level=FATAL)
 @Message(value="[IRAC] Unexpected error occurred.",
         id=608)
void unexpectedErrorFromIrac(@Cause
                                                                                                                            Throwable t)

cannotObtainFailedCache

@LogMessage(level=DEBUG)
 @Message(value="Cannot obtain cache \'%s\' as it is in FAILED state. Please check the configuration",
         id=609)
void cannotObtainFailedCache(String name,
                                                                                                                                                                              @Cause
                                                                                                                                                                              Throwable t)

Interface Log

Field Summary

Method Summary

Methods inherited from interface org.jboss.logging.BasicLogger

Field Detail

LOG_ROOT

CONFIG

CLUSTER

CONTAINER

PERSISTENCE

SECURITY

XSITE

Method Detail

problemApplyingStateForKey

expectedJustOneResponse

notStartingEvictionThread

exceptionPurgingDataContainer

unableToPassivateEntry

jmxMBeanAlreadyRegistered

couldNotFindAttribute

failedToUpdateAttribute

queriedAttributeNotFound

errorWritingValueForAttribute

couldNotInvokeSetOnAttribute

unknownResponsesFromRemoteCache

errorDoingRemoteCall

interruptedWaitingAsyncStorePush

interruptedAcquiringLock

unableToProcessAsyncModifications

unexpectedErrorInAsyncStoreCoordinator

exceptionHandlingCommand

unexpectedErrorReplicating

startingJGroupsChannel

startingJGroupsChannel

localAndPhysicalAddress

disconnectJGroups

problemClosingChannel

wrongTypeForJGroupsChannelLookup

errorInstantiatingJGroupsChannelLookup

errorCreatingChannelFromConfigFile

errorCreatingChannelFromXML

errorCreatingChannelFromConfigString

unableToUseJGroupsPropertiesProvided

interruptedWaitingForCoordinator

receivedMergedView

receivedClusterView

errorProcessing1pcPrepareCommand

errorRollingBack

unfinishedTransactionsRemain

failedSynchronizationRegistration

unableToRollbackGlobalTx

fallingBackToEmbeddedTm

failedToCreateInitialCtx

retrievingTm

errorEnlistingResource

beforeCompletionFailed

unexpectedErrorFromResourceManager

afterCompletionFailed

errorCommittingTx

recoveryIgnored

missingListPreparedTransactions

preparedTxAlreadyExists

unableToSetValue

failedToCallStopAfterFailure

version

noAnnotateMethodsFoundInListener

unableToInvokeListenerMethodAndRemoveListener

unableToLockToInvalidate

executionError

failedInvalidatingRemoteCache

couldNotRollbackPrepared1PcTransaction

failedLoadingValueFromCacheStore

failedToInvalidateKeys

staleEntriesWithoutFetchPersistentStateOrPurgeOnStartup

passivationWithoutEviction

couldNotCompleteInjectedTransaction

usingBatchModeTransactionManager

couldNotInstantiateTransactionManager

randomCacheModeSynonymsDeprecated

errorProcessing2pcCommitCommand