repo
stringlengths 1
191
⌀ | file
stringlengths 23
351
| code
stringlengths 0
5.32M
| file_length
int64 0
5.32M
| avg_line_length
float64 0
2.9k
| max_line_length
int64 0
288k
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/TransactionConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.configuration.cache.TransactionConfiguration.AUTO_COMMIT;
import static org.infinispan.configuration.cache.TransactionConfiguration.CACHE_STOP_TIMEOUT;
import static org.infinispan.configuration.cache.TransactionConfiguration.COMPLETED_TX_TIMEOUT;
import static org.infinispan.configuration.cache.TransactionConfiguration.LOCKING_MODE;
import static org.infinispan.configuration.cache.TransactionConfiguration.NOTIFICATIONS;
import static org.infinispan.configuration.cache.TransactionConfiguration.REAPER_WAKE_UP_INTERVAL;
import static org.infinispan.configuration.cache.TransactionConfiguration.TRANSACTION_MANAGER_LOOKUP;
import static org.infinispan.configuration.cache.TransactionConfiguration.TRANSACTION_MODE;
import static org.infinispan.configuration.cache.TransactionConfiguration.TRANSACTION_SYNCHRONIZATION_REGISTRY_LOOKUP;
import static org.infinispan.configuration.cache.TransactionConfiguration.USE_1_PC_FOR_AUTO_COMMIT_TRANSACTIONS;
import static org.infinispan.configuration.cache.TransactionConfiguration.USE_SYNCHRONIZATION;
import static org.infinispan.util.logging.Log.CONFIG;
import java.util.concurrent.TimeUnit;
import jakarta.transaction.Synchronization;
import jakarta.transaction.TransactionManager;
import javax.transaction.xa.XAResource;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.tx.lookup.TransactionManagerLookup;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.transaction.LockingMode;
import org.infinispan.transaction.TransactionMode;
import org.infinispan.transaction.lookup.TransactionSynchronizationRegistryLookup;
/**
* Defines transactional (JTA) characteristics of the cache.
*
* @author pmuir
* @author Pedro Ruivo
*/
public class TransactionConfigurationBuilder extends AbstractConfigurationChildBuilder implements Builder<TransactionConfiguration> {
final AttributeSet attributes;
private final RecoveryConfigurationBuilder recovery;
TransactionConfigurationBuilder(ConfigurationBuilder builder) {
super(builder);
attributes = TransactionConfiguration.attributeDefinitionSet();
this.recovery = new RecoveryConfigurationBuilder(this);
}
/**
* If the cache is transactional (i.e. {@link #transactionMode(org.infinispan.transaction.TransactionMode)} == TransactionMode.TRANSACTIONAL)
* and transactionAutoCommit is enabled then for single operation transactions
* the user doesn't need to manually start a transaction, but a transactions
* is injected by the system. Defaults to true.
*/
public TransactionConfigurationBuilder autoCommit(boolean b) {
attributes.attribute(AUTO_COMMIT).set(b);
return this;
}
/**
* If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing
* remote and local transactions to finish. The amount of time to wait for is defined by the
* cache stop timeout. It is recommended that this value does not exceed the transaction timeout
* because even if a new transaction was started just before the cache was stopped, this could
* only last as long as the transaction timeout allows it.
* <p/>
* This configuration property may be adjusted at runtime
*/
public TransactionConfigurationBuilder cacheStopTimeout(long l) {
attributes.attribute(CACHE_STOP_TIMEOUT).set(l);
return this;
}
/**
* If there are any ongoing transactions when a cache is stopped, Infinispan waits for ongoing
* remote and local transactions to finish. The amount of time to wait for is defined by the
* cache stop timeout. It is recommended that this value does not exceed the transaction timeout
* because even if a new transaction was started just before the cache was stopped, this could
* only last as long as the transaction timeout allows it.
* <p/>
* This configuration property may be adjusted at runtime
*/
public TransactionConfigurationBuilder cacheStopTimeout(long l, TimeUnit unit) {
return cacheStopTimeout(unit.toMillis(l));
}
/**
* Configures whether the cache uses optimistic or pessimistic locking. If the cache is not
* transactional then the locking mode is ignored.
*
* @see org.infinispan.configuration.cache.TransactionConfiguration#transactionMode()
*/
public TransactionConfigurationBuilder lockingMode(LockingMode lockingMode) {
attributes.attribute(LOCKING_MODE).set(lockingMode);
return this;
}
LockingMode lockingMode() {
return attributes.attribute(LOCKING_MODE).get();
}
/**
* Configure Transaction manager lookup directly using an instance of TransactionManagerLookup.
* Calling this method marks the cache as transactional.
*/
public TransactionConfigurationBuilder transactionManagerLookup(TransactionManagerLookup tml) {
attributes.attribute(TRANSACTION_MANAGER_LOOKUP).set(tml);
if (tml != null) {
this.transactionMode(TransactionMode.TRANSACTIONAL);
}
return this;
}
public TransactionManagerLookup transactionManagerLookup() {
return attributes.attribute(TRANSACTION_MANAGER_LOOKUP).get();
}
/**
* Configure Transaction Synchronization Registry lookup directly using an instance of
* TransactionManagerLookup. Calling this method marks the cache as transactional.
*/
public TransactionConfigurationBuilder transactionSynchronizationRegistryLookup(TransactionSynchronizationRegistryLookup lookup) {
attributes.attribute(TRANSACTION_SYNCHRONIZATION_REGISTRY_LOOKUP).set(lookup);
return this;
}
public TransactionConfigurationBuilder transactionMode(TransactionMode transactionMode) {
attributes.attribute(TRANSACTION_MODE).set(transactionMode);
return this;
}
public TransactionMode transactionMode() {
return attributes.attribute(TRANSACTION_MODE).get();
}
/**
* Configures whether the cache registers a synchronization with the transaction manager, or registers itself as an
* XA resource. It is often unnecessary to register as a full XA resource unless you intend to make use of recovery
* as well, and registering a synchronization is significantly more efficient.
* @param b if true, {@link Synchronization}s are used rather than {@link XAResource}s when communicating with a {@link TransactionManager}.
*/
public TransactionConfigurationBuilder useSynchronization(boolean b) {
attributes.attribute(USE_SYNCHRONIZATION).set(b);
return this;
}
/**
* See {@link #useSynchronization(boolean)}
*
* @return {@code true} if synchronization enlistment is enabled
*/
boolean useSynchronization() {
return attributes.attribute(USE_SYNCHRONIZATION).get();
}
/**
* This method allows configuration of the transaction recovery cache. When this method is
* called, it automatically enables recovery. So, if you want it to be disabled, make sure you
* call {@link RecoveryConfigurationBuilder#disable()} )}
*/
public RecoveryConfigurationBuilder recovery() {
return recovery;
}
/**
* Before Infinispan 5.1 you could access the cache both transactionally and
* non-transactionally. Naturally the non-transactional access is faster and
* offers less consistency guarantees. From Infinispan 5.1 onwards, mixed
* access is no longer supported, so if you wanna speed up transactional
* caches and you're ready to trade some consistency guarantees, you can
* enable use1PcForAutoCommitTransactions. <p/>
*
* What this configuration option does is force an induced transaction,
* that has been started by Infinispan as a result of enabling autoCommit,
* to commit in a single phase. So only 1 RPC instead of 2RPCs as in the
* case of a full 2 Phase Commit (2PC).
*/
public TransactionConfigurationBuilder use1PcForAutoCommitTransactions(boolean b) {
attributes.attribute(USE_1_PC_FOR_AUTO_COMMIT_TRANSACTIONS).set(b);
return this;
}
public boolean use1PcForAutoCommitTransactions() {
return attributes.attribute(USE_1_PC_FOR_AUTO_COMMIT_TRANSACTIONS).get();
}
/**
*The time interval (millis) at which the thread that cleans up transaction completion information kicks in. Defaults to 30000.
*/
public TransactionConfigurationBuilder reaperWakeUpInterval(long interval) {
attributes.attribute(REAPER_WAKE_UP_INTERVAL).set(interval);
return this;
}
/**
* The duration (millis) in which to keep information about the completion of a transaction. Defaults to 60000.
*/
public TransactionConfigurationBuilder completedTxTimeout(long timeout) {
attributes.attribute(COMPLETED_TX_TIMEOUT).set(timeout);
return this;
}
/**
* @return are transactional notifications (
* {@link org.infinispan.notifications.cachelistener.annotation.TransactionRegistered} and
* {@link org.infinispan.notifications.cachelistener.annotation.TransactionCompleted}) triggered?
*/
public TransactionConfigurationBuilder notifications(boolean enabled) {
attributes.attribute(NOTIFICATIONS).set(enabled);
return this;
}
public AttributeSet attributes() {
return attributes;
}
@Override
public void validate() {
Attribute<Long> reaperWakeUpInterval = attributes.attribute(REAPER_WAKE_UP_INTERVAL);
Attribute<Long> completedTxTimeout = attributes.attribute(COMPLETED_TX_TIMEOUT);
if (reaperWakeUpInterval.get()< 0)
throw CONFIG.invalidReaperWakeUpInterval(reaperWakeUpInterval.get());
if (completedTxTimeout.get() < 0)
throw CONFIG.invalidCompletedTxTimeout(completedTxTimeout.get());
CacheMode cacheMode = clustering().cacheMode();
if (!attributes.attribute(NOTIFICATIONS).get() && !getBuilder().template()) {
CONFIG.transactionNotificationsDisabled();
}
if (attributes.attribute(TRANSACTION_MODE).get().isTransactional() && !cacheMode.isSynchronous()) {
throw CONFIG.unsupportedAsyncCacheMode(cacheMode);
}
recovery.validate();
}
@Override
public void validate(GlobalConfiguration globalConfig) {
recovery.validate(globalConfig);
}
@Override
public TransactionConfiguration create() {
boolean invocationBatching = builder.invocationBatching().isEnabled();
return new TransactionConfiguration(attributes.protect(), recovery.create(), invocationBatching);
}
@Override
public TransactionConfigurationBuilder read(TransactionConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.recovery.read(template.recovery(), combine);
return this;
}
@Override
public String toString() {
return "TransactionConfigurationBuilder [attributes=" + attributes + ", recovery=" + recovery + "]";
}
}
| 11,195
| 42.227799
| 144
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/CustomFailurePolicy.java
|
package org.infinispan.configuration.cache;
import java.util.Collection;
import java.util.Map;
import java.util.function.BiFunction;
import java.util.function.Function;
import jakarta.transaction.Transaction;
import org.infinispan.Cache;
import org.infinispan.xsite.AbstractCustomFailurePolicy;
import org.infinispan.xsite.BackupFailureException;
/**
* Used for implementing custom policies in case of communication failures with a remote site. The handle methods are
* allowed to throw instances of {@link BackupFailureException} to signal that they want the intra-site operation to
* fail as well. If handle methods don't throw any exception then the operation will succeed in the local cluster. For
* convenience, there is a support implementation of this class: {@link AbstractCustomFailurePolicy}
* <p/>
* Lifecycle: the same instance is invoked during the lifecycle of a cache so it is allowed to hold state between
* invocations.
* <p/>
* Threadsafety: instances of this class might be invoked from different threads and they should be synchronized.
*
* @author Mircea Markus
* @see BackupFailureException
* @since 5.2
*/
public interface CustomFailurePolicy<K, V> {
/**
* Invoked during the initialization phase.
*/
void init(Cache<K, V> cache);
void handlePutFailure(String site, K key, V value, boolean putIfAbsent);
void handleRemoveFailure(String site, K key, V oldValue);
void handleReplaceFailure(String site, K key, V oldValue, V newValue);
default void handleComputeFailure(String site, K key,
BiFunction<? super K, ? super V, ? extends V> remappingFunction, boolean computeIfPresent) {
}
default void handleComputeIfAbsentFailure(String site, K key, Function<? super K, ? extends V> mappingFunction) {
}
default void handleReadWriteKeyFailure(String site, K key) {
}
default void handleReadWriteKeyValueFailure(String site, K key) {
}
default void handleWriteOnlyKeyFailure(String site, K key) {
}
default void handleWriteOnlyKeyValueFailure(String site, K key) {
}
default void handleReadWriteManyFailure(String site, Collection<? extends K> keys) {
}
default void handleReadWriteManyEntriesFailure(String site, Map<? extends K, ? extends V> keys) {
}
default void handleWriteOnlyManyFailure(String site, Collection<? extends K> key) {
}
default void handleWriteOnlyManyEntriesFailure(String site, Map<? extends K, ? extends V> key) {
}
void handleClearFailure(String site);
void handlePutAllFailure(String site, Map<K, V> map);
void handlePrepareFailure(String site, Transaction transaction);
void handleRollbackFailure(String site, Transaction transaction);
void handleCommitFailure(String site, Transaction transaction);
}
| 2,788
| 32.60241
| 118
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/BackupForBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.configuration.cache.BackupForConfiguration.REMOTE_CACHE;
import static org.infinispan.configuration.cache.BackupForConfiguration.REMOTE_SITE;
import static org.infinispan.util.logging.Log.CONFIG;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.global.GlobalConfiguration;
/**
* @author Mircea Markus
* @since 5.2
*/
public class BackupForBuilder extends AbstractConfigurationChildBuilder implements Builder<BackupForConfiguration> {
private final AttributeSet attributes;
public BackupForBuilder(ConfigurationBuilder builder) {
super(builder);
attributes = BackupForConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* @param siteName the name of the remote site that backups data into this cache.
*/
public BackupForBuilder remoteSite(String siteName) {
attributes.attribute(REMOTE_SITE).set(siteName);
return this;
}
/**
* @param name the name of the remote cache that backups data into this cache.
*/
public BackupForBuilder remoteCache(String name) {
if (name == null) {
throw CONFIG.backupForNullCache();
}
attributes.attribute(REMOTE_CACHE).set(name);
return this;
}
/**
* Use this method if the remote cache that backups in this cache is the default cache.
* @deprecated Use a named cache with {@link #remoteCache(String)} instead.
*/
@Deprecated
public BackupForBuilder defaultRemoteCache() {
attributes.attribute(REMOTE_CACHE).set("");
return this;
}
@Override
public void validate() {
//if both remote cache and remote site are not specified then this is not a backup
if (attributes.attribute(REMOTE_CACHE).get() == null && attributes.attribute(REMOTE_SITE).get() == null)
return;
if (attributes.attribute(REMOTE_SITE).get() == null || attributes.attribute(REMOTE_CACHE).get() == null) {
throw CONFIG.backupForMissingParameters();
}
//if we have backup for configured, we can check if the cache is clustered.
if (!builder.clustering().cacheMode().isClustered()) {
throw CONFIG.xsiteInLocalCache();
}
}
@Override
public void validate(GlobalConfiguration globalConfig) {
}
@Override
public BackupForConfiguration create() {
return new BackupForConfiguration(attributes.protect());
}
@Override
public BackupForBuilder read(BackupForConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "BackupForBuilder [attributes=" + attributes + "]";
}
}
| 2,947
| 31.395604
| 116
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/StatisticsConfiguration.java
|
package org.infinispan.configuration.cache;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Element;
/**
* Determines whether cache statistics are gathered.
*
* @since 10.1.3
*/
public class StatisticsConfiguration extends ConfigurationElement<StatisticsConfiguration> implements JMXStatisticsConfiguration {
public static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.STATISTICS, false).build();
public static final AttributeDefinition<Boolean> AVAILABLE = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.STATISTICS_AVAILABLE, true).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(StatisticsConfiguration.class, ENABLED, AVAILABLE);
}
private final Attribute<Boolean> enabled;
private final Attribute<Boolean> available;
/**
* Enable or disable statistics gathering.
*
* @param attributes
*/
StatisticsConfiguration(AttributeSet attributes) {
super(Element.JMX_STATISTICS, attributes);
enabled = attributes.attribute(ENABLED);
available = attributes.attribute(AVAILABLE);
}
public boolean enabled() {
return enabled.get();
}
/**
* If set to false, statistics gathering cannot be enabled during runtime. Performance optimization.
*
* @deprecated since 10.1.3. This method will be removed in a future version.
*/
@Deprecated
public boolean available() {
return available.get();
}
}
| 1,836
| 35.019608
| 187
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/AbstractSegmentedStoreConfiguration.java
|
package org.infinispan.configuration.cache;
import java.io.File;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.persistence.spi.InitializationContext;
/**
* Abstract store configuration that should be extended when the store configuration supports being segmented.
* @author wburns
* @since 9.4
*/
public abstract class AbstractSegmentedStoreConfiguration<T extends AbstractStoreConfiguration> extends AbstractStoreConfiguration {
public AbstractSegmentedStoreConfiguration(Enum<?> element, AttributeSet attributes, AsyncStoreConfiguration async) {
super(element, attributes, async);
}
/**
* Method that is invoked each time a new store is created for a segment. This method should return a new
* configuration that is configured to be persisted using the given segment.
* @param segment the segment to use
* @return the newly created configuration
* @deprecated since 10.0 - please implement {@link #newConfigurationFrom(int, InitializationContext)}.
*/
@Deprecated
public T newConfigurationFrom(int segment) {
throw new UnsupportedOperationException("Please make sure you are implementing newConfigurationFrom(int, InitializationContext)");
}
/**
* Same as {@link #newConfigurationFrom(int)} except that you can utilize the intialization context when
* initializing the segmented store object. This method
* @param segment the segment to use
* @param ctx the initialization context from the persistence layer
* @return the newly created configuration
* @implSpec This invokes the {@link #newConfigurationFrom(int)} method and this default impl will be removed in the future
*/
public T newConfigurationFrom(int segment, InitializationContext ctx) {
return newConfigurationFrom(segment);
}
/**
* Transforms a file location to a segment based one. This is useful for file based stores where all you need to
* do is append a segment to the name of the directory. If the provided location is a directory, that is that it is
* terminated by in {@link File#separatorChar}, it will add a new directory onto that that is the segment. If the
* location is a file, that is that it is not terminated by {@link File#separatorChar}, this will treat the location
* as a directory and append a segment file in it. The underlying store may or may not preserve this and could still
* turn the segment into a directory.
* @param location original file location
* @param segment the segment to append
* @return string with the segment appended to the file location
*/
public static String fileLocationTransform(String location, int segment) {
if (location.endsWith(File.separator)) {
return location.substring(0, location.length() - 1) + "-" + segment + File.separatorChar;
}
return location + File.separatorChar + segment;
}
}
| 2,938
| 47.983333
| 136
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/InvocationBatchingConfiguration.java
|
package org.infinispan.configuration.cache;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.Matchable;
public class InvocationBatchingConfiguration implements Matchable<InvocationBatchingConfiguration> {
public static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.ENABLED, false).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(InvocationBatchingConfiguration.class, ENABLED);
}
private final Attribute<Boolean> enabled;
private final AttributeSet attributes;
InvocationBatchingConfiguration(AttributeSet attributes) {
this.attributes = attributes.checkProtection();
enabled = attributes.attribute(ENABLED);
}
public boolean enabled() {
return enabled.get();
}
public AttributeSet attributes() {
return attributes;
}
@Override
public String toString() {
return attributes.toString(null);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
InvocationBatchingConfiguration other = (InvocationBatchingConfiguration) obj;
if (attributes == null) {
if (other.attributes != null)
return false;
} else if (!attributes.equals(other.attributes))
return false;
return true;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((attributes == null) ? 0 : attributes.hashCode());
return result;
}
}
| 1,905
| 30.766667
| 173
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/IndexingConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.commons.configuration.AbstractTypedPropertiesConfiguration.PROPERTIES;
import static org.infinispan.commons.util.StringPropertyReplacer.replaceProperties;
import static org.infinispan.configuration.cache.IndexingConfiguration.ENABLED;
import static org.infinispan.configuration.cache.IndexingConfiguration.INDEXED_ENTITIES;
import static org.infinispan.configuration.cache.IndexingConfiguration.INDEXING_MODE;
import static org.infinispan.configuration.cache.IndexingConfiguration.KEY_TRANSFORMERS;
import static org.infinispan.configuration.cache.IndexingConfiguration.PATH;
import static org.infinispan.configuration.cache.IndexingConfiguration.STARTUP_MODE;
import static org.infinispan.configuration.cache.IndexingConfiguration.STORAGE;
import static org.infinispan.util.logging.Log.CONFIG;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.util.TypedProperties;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.util.logging.Log;
/**
* Configures indexing of entries in the cache for searching.
*/
public class IndexingConfigurationBuilder extends AbstractConfigurationChildBuilder implements IndexingConfigurationChildBuilder, Builder<IndexingConfiguration> {
private final AttributeSet attributes;
private final IndexReaderConfigurationBuilder readerConfigurationBuilder;
private final IndexWriterConfigurationBuilder writerConfigurationBuilder;
private final IndexShardingConfigurationBuilder shardingConfigurationBuilder;
IndexingConfigurationBuilder(ConfigurationBuilder builder) {
super(builder);
attributes = IndexingConfiguration.attributeDefinitionSet();
readerConfigurationBuilder = new IndexReaderConfigurationBuilder(this);
writerConfigurationBuilder = new IndexWriterConfigurationBuilder(this);
shardingConfigurationBuilder = new IndexShardingConfigurationBuilder(this);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public IndexingConfigurationBuilder enabled(boolean enabled) {
attributes.attribute(ENABLED).set(enabled);
return this;
}
public IndexReaderConfigurationBuilder reader() {
return readerConfigurationBuilder;
}
public IndexWriterConfigurationBuilder writer() {
return writerConfigurationBuilder;
}
public IndexShardingConfigurationBuilder sharding() {
return shardingConfigurationBuilder;
}
public IndexingConfigurationBuilder enable() {
return enabled(true);
}
public IndexingConfigurationBuilder disable() {
return enabled(false);
}
public boolean enabled() {
return attributes.attribute(ENABLED).get();
}
public IndexingConfigurationBuilder path(String path) {
attributes.attribute(PATH).set(path);
return this;
}
public IndexingConfigurationBuilder storage(IndexStorage storage) {
attributes.attribute(STORAGE).set(storage);
return this;
}
public IndexingConfigurationBuilder startupMode(IndexStartupMode startupMode) {
attributes.attribute(STARTUP_MODE).set(startupMode);
return this;
}
public IndexingConfigurationBuilder indexingMode(IndexingMode indexingMode) {
attributes.attribute(INDEXING_MODE).set(indexingMode);
return this;
}
/**
* Registers a transformer for a key class.
*
* @param keyClass the class of the key
* @param keyTransformerClass the class of the org.infinispan.query.Transformer that handles this key type
* @return <code>this</code>, for method chaining
*/
public IndexingConfigurationBuilder addKeyTransformer(Class<?> keyClass, Class<?> keyTransformerClass) {
Map<Class<?>, Class<?>> keyTransformers = keyTransformers();
keyTransformers.put(keyClass, keyTransformerClass);
attributes.attribute(KEY_TRANSFORMERS).set(keyTransformers);
return this;
}
/**
* The currently configured key transformers.
*
* @return a {@link Map} in which the map key is the key class and the value is the Transformer class.
*/
private Map<Class<?>, Class<?>> keyTransformers() {
return attributes.attribute(KEY_TRANSFORMERS).get();
}
public IndexingConfigurationBuilder addIndexedEntity(String indexedEntity) {
if (indexedEntity == null || indexedEntity.isEmpty()) {
throw Log.CONFIG.indexedEntityNameMissing();
}
Set<String> indexedEntitySet = indexedEntities();
indexedEntitySet.add(indexedEntity);
attributes.attribute(INDEXED_ENTITIES).set(indexedEntitySet);
return this;
}
public IndexingConfigurationBuilder addIndexedEntities(String... indexedEntities) {
Set<String> indexedEntitySet = indexedEntities();
for (String typeName : indexedEntities) {
if (typeName == null || typeName.isEmpty()) {
throw Log.CONFIG.indexedEntityNameMissing();
}
indexedEntitySet.add(typeName);
}
attributes.attribute(INDEXED_ENTITIES).set(indexedEntitySet);
return this;
}
public IndexingConfigurationBuilder addIndexedEntity(Class<?> indexedEntity) {
addIndexedEntity(indexedEntity.getName());
return this;
}
public IndexingConfigurationBuilder addIndexedEntities(Class<?>... indexedEntities) {
addIndexedEntities(Arrays.stream(indexedEntities).map(Class::getName).toArray(String[]::new));
return this;
}
/**
* The set of fully qualified names of indexed entity types, either Java classes or protobuf type names. This
* configuration corresponds to the {@code <indexed-entities>} XML configuration element.
*/
private Set<String> indexedEntities() {
return attributes.attribute(INDEXED_ENTITIES).get();
}
@Override
public void validate() {
if (enabled()) {
//Indexing is not conceptually compatible with Invalidation mode
if (clustering().cacheMode().isInvalidation()) {
throw CONFIG.invalidConfigurationIndexingWithInvalidation();
}
if (indexedEntities().isEmpty() && !getBuilder().template()) {
//TODO [anistor] This does not take into account eventual programmatically defined entity mappings
throw CONFIG.noIndexableClassesDefined();
}
} else {
if (!indexedEntities().isEmpty()) {
throw CONFIG.indexableClassesDefined();
}
}
ensureSingleIndexingConfig();
}
private void ensureSingleIndexingConfig() {
TypedProperties typedProperties = attributes.attribute(PROPERTIES).get();
boolean hasMultiIndexConfig =
typedProperties.keySet().stream()
.map(Object::toString)
.filter(k -> k.contains("."))
.map(k -> k.substring(k.lastIndexOf('.')))
.anyMatch(s -> typedProperties.keySet().stream().filter(k -> k.toString().endsWith(s)).count() > 1);
if (hasMultiIndexConfig) {
throw CONFIG.foundDifferentIndexConfigPerType();
}
}
@Override
public void validate(GlobalConfiguration globalConfig) {
if (enabled()) {
// Check that the query module is on the classpath.
try {
String clazz = "org.infinispan.query.Search";
Util.loadClassStrict(clazz, globalConfig.classLoader());
} catch (ClassNotFoundException e) {
throw CONFIG.invalidConfigurationIndexingWithoutModule();
}
if (attributes.attribute(STORAGE).get() == IndexStorage.FILESYSTEM) {
boolean globalStateEnabled = globalConfig.globalState().enabled();
String path = replaceProperties(attributes.attribute(PATH).get());
if (!globalStateEnabled) {
if (path == null) {
CONFIG.indexLocationWorkingDir();
} else if (!Paths.get(path).isAbsolute()) {
CONFIG.indexRelativeWorkingDir(path);
}
}
}
}
}
@Override
public IndexingConfiguration create() {
return new IndexingConfiguration(attributes.protect(), readerConfigurationBuilder.create(),
writerConfigurationBuilder.create(), shardingConfigurationBuilder.create());
}
@Override
public IndexingConfigurationBuilder read(IndexingConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.readerConfigurationBuilder.read(template.reader(), combine);
this.writerConfigurationBuilder.read(template.writer(), combine);
this.shardingConfigurationBuilder.read(template.sharding(), combine);
return this;
}
@Override
public String toString() {
return "IndexingConfigurationBuilder{" +
"attributes=" + attributes +
", readerConfigurationBuilder=" + readerConfigurationBuilder +
", writerConfigurationBuilder=" + writerConfigurationBuilder +
", shardingConfigurationBuilder=" + shardingConfigurationBuilder +
'}';
}
}
| 9,386
| 37.314286
| 162
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/QueryConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.configuration.cache.QueryConfiguration.DEFAULT_MAX_RESULTS;
import static org.infinispan.configuration.cache.QueryConfiguration.HIT_COUNT_ACCURACY;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class QueryConfigurationBuilder extends AbstractConfigurationChildBuilder implements Builder<QueryConfiguration> {
private final AttributeSet attributes;
public QueryConfigurationBuilder(ConfigurationBuilder builder) {
super(builder);
attributes = QueryConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Limits the number of results returned by a query. Applies to indexed, non-indexed, and hybrid queries.
* Setting the default-max-results significantly improves performance of queries that don't have an explicit limit set.
*
* @param defaultMaxResults The value to apply
* @return <code>this</code>, for method chaining
*/
public QueryConfigurationBuilder defaultMaxResults(int defaultMaxResults) {
attributes.attribute(DEFAULT_MAX_RESULTS).set(defaultMaxResults);
return this;
}
public int defaultMaxResults() {
return attributes.attribute(DEFAULT_MAX_RESULTS).get();
}
/**
* Limit the required accuracy of the hit count for the indexed queries to an upper-bound.
* Setting the hit-count-accuracy could improve the performance of queries targeting large data sets.
* For optimal performances set this value not much above the expected hit count.
* If you do not require accurate hit counts, set it to a low value.
*
* @param hitCountAccuracy The value to apply
* @return <code>this</code>, for method chaining
*/
public QueryConfigurationBuilder hitCountAccuracy(int hitCountAccuracy) {
attributes.attribute(HIT_COUNT_ACCURACY).set(hitCountAccuracy);
return this;
}
public int hitCountAccuracy() {
return attributes.attribute(HIT_COUNT_ACCURACY).get();
}
@Override
public QueryConfiguration create() {
return new QueryConfiguration(attributes.protect());
}
@Override
public QueryConfigurationBuilder read(QueryConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 2,495
| 35.173913
| 122
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/PartitionHandlingConfiguration.java
|
package org.infinispan.configuration.cache;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Attribute;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.conflict.EntryMergePolicy;
import org.infinispan.conflict.MergePolicy;
import org.infinispan.partitionhandling.PartitionHandling;
/**
* Controls how the cache handles partitioning and/or multiple node failures.
*
* @author Mircea Markus
* @since 7.0
*/
public class PartitionHandlingConfiguration extends ConfigurationElement<PartitionHandlingConfiguration> {
public static final AttributeDefinition<PartitionHandling> WHEN_SPLIT = AttributeDefinition.builder(Attribute.WHEN_SPLIT, PartitionHandling.ALLOW_READ_WRITES)
.immutable().build();
public static final AttributeDefinition<EntryMergePolicy> MERGE_POLICY = AttributeDefinition.builder(Attribute.MERGE_POLICY, MergePolicy.NONE, EntryMergePolicy.class)
.immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(PartitionHandlingConfiguration.class, WHEN_SPLIT, MERGE_POLICY);
}
public PartitionHandlingConfiguration(AttributeSet attributes) {
super(Element.PARTITION_HANDLING, attributes);
}
public PartitionHandling whenSplit() {
return attributes.attribute(WHEN_SPLIT).get();
}
public EntryMergePolicy mergePolicy() {
return attributes.attribute(MERGE_POLICY).get();
}
public boolean resolveConflictsOnMerge() {
EntryMergePolicy policy = mergePolicy();
if (policy == MergePolicy.NONE)
return false;
return policy != null;
}
}
| 1,834
| 35.7
| 169
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/AbstractStoreConfiguration.java
|
package org.infinispan.configuration.cache;
import java.util.Properties;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.util.TypedProperties;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.parsing.Element;
public class AbstractStoreConfiguration<T extends StoreConfiguration> extends ConfigurationElement<AbstractStoreConfiguration<T>> implements StoreConfiguration {
public static final AttributeDefinition<Boolean> PURGE_ON_STARTUP = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.PURGE, false).immutable().build();
public static final AttributeDefinition<Boolean> READ_ONLY = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.READ_ONLY, false).immutable().build();
public static final AttributeDefinition<Boolean> WRITE_ONLY = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.WRITE_ONLY, false).immutable().build();
public static final AttributeDefinition<Boolean> PRELOAD = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.PRELOAD, false).immutable().build();
public static final AttributeDefinition<Boolean> SHARED = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.SHARED, false).immutable().build();
public static final AttributeDefinition<Boolean> TRANSACTIONAL = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.TRANSACTIONAL, false).immutable().build();
public static final AttributeDefinition<Integer> MAX_BATCH_SIZE = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.MAX_BATCH_SIZE, 100).immutable().build();
public static final AttributeDefinition<Boolean> SEGMENTED = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.SEGMENTED, true).immutable().build();
public static final AttributeDefinition<TypedProperties> PROPERTIES = AttributeDefinition.builder(Element.PROPERTIES, null, TypedProperties.class)
.initializer(() -> new TypedProperties()).autoPersist(false).immutable().build();
private final Attribute<Integer> maxBatchSize;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(AbstractStoreConfiguration.class, PURGE_ON_STARTUP,
READ_ONLY, WRITE_ONLY, PRELOAD, SHARED, TRANSACTIONAL, MAX_BATCH_SIZE, SEGMENTED, PROPERTIES);
}
private final AsyncStoreConfiguration async;
protected AbstractStoreConfiguration(Enum<?> element, AttributeSet attributes, AsyncStoreConfiguration async, ConfigurationElement<?>... children) {
super(element, attributes, Util.concat(children, async));
this.async = async;
maxBatchSize = attributes.attribute(MAX_BATCH_SIZE);
}
/**
* Configuration for the async cache loader. If enabled, this provides you with asynchronous writes to the cache
* store, giving you 'write-behind' caching.
*/
@Override
public AsyncStoreConfiguration async() {
return async;
}
/**
* If true, purges this cache store when it starts up.
*/
@Override
public boolean purgeOnStartup() {
return attributes.attribute(PURGE_ON_STARTUP).get();
}
@Override
public boolean shared() {
return attributes.attribute(SHARED).get();
}
@Override
public boolean transactional() {
return attributes.attribute(TRANSACTIONAL).get();
}
@Override
public int maxBatchSize() {
return maxBatchSize.get();
}
@Override
public boolean segmented() {
return attributes.attribute(SEGMENTED).get();
}
/**
* If true, fetch persistent state when joining a cluster. If multiple cache stores are chained, only one of them can
* have this property enabled. Persistent state transfer with a shared cache store does not make sense, as the same
* persistent store that provides the data will just end up receiving it. Therefore, if a shared cache store is used,
* the cache will not allow a persistent state transfer even if a cache store has this property set to true.
*
* @deprecated since 14.0. Always returns false. The first non shared store is used instead.
*/
@Deprecated
@Override
public boolean fetchPersistentState() {
return false;
}
/**
* If true, any operation that modifies the cache (put, remove, clear, store...etc) won't be applied to the cache
* store. This means that the cache store could become out of sync with the cache.
*/
@Override
public boolean ignoreModifications() {
return attributes.attribute(READ_ONLY).get();
}
/**
* If true, any operation that reads from the cache won't be retrieved from the given store. This includes bulk
* operations as well.
*/
@Override
public boolean writeOnly() {
return attributes.attribute(WRITE_ONLY).get();
}
@Override
public boolean preload() {
return attributes.attribute(PRELOAD).get();
}
@Override
public Properties properties() {
return attributes.attribute(PROPERTIES).get();
}
}
| 5,331
| 44.186441
| 185
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/EncodingConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.configuration.cache.EncodingConfiguration.MEDIA_TYPE;
import static org.infinispan.util.logging.Log.CONFIG;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.parsing.Element;
/**
* @since 9.2
*/
public class EncodingConfigurationBuilder extends AbstractConfigurationChildBuilder implements Builder<EncodingConfiguration> {
private ContentTypeConfigurationBuilder keyContentTypeBuilder = new ContentTypeConfigurationBuilder(Element.KEY_DATA_TYPE, this);
private ContentTypeConfigurationBuilder valueContentTypeBuilder = new ContentTypeConfigurationBuilder(Element.VALUE_DATA_TYPE, this);
private final Attribute<MediaType> mediaType;
private final AttributeSet attributes;
EncodingConfigurationBuilder(ConfigurationBuilder builder) {
super(builder);
attributes = EncodingConfiguration.attributeDefinitionSet();
mediaType = attributes.attribute(MEDIA_TYPE);
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public void validate() {
MediaType globalMediaType = mediaType.get();
if (globalMediaType != null) {
MediaType keyType = keyContentTypeBuilder.mediaType();
MediaType valueType = valueContentTypeBuilder.mediaType();
if ((keyType != null && !keyType.equals(globalMediaType)) || valueType != null && !valueType.equals(globalMediaType)) {
CONFIG.ignoringSpecificMediaTypes();
}
}
keyContentTypeBuilder.validate();
valueContentTypeBuilder.validate();
}
public boolean isObjectStorage() {
if (!mediaType.isNull()) {
return MediaType.APPLICATION_OBJECT.match(mediaType.get());
} else {
return keyContentTypeBuilder.isObjectStorage() && valueContentTypeBuilder.isObjectStorage();
}
}
public ContentTypeConfigurationBuilder key() {
return keyContentTypeBuilder;
}
public ContentTypeConfigurationBuilder value() {
return valueContentTypeBuilder;
}
public EncodingConfigurationBuilder mediaType(String keyValueMediaType) {
mediaType.set(MediaType.fromString(keyValueMediaType));
return this;
}
public EncodingConfigurationBuilder mediaType(MediaType keyValueMediaType) {
mediaType.set(keyValueMediaType);
return this;
}
public boolean isStorageBinary() {
// global takes precedence
if (!mediaType.isNull()) {
return mediaType.get().isBinary();
} else {
MediaType keyMediaType = keyContentTypeBuilder.mediaType();
MediaType valueMediaType = valueContentTypeBuilder.mediaType();
return keyMediaType != null && valueMediaType != null &&
keyMediaType.isBinary() && valueMediaType.isBinary();
}
}
@Override
public EncodingConfiguration create() {
MediaType globalType = mediaType.get();
ContentTypeConfiguration keyContentType = keyContentTypeBuilder.create(globalType);
ContentTypeConfiguration valueContentType = valueContentTypeBuilder.create(globalType);
return new EncodingConfiguration(attributes.protect(), keyContentType, valueContentType);
}
@Override
public Builder<?> read(EncodingConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.keyContentTypeBuilder = new ContentTypeConfigurationBuilder(Element.KEY_DATA_TYPE, this).read(template.keyDataType(), combine);
this.valueContentTypeBuilder = new ContentTypeConfigurationBuilder(Element.VALUE_DATA_TYPE, this).read(template.valueDataType(), combine);
return this;
}
@Override
public String toString() {
return "EncodingConfigurationBuilder{" +
"keyContentTypeBuilder=" + keyContentTypeBuilder +
", valueContentTypeBuilder=" + valueContentTypeBuilder +
", attributes=" + attributes +
'}';
}
}
| 4,245
| 36.910714
| 144
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/ExpirationConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.configuration.cache.ExpirationConfiguration.LIFESPAN;
import static org.infinispan.configuration.cache.ExpirationConfiguration.MAX_IDLE;
import static org.infinispan.configuration.cache.ExpirationConfiguration.REAPER_ENABLED;
import static org.infinispan.configuration.cache.ExpirationConfiguration.TOUCH;
import static org.infinispan.configuration.cache.ExpirationConfiguration.WAKEUP_INTERVAL;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.expiration.TouchMode;
import org.infinispan.util.logging.Log;
/**
* Controls the default expiration settings for entries in the cache.
*/
public class ExpirationConfigurationBuilder extends AbstractConfigurationChildBuilder implements Builder<ExpirationConfiguration> {
private final AttributeSet attributes;
ExpirationConfigurationBuilder(ConfigurationBuilder builder) {
super(builder);
attributes = ExpirationConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in
* milliseconds. -1 means the entries never expire.
*
* Note that this can be overridden on a per-entry basis by using the Cache API.
*/
public ExpirationConfigurationBuilder lifespan(long l) {
attributes.attribute(LIFESPAN).set(l);
return this;
}
/**
* Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in
* milliseconds. -1 means the entries never expire.
*
* Note that this can be overridden on a per-entry basis by using the Cache API.
*/
public ExpirationConfigurationBuilder lifespan(long l, TimeUnit unit) {
return lifespan(unit.toMillis(l));
}
/**
* Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle
* time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
*
* Note that this can be overridden on a per-entry basis by using the Cache API.
*/
public ExpirationConfigurationBuilder maxIdle(long l) {
attributes.attribute(MAX_IDLE).set(l);
return this;
}
/**
* Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle
* time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
* <p>
* Note that this can be overridden on a per-entry basis by using the Cache API.
*/
public ExpirationConfigurationBuilder maxIdle(long l, TimeUnit unit) {
return maxIdle(unit.toMillis(l));
}
/**
* Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle
* time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
*
* @return the max idle setting, default is -1 for disabled
*/
public long maxIdle() {
return attributes.attribute(MAX_IDLE).get();
}
/**
* Enable the background reaper to test entries for expiration.
* Regardless of whether a reaper is used, entries are tested for expiration lazily when they are
* touched.
*/
public ExpirationConfigurationBuilder enableReaper() {
attributes.attribute(REAPER_ENABLED).set(true);
return this;
}
/**
* Enable the background reaper to test entries for expiration.
* Regardless of whether a reaper is used, entries are tested for expiration lazily when they are
* touched.
*/
public ExpirationConfigurationBuilder reaperEnabled(boolean enabled) {
attributes.attribute(REAPER_ENABLED).set(enabled);
return this;
}
/**
* Disable the background reaper to test entries for expiration. to test entries for expiration.
* Regardless of whether a reaper is used, entries are tested for expiration lazily when they are
* touched.
*/
public ExpirationConfigurationBuilder disableReaper() {
attributes.attribute(REAPER_ENABLED).set(false);
return this;
}
public boolean reaperEnabled() {
return attributes.attribute(REAPER_ENABLED).get();
}
/**
* Interval (in milliseconds) between subsequent runs to purge expired entries from memory and
* any cache stores. If you wish to disable the periodic eviction process altogether, set
* wakeupInterval to -1.
*/
public ExpirationConfigurationBuilder wakeUpInterval(long l) {
attributes.attribute(WAKEUP_INTERVAL).set(l);
return this;
}
public long wakeupInterval() {
return attributes.attribute(WAKEUP_INTERVAL).get();
}
/**
* Interval (in milliseconds) between subsequent runs to purge expired entries from memory and
* any cache stores. If you wish to disable the periodic eviction process altogether, set
* wakeupInterval to -1.
*/
public ExpirationConfigurationBuilder wakeUpInterval(long l, TimeUnit unit) {
return wakeUpInterval(unit.toMillis(l));
}
/**
* Control how the timestamp of read keys are updated on all the key owners in a cluster.
*
* Default is {@link TouchMode#SYNC}.
* If the cache mode is ASYNC this attribute is ignored, and timestamps are updated asynchronously.
*/
public ExpirationConfigurationBuilder touch(TouchMode touchMode) {
attributes.attribute(TOUCH).set(touchMode);
return this;
}
@Override
public void validate() {
Attribute<TouchMode> touch = attributes.attribute(TOUCH);
Objects.requireNonNull(touch.get());
if (touch.isModified() && touch.get() == TouchMode.SYNC && !clustering().cacheMode().isSynchronous()) {
throw Log.CONFIG.invalidTouchMode(clustering().cacheMode());
}
}
@Override
public void validate(GlobalConfiguration globalConfig) {
}
@Override
public ExpirationConfiguration create() {
return new ExpirationConfiguration(attributes.protect());
}
@Override
public ExpirationConfigurationBuilder read(ExpirationConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return this.getClass().getSimpleName() + attributes;
}
}
| 6,656
| 34.59893
| 131
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/AbstractClusteringConfigurationChildBuilder.java
|
package org.infinispan.configuration.cache;
abstract class AbstractClusteringConfigurationChildBuilder extends AbstractConfigurationChildBuilder implements ClusteringConfigurationChildBuilder {
private final ClusteringConfigurationBuilder clusteringBuilder;
protected AbstractClusteringConfigurationChildBuilder(ClusteringConfigurationBuilder builder) {
super(builder.getBuilder());
this.clusteringBuilder = builder;
}
@Override
public HashConfigurationBuilder hash() {
return clusteringBuilder.hash();
}
@Override
public L1ConfigurationBuilder l1() {
return clusteringBuilder.l1();
}
@Override
public StateTransferConfigurationBuilder stateTransfer() {
return clusteringBuilder.stateTransfer();
}
@Override
public PartitionHandlingConfigurationBuilder partitionHandling() {
return clusteringBuilder.partitionHandling();
}
protected ClusteringConfigurationBuilder getClusteringBuilder() {
return clusteringBuilder;
}
}
| 1,021
| 26.621622
| 149
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/IndexStartupMode.java
|
package org.infinispan.configuration.cache;
import java.util.Arrays;
import org.infinispan.util.logging.Log;
/**
* Allows to define some mass indexing operations (e.g.: purge or reindex) to trigger when the cache starts.
* These actions are usually needed to keep data and indexes aligned (consistent).
*
* @author Fabio Massimo Ercoli <fabiomassimo.ercoli@gmail.com>
* @since 14.0
*/
public enum IndexStartupMode {
/**
* Purge will be triggered at cache startup time.
*/
PURGE,
/**
* Reindex will be triggered at cache startup time.
*/
REINDEX,
/**
* With this configuration Infinispan will try to run the right action to align cache data and indexes.
* Purge will be triggered if the cache data is volatile and indexes are not.
* Reindex will be triggered if the cache data is not volatile and indexes are.
*/
AUTO,
/**
* No mass-indexing operation is triggered at cache startup time. This is the default.
*/
NONE;
public static IndexStartupMode requireValid(String value, Log logger) {
return Arrays.stream(IndexStartupMode.values())
.filter(i -> i.name().equalsIgnoreCase(value))
.findFirst()
.orElseThrow(() -> logger.invalidIndexStartUpMode(value));
}
}
| 1,292
| 27.733333
| 108
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/IndexShardingConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.configuration.cache.IndexShardingConfiguration.SHARDS;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 15.0
*/
public class IndexShardingConfigurationBuilder extends AbstractIndexingConfigurationChildBuilder
implements Builder<IndexShardingConfiguration> {
private final AttributeSet attributes;
private final Attribute<Integer> shards;
IndexShardingConfigurationBuilder(IndexingConfigurationBuilder builder) {
super(builder);
this.attributes = IndexShardingConfiguration.attributeDefinitionSet();
this.shards = attributes.attribute(SHARDS);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public IndexShardingConfigurationBuilder shards(int value) {
shards.set(value);
return this;
}
@Override
public IndexShardingConfiguration create() {
return new IndexShardingConfiguration(attributes.protect());
}
@Override
public IndexShardingConfigurationBuilder read(IndexShardingConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "IndexShardingConfigurationBuilder{" +
"attributes=" + attributes +
'}';
}
}
| 1,560
| 28.45283
| 104
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/ClusteringConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.configuration.cache.ClusteringConfiguration.CACHE_SYNC;
import static org.infinispan.configuration.cache.ClusteringConfiguration.CACHE_TYPE;
import static org.infinispan.configuration.cache.ClusteringConfiguration.REMOTE_TIMEOUT;
import static org.infinispan.util.logging.Log.CONFIG;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.partitionhandling.PartitionHandling;
/**
* Defines clustered characteristics of the cache.
*
* @author pmuir
*
*/
public class ClusteringConfigurationBuilder extends AbstractConfigurationChildBuilder implements
ClusteringConfigurationChildBuilder, Builder<ClusteringConfiguration> {
private final HashConfigurationBuilder hashConfigurationBuilder;
private final L1ConfigurationBuilder l1ConfigurationBuilder;
private final StateTransferConfigurationBuilder stateTransferConfigurationBuilder;
private final PartitionHandlingConfigurationBuilder partitionHandlingConfigurationBuilder;
final AttributeSet attributes;
ClusteringConfigurationBuilder(ConfigurationBuilder builder) {
super(builder);
this.attributes = ClusteringConfiguration.attributeDefinitionSet();
this.hashConfigurationBuilder = new HashConfigurationBuilder(this);
this.l1ConfigurationBuilder = new L1ConfigurationBuilder(this);
this.stateTransferConfigurationBuilder = new StateTransferConfigurationBuilder(this);
this.partitionHandlingConfigurationBuilder = new PartitionHandlingConfigurationBuilder(this);
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Cache mode. See {@link CacheMode} for information on the various cache modes available.
*/
public ClusteringConfigurationBuilder cacheMode(CacheMode cacheMode) {
cacheType(cacheMode.cacheType());
cacheSync(cacheMode.isSynchronous());
return this;
}
public CacheMode cacheMode() {
return CacheMode.of(attributes.attribute(CACHE_TYPE).get(), attributes.attribute(CACHE_SYNC).get());
}
public ClusteringConfigurationBuilder cacheType(CacheType type) {
attributes.attribute(CACHE_TYPE).set(type);
return this;
}
public ClusteringConfigurationBuilder cacheSync(boolean sync) {
attributes.attribute(CACHE_SYNC).set(sync);
return this;
}
/**
* This is the timeout used to wait for an acknowledgment when making a remote call, after which
* the call is aborted and an exception is thrown.
*/
public ClusteringConfigurationBuilder remoteTimeout(long l) {
attributes.attribute(REMOTE_TIMEOUT).set(l);
return this;
}
/**
* This is the timeout used to wait for an acknowledgment when making a remote call, after which
* the call is aborted and an exception is thrown.
*/
public ClusteringConfigurationBuilder remoteTimeout(long l, TimeUnit unit) {
return remoteTimeout(unit.toMillis(l));
}
/**
* Configure hash sub element
*/
@Override
public HashConfigurationBuilder hash() {
return hashConfigurationBuilder;
}
/**
* This method allows configuration of the L1 cache for distributed
* caches. L1 should be explicitly enabled by calling {@link L1ConfigurationBuilder#enable()}
*/
@Override
public L1ConfigurationBuilder l1() {
return l1ConfigurationBuilder;
}
/**
* Configure the {@code stateTransfer} sub element for distributed and replicated caches.
* It doesn't have any effect on LOCAL or INVALIDATION-mode caches.
*/
@Override
public StateTransferConfigurationBuilder stateTransfer() {
return stateTransferConfigurationBuilder;
}
@Override
public PartitionHandlingConfigurationBuilder partitionHandling() {
return partitionHandlingConfigurationBuilder;
}
@Override
public void validate() {
for (Builder<?> validatable : Arrays.asList(hashConfigurationBuilder, l1ConfigurationBuilder,
stateTransferConfigurationBuilder, partitionHandlingConfigurationBuilder)) {
validatable.validate();
}
if (hash().numOwners() == 1 && partitionHandling().whenSplit() != PartitionHandling.ALLOW_READ_WRITES)
throw CONFIG.singleOwnerNotSetToAllowReadWrites();
}
@Override
public void validate(GlobalConfiguration globalConfig) {
if (cacheMode().isClustered() && globalConfig.transport().transport() == null && !builder.template()) {
throw CONFIG.missingTransportConfiguration();
}
for (ConfigurationChildBuilder validatable : Arrays
.asList(hashConfigurationBuilder, l1ConfigurationBuilder, stateTransferConfigurationBuilder, partitionHandlingConfigurationBuilder)) {
validatable.validate(globalConfig);
}
}
@Override
public
ClusteringConfiguration create() {
return new ClusteringConfiguration(attributes.protect(), hashConfigurationBuilder.create(),
l1ConfigurationBuilder.create(), stateTransferConfigurationBuilder.create(), partitionHandlingConfigurationBuilder.create());
}
@Override
public ClusteringConfigurationBuilder read(ClusteringConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
hashConfigurationBuilder.read(template.hash(), combine);
l1ConfigurationBuilder.read(template.l1(), combine);
stateTransferConfigurationBuilder.read(template.stateTransfer(), combine);
partitionHandlingConfigurationBuilder.read(template.partitionHandling(), combine);
return this;
}
@Override
public String toString() {
return "ClusteringConfigurationBuilder [hashConfigurationBuilder=" + hashConfigurationBuilder +
", l1ConfigurationBuilder=" + l1ConfigurationBuilder +
", stateTransferConfigurationBuilder=" + stateTransferConfigurationBuilder +
", partitionHandlingConfigurationBuilder=" + partitionHandlingConfigurationBuilder +
", attributes=" + attributes + "]";
}
}
| 6,319
| 37.072289
| 146
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/HashConfiguration.java
|
package org.infinispan.configuration.cache;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSerializer;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.distribution.ch.ConsistentHash;
import org.infinispan.distribution.ch.ConsistentHashFactory;
import org.infinispan.distribution.ch.KeyPartitioner;
import org.infinispan.distribution.ch.impl.HashFunctionPartitioner;
/**
* Allows fine-tuning of rehashing characteristics. Must only used with 'distributed' cache mode.
*
* @author pmuir
*/
public class HashConfiguration extends ConfigurationElement<HashConfiguration> {
public static final AttributeDefinition<ConsistentHashFactory> CONSISTENT_HASH_FACTORY = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.CONSISTENT_HASH_FACTORY, null, ConsistentHashFactory.class)
.serializer(AttributeSerializer.INSTANCE_CLASS_NAME).immutable().build();
public static final AttributeDefinition<Integer> NUM_OWNERS = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.OWNERS , 2).immutable().build();
// Because it assigns owners randomly, SyncConsistentHashFactory doesn't work very well with a low number
// of segments. (With DefaultConsistentHashFactory, 60 segments was ok up to 6 nodes.)
public static final AttributeDefinition<Integer> NUM_SEGMENTS = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.SEGMENTS, 256).immutable().build();
public static final AttributeDefinition<Float> CAPACITY_FACTOR= AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.CAPACITY_FACTOR, 1.0f).immutable().global(false).build();
public static final AttributeDefinition<KeyPartitioner> KEY_PARTITIONER = AttributeDefinition
.builder(org.infinispan.configuration.parsing.Attribute.KEY_PARTITIONER, HashFunctionPartitioner.instance(NUM_SEGMENTS.getDefaultValue()), KeyPartitioner.class)
.copier(original -> {
KeyPartitioner copy = Util.getInstance(original.getClass());
copy.init(original);
return copy;
})
.serializer(AttributeSerializer.INSTANCE_CLASS_NAME)
.immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(HashConfiguration.class, CONSISTENT_HASH_FACTORY, NUM_OWNERS,
NUM_SEGMENTS, CAPACITY_FACTOR, KEY_PARTITIONER);
}
private final Attribute<ConsistentHashFactory> consistentHashFactory;
private final Attribute<Integer> numOwners;
private final Attribute<Integer> numSegments;
private final Attribute<Float> capacityFactor;
private final Attribute<KeyPartitioner> keyPartitioner;
private final GroupsConfiguration groupsConfiguration;
HashConfiguration(AttributeSet attributes, GroupsConfiguration groupsConfiguration) {
super(Element.HASH, attributes);
this.groupsConfiguration = groupsConfiguration;
consistentHashFactory = attributes.attribute(CONSISTENT_HASH_FACTORY);
numOwners = attributes.attribute(NUM_OWNERS);
numSegments = attributes.attribute(NUM_SEGMENTS);
capacityFactor = attributes.attribute(CAPACITY_FACTOR);
keyPartitioner = attributes.attribute(KEY_PARTITIONER);
}
/**
* The consistent hash factory in use.
* @deprecated Since 11.0. Will be removed in 14.0, the segment allocation will no longer be customizable.
*/
@Deprecated
public ConsistentHashFactory<?> consistentHashFactory() {
return consistentHashFactory.get();
}
/**
* Number of cluster-wide replicas for each cache entry.
*/
public int numOwners() {
return numOwners.get();
}
/**
* Controls the total number of hash space segments (per cluster).
*
* <p>A hash space segment is the granularity for key distribution in the cluster: a node can own
* (or primary-own) one or more full segments, but not a fraction of a segment.
* As such, very small {@code numSegments} values (< 10 segments per node) will make
* the distribution of keys between nodes more uneven.</p>
* <p>The recommended value is 20 * the expected cluster size.</p>
* <p>Note: The value returned by {@link ConsistentHash#getNumSegments()} may be different,
* e.g. rounded up to a power of 2.</p>
*/
public int numSegments() {
return numSegments.get();
}
/**
* Controls the proportion of entries that will reside on the local node, compared to the other nodes in the
* cluster. This is just a suggestion, there is no guarantee that a node with a capacity factor of {@code 2} will
* have twice as many entries as a node with a capacity factor of {@code 1}.
*/
public float capacityFactor() {
return capacityFactor.get();
}
public KeyPartitioner keyPartitioner() {
return keyPartitioner.get();
}
/**
* Configuration for various grouper definitions. See the user guide for more information.
*/
public GroupsConfiguration groups() {
return groupsConfiguration;
}
}
| 5,393
| 47.160714
| 226
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/MemoryConfigurationBuilder.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.util.logging.Log.CONFIG;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeListener;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.eviction.EvictionStrategy;
import org.infinispan.eviction.EvictionType;
/**
* Controls the data container for the cache.
*
* @author William Burns
*/
public class MemoryConfigurationBuilder extends AbstractConfigurationChildBuilder implements
Builder<MemoryConfiguration> {
private MemoryStorageConfigurationBuilder legacyBuilder;
private final AttributeSet attributes;
private final List<String> legacyAttributesUsed = new ArrayList<>();
private boolean newAttributesUsed = false;
private boolean isInListener = false;
MemoryConfigurationBuilder(ConfigurationBuilder builder) {
super(builder);
this.legacyBuilder = new MemoryStorageConfigurationBuilder(builder);
this.attributes = MemoryConfiguration.attributeDefinitionSet();
// Keep new and legacy attributes in sync
// Only attribute listeners are invoked when parsing JSON
attributes.attribute(MemoryConfiguration.STORAGE)
.addListener(nonReentrantListener((attribute, oldValue) -> {
memoryStorageAttribute(MemoryStorageConfiguration.STORAGE_TYPE).set(attribute.get());
}));
attributes.attribute(MemoryConfiguration.WHEN_FULL)
.addListener(nonReentrantListener((attribute, oldValue) -> {
memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_STRATEGY).set(attribute.get());
}));
attributes.attribute(MemoryConfiguration.MAX_COUNT)
.addListener(nonReentrantListener((attribute, oldValue) -> {
updateMaxCount(attribute.get());
}));
attributes.attribute(MemoryConfiguration.MAX_SIZE)
.addListener(nonReentrantListener((attribute, oldValue) -> {
updateMaxSize(attribute.get());
}));
memoryStorageAttribute(MemoryStorageConfiguration.STORAGE_TYPE)
.addListener(nonReentrantListener((attribute, oldValue) -> {
attributes.attribute(MemoryConfiguration.STORAGE).set(attribute.get());
}));
memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_STRATEGY)
.addListener(nonReentrantListener((attribute, oldValue) -> {
attributes.attribute(MemoryConfiguration.WHEN_FULL).set(attribute.get());
}));
memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_TYPE)
.addListener(nonReentrantListener((attribute, oldValue) -> {
long size = memoryStorageAttribute(MemoryStorageConfiguration.SIZE).get();
if (size == -1)
return;
updateLegacySize(attribute.get(), size);
}));
memoryStorageAttribute(MemoryStorageConfiguration.SIZE)
.addListener(nonReentrantListener((attribute, oldValue) -> {
EvictionType evictionType = memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_TYPE).get();
updateLegacySize(evictionType, attribute.get());
}));
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Deprecated
public MemoryStorageConfigurationBuilder legacyBuilder() {
return legacyBuilder;
}
private <T> AttributeListener<T> nonReentrantListener(AttributeListener<T> listener) {
return ((attribute, oldValue) -> {
if (isInListener)
return;
isInListener = true;
try {
listener.attributeChanged(attribute, oldValue);
} finally {
isInListener = false;
}
});
}
/**
* Set the {@link StorageType} to determine how the data is stored in the data container.
* @param storageType the storage type of the underlying data
* @return this configuration builder
* @deprecated Since 11.0, use {@link #storage(StorageType)} instead.
*/
@Deprecated
public MemoryConfigurationBuilder storageType(StorageType storageType) {
return storage(storageType);
}
public MemoryConfigurationBuilder storage(StorageType storageType) {
attributes.attribute(MemoryConfiguration.STORAGE).set(storageType);
return this;
}
public MemoryConfigurationBuilder maxSize(String size) {
newAttributesUsed = true;
attributes.attribute(MemoryConfiguration.MAX_SIZE).set(size);
return this;
}
public String maxSize() {
return attributes.attribute(MemoryConfiguration.MAX_SIZE).get();
}
public MemoryConfigurationBuilder maxCount(long count) {
newAttributesUsed = true;
attributes.attribute(MemoryConfiguration.MAX_COUNT).set(count);
return this;
}
public long maxCount() {
return attributes.attribute(MemoryConfiguration.MAX_COUNT).get();
}
/**
* The underlying storage type for this configuration
* @return the configured storage type
* @deprecated Since 11.0, use {@link #storage()} instead.
*/
@Deprecated
public StorageType storageType() {
return storage();
}
public StorageType storage() {
return attributes.attribute(MemoryConfiguration.STORAGE).get();
}
/**
* Defines the maximum size before eviction occurs. See {@link #evictionType(EvictionType)}
* for more details on the size is interpreted.
*
* If {@link #evictionStrategy(EvictionStrategy)} has not been invoked, this will set the strategy to
* {@link EvictionStrategy#REMOVE}.
*
* @param size the maximum size for the container
* @deprecated Since 11.0, use {@link #maxSize(String)} to define the size in bytes or {@link #maxCount(long)}
* to define the number of entries.
*/
@Deprecated
public MemoryConfigurationBuilder size(long size) {
legacyAttributesUsed.add(MemoryStorageConfiguration.SIZE.name());
memoryStorageAttribute(MemoryStorageConfiguration.SIZE).set(size);
return this;
}
/**
* The configured eviction size, please see {@link MemoryConfigurationBuilder#size(long)}.
* @return the configured evicted size
* @deprecated Since 11.0, use either {@link #maxSize()} or {@link #maxCount()}.
*/
@Deprecated
public long size() {
return memoryStorageAttribute(MemoryStorageConfiguration.SIZE).get();
}
/**
* Sets the eviction type which can either be
* <ul>
* <li>COUNT - entries will be evicted when the number of entries exceeds the {@link #size(long)}</li>
* <li>MEMORY - entries will be evicted when the approximate combined size of all values exceeds the {@link #size(long)}</li>
* </ul>
*
* Cache size is guaranteed not to exceed upper
* limit specified by size.
*
* @param type
* @deprecated since 11.0, use {@link #maxCount(long)} or {@link #maxSize(String)} to define data container bounds
* by size or by count.
*/
@Deprecated
public MemoryConfigurationBuilder evictionType(EvictionType type) {
legacyAttributesUsed.add(MemoryStorageConfiguration.EVICTION_TYPE.name());
memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_TYPE).set(type);
return this;
}
private <T> Attribute<T> memoryStorageAttribute(AttributeDefinition<T> attributeDefinition) {
return legacyBuilder.attributes.attribute(attributeDefinition);
}
/**
* The configured eviction type, please see {@link MemoryConfigurationBuilder#evictionType(EvictionType)}.
*
* @return the configured eviction type
* @deprecated since 11.0, @see {@link #evictionType(EvictionType)}
*/
@Deprecated
public EvictionType evictionType() {
return memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_TYPE).get();
}
/**
* Sets the eviction strategy which can be:
* <ul>
* <li>NONE - no eviction will take place</li>
* <li>MANUAL - no eviction will take place automatically, but user is assumed to manually call evict</li>
* <li>REMOVE - eviction will remove entries to make room for new entries to be inserted</li>
* <li>EXCEPTION - eviction will not take place, but instead an exception will be thrown to ensure container doesn't grow too large</li>
* </ul>
*
* The eviction strategy NONE and MANUAL are essentially the same except that MANUAL does not warn the user
* when passivation is enabled.
* @param strategy the strategy to set
* @return this
* @deprecated Since 11.0, use {@link #whenFull(EvictionStrategy)} instead.
*/
@Deprecated
public MemoryConfigurationBuilder evictionStrategy(EvictionStrategy strategy) {
return whenFull(strategy);
}
public MemoryConfigurationBuilder whenFull(EvictionStrategy strategy) {
attributes.attribute(MemoryConfiguration.WHEN_FULL).set(strategy);
return this;
}
public EvictionStrategy whenFull() {
return attributes.attribute(MemoryConfiguration.WHEN_FULL).get();
}
/**
* The configured eviction strategy, please see {@link MemoryConfigurationBuilder#evictionStrategy(EvictionStrategy)}.
* @return the configured eviction stategy
* @deprecated Since 11.0, use {@link #whenFull()} instead.
*/
@Deprecated
public EvictionStrategy evictionStrategy() {
return whenFull();
}
boolean isSizeBounded() {
return maxSize() != null;
}
boolean isCountBounded() {
return maxCount() > 0;
}
private void checkBinaryRequirement() {
if (!storageType().canStoreReferences()) {
if (getBuilder().clustering().hash().groups().isEnabled()) {
throw CONFIG.groupingOnlyCompatibleWithObjectStorage(encoding().key().mediaType(), encoding().value().mediaType());
}
}
boolean storageBinary = encoding().isStorageBinary() || !storageType().canStoreReferences();
if (isSizeBounded() && !storageBinary) {
throw CONFIG.offHeapMemoryEvictionNotSupportedWithObject();
}
}
@Override
public void validate() {
if (newAttributesUsed && !legacyAttributesUsed.isEmpty()) {
// Prevent mixing of old and new attributes
throw CONFIG.cannotUseDeprecatedAndReplacement(legacyAttributesUsed.toString());
}
if (isSizeBounded() && isCountBounded()) {
throw CONFIG.cannotProvideBothSizeAndCount();
}
EvictionStrategy strategy = evictionStrategy();
if (strategy.isEnabled()) {
if (!isCountBounded() && !isSizeBounded()) {
throw CONFIG.invalidEvictionSize();
}
if (strategy.isExceptionBased()) {
TransactionConfigurationBuilder transactionConfiguration = getBuilder().transaction();
org.infinispan.transaction.TransactionMode transactionMode = transactionConfiguration.transactionMode();
if (transactionMode == null || !transactionMode.isTransactional() ||
transactionConfiguration.useSynchronization() ||
transactionConfiguration.use1PcForAutoCommitTransactions()) {
throw CONFIG.exceptionBasedEvictionOnlySupportedInTransactionalCaches();
}
}
} else {
if (getBuilder().persistence().passivation() && strategy != EvictionStrategy.MANUAL &&
!getBuilder().template()) {
// maxSize of maxCount would automatically set evictionStrategy(REMOVAL)
if (!isSizeBounded() && !isCountBounded()) {
CONFIG.passivationWithoutEviction();
}
}
}
checkBinaryRequirement();
}
@Override
public void validate(GlobalConfiguration globalConfig) {
}
@Override
public MemoryConfiguration create() {
Attribute<EvictionStrategy> whenFull = attributes.attribute(MemoryConfiguration.WHEN_FULL);
if (!whenFull.get().isEnabled()) {
if (isSizeBounded() || isCountBounded()) {
whenFull.setImplied(EvictionStrategy.REMOVE);
if (isCountBounded()) {
CONFIG.debugf("Max entries configured (%d) without eviction strategy. Eviction strategy overridden to %s", maxCount(), whenFull.get());
} else {
CONFIG.debugf("Max size configured (%s) without eviction strategy. Eviction strategy overridden to %s", maxSize(), whenFull.get());
}
}
}
return new MemoryConfiguration(attributes.protect(), legacyBuilder.create());
}
@Override
public MemoryConfigurationBuilder read(MemoryConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
// Propagate any changes to the MemoryStorageConfiguration attributes,
// because reading an attribute does not invoke the listener
// There's no need to do the reverse, since the new and legacy attributes
// are in sync at build time
if (attributes.attribute(MemoryConfiguration.STORAGE).isModified()) {
memoryStorageAttribute(MemoryStorageConfiguration.STORAGE_TYPE).set(storage());
}
if (attributes.attribute(MemoryConfiguration.WHEN_FULL).isModified()) {
memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_STRATEGY).set(whenFull());
}
if (attributes.attribute(MemoryConfiguration.MAX_COUNT).isModified()) {
updateMaxCount(maxCount());
}
if (attributes.attribute(MemoryConfiguration.MAX_SIZE).isModified()) {
updateMaxSize(maxSize());
}
return this;
}
private void updateMaxSize(String maxSize) {
Attribute<EvictionType> evictionTypeAttribute =
memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_TYPE);
if (maxSize != null && evictionTypeAttribute.get() != EvictionType.MEMORY) {
evictionTypeAttribute.set(EvictionType.MEMORY);
}
if (maxSize != null || maxCount() == -1L) {
// Either the new maxSize is valid or both maxSize and maxCount are -1
long maxSizeBytes = MemoryConfiguration.maxSizeToBytes(maxSize);
memoryStorageAttribute(MemoryStorageConfiguration.SIZE).set(maxSizeBytes);
}
}
private void updateMaxCount(long maxCount) {
Attribute<EvictionType> evictionTypeAttribute =
memoryStorageAttribute(MemoryStorageConfiguration.EVICTION_TYPE);
if (maxCount != -1 && evictionTypeAttribute.get() != EvictionType.COUNT) {
evictionTypeAttribute.set(EvictionType.COUNT);
}
if (maxCount != -1L || maxSize() == null) {
// Either the new maxCount is valid or both maxSize and maxCount are -1
memoryStorageAttribute(MemoryStorageConfiguration.SIZE).set(maxCount);
}
}
private void updateLegacySize(EvictionType type, Long size) {
switch (type) {
case COUNT:
if (attributes.attribute(MemoryConfiguration.MAX_SIZE).get() != null) {
attributes.attribute(MemoryConfiguration.MAX_SIZE).reset();
}
attributes.attribute(MemoryConfiguration.MAX_COUNT).set(size);
break;
case MEMORY:
if (attributes.attribute(MemoryConfiguration.MAX_COUNT).get() != -1L) {
attributes.attribute(MemoryConfiguration.MAX_COUNT).reset();
}
String maxSize = attributes.attribute(MemoryConfiguration.MAX_SIZE).get();
long maxSizeBytes = MemoryConfiguration.maxSizeToBytes(maxSize);
if (maxSizeBytes != size) {
attributes.attribute(MemoryConfiguration.MAX_SIZE).set(String.valueOf(size));
}
break;
default:
throw new IllegalArgumentException();
}
}
@Override
public String toString() {
return "MemoryConfigurationBuilder{" +
"memoryStorageConfigurationBuilder=" + legacyBuilder +
", attributes=" + attributes +
'}';
}
}
| 16,464
| 39.060827
| 150
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/RecoveryConfiguration.java
|
package org.infinispan.configuration.cache;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Element;
/**
* Defines recovery configuration for the cache.
*
* @author pmuir
*
*/
public class RecoveryConfiguration extends ConfigurationElement<RecoveryConfiguration> {
public static final String DEFAULT_RECOVERY_INFO_CACHE = "__recoveryInfoCacheName__";
public static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.ENABLED, false).autoPersist(false).immutable().build();
public static final AttributeDefinition<String> RECOVERY_INFO_CACHE_NAME = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.RECOVERY_INFO_CACHE_NAME, DEFAULT_RECOVERY_INFO_CACHE).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RecoveryConfiguration.class, ENABLED, RECOVERY_INFO_CACHE_NAME);
}
private final Attribute<Boolean> enabled;
private final Attribute<String> recoveryInfoCacheName;
RecoveryConfiguration(AttributeSet attributes) {
super(Element.RECOVERY, attributes);
enabled = attributes.attribute(ENABLED);
recoveryInfoCacheName = attributes.attribute(RECOVERY_INFO_CACHE_NAME);
}
/**
* Determines if recovery is enabled for the cache.
*/
public boolean enabled() {
return enabled.get();
}
/**
* Sets the name of the cache where recovery related information is held. If not specified
* defaults to a cache named {@link RecoveryConfiguration#DEFAULT_RECOVERY_INFO_CACHE}
*/
public String recoveryInfoCacheName() {
return recoveryInfoCacheName.get();
}
}
| 1,971
| 40.957447
| 228
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/ClusteringConfiguration.java
|
package org.infinispan.configuration.cache;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Element;
/**
* Defines clustered characteristics of the cache.
*
* @author pmuir
*
*/
public class ClusteringConfiguration extends ConfigurationElement<ClusteringConfiguration> {
public static final AttributeDefinition<CacheType> CACHE_TYPE = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.TYPE, CacheType.LOCAL).immutable().autoPersist(false).build();
public static final AttributeDefinition<Boolean> CACHE_SYNC = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.MODE, true, Boolean.class).immutable().autoPersist(false).build();
public static final AttributeDefinition<Long> REMOTE_TIMEOUT =
AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.REMOTE_TIMEOUT, TimeUnit.SECONDS.toMillis(15)).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ClusteringConfiguration.class, CACHE_TYPE, CACHE_SYNC, REMOTE_TIMEOUT);
}
private final CacheMode cacheMode;
private final Attribute<Long> remoteTimeout;
private final HashConfiguration hashConfiguration;
private final L1Configuration l1Configuration;
private final StateTransferConfiguration stateTransferConfiguration;
private final PartitionHandlingConfiguration partitionHandlingConfiguration;
ClusteringConfiguration(AttributeSet attributes, HashConfiguration hashConfiguration,
L1Configuration l1Configuration, StateTransferConfiguration stateTransferConfiguration,
PartitionHandlingConfiguration partitionHandlingStrategy) {
super(Element.CLUSTERING, attributes, hashConfiguration, l1Configuration, stateTransferConfiguration, partitionHandlingStrategy);
this.cacheMode = CacheMode.of(attributes.attribute(CACHE_TYPE).get(), attributes.attribute(CACHE_SYNC).get());
this.remoteTimeout = attributes.attribute(REMOTE_TIMEOUT);
this.hashConfiguration = hashConfiguration;
this.l1Configuration = l1Configuration;
this.stateTransferConfiguration = stateTransferConfiguration;
this.partitionHandlingConfiguration = partitionHandlingStrategy;
}
/**
* Cache mode. See {@link CacheMode} for information on the various cache modes available.
*/
public CacheMode cacheMode() {
return cacheMode;
}
/**
* This is the timeout used to wait for an acknowledgment when making a remote call, after which
* the call is aborted and an exception is thrown.
*/
public long remoteTimeout() {
return remoteTimeout.get();
}
/**
* This is the timeout used to wait for an acknowledgment when making a remote call, after which
* the call is aborted and an exception is thrown.
*/
public void remoteTimeout(long timeoutMillis) {
remoteTimeout.set(timeoutMillis);
}
/**
* Configures cluster's behaviour in the presence of partitions or node failures.
*/
public PartitionHandlingConfiguration partitionHandling() {
return partitionHandlingConfiguration;
}
public String cacheModeString() {
return cacheMode() == null ? "none" : cacheMode().toString();
}
/**
* Configure hash sub element
*/
public HashConfiguration hash() {
return hashConfiguration;
}
/**
* This method allows configuration of the L1 cache for distributed caches. When this method is
* called, it automatically enables L1. So, if you want it to be disabled, make sure you call
* {@link org.infinispan.configuration.cache.L1ConfigurationBuilder#disable()}
*/
public L1Configuration l1() {
return l1Configuration;
}
public StateTransferConfiguration stateTransfer() {
return stateTransferConfiguration;
}
}
| 4,161
| 40.207921
| 206
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/StoreConfiguration.java
|
package org.infinispan.configuration.cache;
import java.util.Properties;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* StoreConfiguration contains generic configuration elements available to all the stores.
*
* @author Tristan Tarrant
* @author Mircea Markus
* @since 5.2
*/
public interface StoreConfiguration {
/**
* Configuration for the async cache loader. If enabled, this provides you with asynchronous
* writes to the cache store, giving you 'write-behind' caching.
*/
AsyncStoreConfiguration async();
/**
* If true, purges this cache store when it starts up.
*/
boolean purgeOnStartup();
/**
* If true, fetch persistent state when joining a cluster. If multiple cache stores are chained,
* only one of them can have this property enabled. Persistent state transfer with a shared cache
* store does not make sense, as the same persistent store that provides the data will just end
* up receiving it. Therefore, if a shared cache store is used, the cache will not allow a
* persistent state transfer even if a cache store has this property set to true. Finally,
* setting it to true only makes sense if in a clustered environment, and only 'replication' and
* 'invalidation' cluster modes are supported.
*/
boolean fetchPersistentState();
/**
* If true, any operation that modifies the cache (put, remove, clear, store...etc) won't be
* applied to the cache store. This means that the cache store could become out of sync with the
* cache.
*/
boolean ignoreModifications();
boolean writeOnly();
boolean preload();
boolean shared();
boolean transactional();
int maxBatchSize();
/**
* Whether or not this store is configured to be segmented. For a non shared store this means there will be a separate
* instance of each store for each segment. For shared stores normally this means the store is able to do some
* optimizations based on the segment (ie. select * from table where segment = $1)
* @return whether this store is configured to be segmented
*/
default boolean segmented() {
return false;
}
Properties properties();
AttributeSet attributes();
}
| 2,257
| 31.724638
| 121
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/CustomInterceptorsConfiguration.java
|
package org.infinispan.configuration.cache;
import java.util.Collections;
import java.util.List;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.Matchable;
/**
* Configures custom interceptors to be added to the cache.
*
* @author pmuir
* @deprecated Since 10.0, custom interceptors support will be removed and only modules will be able to define interceptors
*/
@Deprecated
public class CustomInterceptorsConfiguration implements Matchable<CustomInterceptorsConfiguration> {
private List<InterceptorConfiguration> interceptors;
CustomInterceptorsConfiguration(List<InterceptorConfiguration> interceptors) {
this.interceptors = interceptors;
}
CustomInterceptorsConfiguration() {
this(Collections.emptyList());
}
/**
* This specifies a list of {@link InterceptorConfiguration} instances to be referenced when building the interceptor
* chain.
* @return A list of {@link InterceptorConfiguration}s. May be an empty list, will never be null.
*/
public List<InterceptorConfiguration> interceptors() {
return interceptors;
}
public CustomInterceptorsConfiguration interceptors(List<InterceptorConfiguration> interceptors) {
this.interceptors = interceptors;
return this;
}
@Override
public String toString() {
return "[interceptors=" + interceptors + "]";
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
CustomInterceptorsConfiguration that = (CustomInterceptorsConfiguration) o;
if (interceptors != null ? !interceptors.equals(that.interceptors) : that.interceptors != null)
return false;
return true;
}
@Override
public int hashCode() {
return interceptors != null ? interceptors.hashCode() : 0;
}
public AttributeSet attributes() {
return null;
}
}
| 1,995
| 27.927536
| 123
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/AbstractPersistenceConfigurationChildBuilder.java
|
package org.infinispan.configuration.cache;
/**
*
* AbstractPersistenceConfigurationChildBuilder.
*
* @author Tristan Tarrant
* @since 5.2
*/
public abstract class AbstractPersistenceConfigurationChildBuilder extends AbstractConfigurationChildBuilder implements PersistenceConfigurationChildBuilder {
protected AbstractPersistenceConfigurationChildBuilder(PersistenceConfigurationBuilder builder) {
super(builder.getBuilder());
}
}
| 451
| 29.133333
| 158
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/Configurations.java
|
package org.infinispan.configuration.cache;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.internal.PrivateGlobalConfiguration;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.metadata.Metadata;
import org.infinispan.transaction.LockingMode;
import org.infinispan.util.concurrent.IsolationLevel;
/**
* Helper configuration methods.
*
* @author Galder Zamarreño
* @author Pedro Ruivo
* @since 5.2
*/
public class Configurations {
// Suppresses default constructor, ensuring non-instantiability.
private Configurations() {
}
public static boolean isExceptionBasedEviction(Configuration cfg) {
return cfg.memory().size() > 0 && cfg.memory().evictionStrategy().isExceptionBased();
}
public static boolean isOnePhaseCommit(Configuration cfg) {
// Otherwise pessimistic transactions will be one phase commit
if (isExceptionBasedEviction(cfg)) {
return false;
}
return !cfg.clustering().cacheMode().isSynchronous() ||
cfg.transaction().lockingMode() == LockingMode.PESSIMISTIC;
}
public static boolean isTxVersioned(Configuration cfg) {
return cfg.transaction().transactionMode().isTransactional() &&
cfg.transaction().lockingMode() == LockingMode.OPTIMISTIC &&
cfg.locking().isolationLevel() == IsolationLevel.REPEATABLE_READ &&
!cfg.clustering().cacheMode().isInvalidation(); //invalidation can't use versions
}
public static boolean isEmbeddedMode(GlobalConfiguration globalConfiguration) {
PrivateGlobalConfiguration config = globalConfiguration.module(PrivateGlobalConfiguration.class);
return config == null || !config.isServerMode();
}
public static boolean isClustered(GlobalConfiguration globalConfiguration) {
return globalConfiguration.transport().transport() != null;
}
/**
* Returns if the store configuration is a store that is used for state transfer. This is no longer used and will
* return true if the store config is not shared.
*
* @param storeConfiguration Store configuration to check
* @return if the store config can be used for state transfer
* @deprecated since 14.0. Returns true if the store is not shared.
*/
@Deprecated
public static boolean isStateTransferStore(StoreConfiguration storeConfiguration) {
return !storeConfiguration.shared();
}
public static boolean needSegments(Configuration configuration) {
CacheMode cacheMode = configuration.clustering().cacheMode();
boolean transactional = configuration.transaction().transactionMode().isTransactional();
boolean usingSegmentedStore = configuration.persistence().usingSegmentedStore();
return (cacheMode.isReplicated() ||
cacheMode.isDistributed() ||
(cacheMode.isInvalidation() && transactional) ||
usingSegmentedStore);
}
public static Metadata newDefaultMetadata(Configuration configuration) {
return new EmbeddedMetadata.Builder()
.lifespan(configuration.expiration().lifespan())
.maxIdle(configuration.expiration().maxIdle())
.build();
}
}
| 3,226
| 38.353659
| 116
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/StorageType.java
|
package org.infinispan.configuration.cache;
import java.util.HashMap;
import java.util.Map;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.parsing.Element;
/**
* Enumeration defining the various storage types for the data container.
*
* @author wburns
* @since 9.0
*/
public enum StorageType {
/**
* Objects are stored on heap as objects as provided. These are serialized across to other nodes and stored as
* deserialized instances of the object. Equality is defined by the equals method of the implementation class.
* @deprecated since 11.0, use {@link StorageType#HEAP} instead.
*/
@Deprecated
OBJECT(Element.OBJECT),
/**
* Objects are stored on heap. Equality is defined by the equals of the implementation class.
* If the configured {@link MediaType} causes the storage to be byte[], then equality is defined by these
* byte[] instances.
*/
HEAP(Element.HEAP),
/**
* Entries are stored in Java heap but as byte[] instances. This mode has equality defined by the byte[] created from
* the serialized from of the provided object.
* @deprecated since 11.0, with no replacement. Use {@link #HEAP} and the cache's {@link EncodingConfiguration} to
* define a {@link MediaType} that is byte[] or primitive based.
*/
@Deprecated
BINARY(Element.BINARY),
/**
* Entries are stored in internal memory off the normal Java heap. This mode has equality defined by the byte[]
* created from the serialized form of the provided object.
*/
OFF_HEAP(Element.OFF_HEAP);
private final Element element;
StorageType(Element element) {
this.element = element;
}
public Element getElement() {
return element;
}
public static StorageType forElement(String element) {
return STORAGE_PER_ELEMENT.get(element);
}
public boolean canStoreReferences() {
return this == HEAP || this == OBJECT;
}
private static final Map<String, StorageType> STORAGE_PER_ELEMENT = new HashMap<>(3);
static {
for (StorageType storageType : StorageType.values()) {
STORAGE_PER_ELEMENT.put(storageType.element.getLocalName(), storageType);
}
}
}
| 2,239
| 28.866667
| 120
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/SingleFileStoreConfiguration.java
|
package org.infinispan.configuration.cache;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.ConfigurationFor;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.persistence.file.SingleFileStore;
/**
* Defines the configuration for the single file cache store.
*
* @author Galder Zamarreño
* @since 6.0
*/
@BuiltBy(SingleFileStoreConfigurationBuilder.class)
@ConfigurationFor(SingleFileStore.class)
public class SingleFileStoreConfiguration extends AbstractStoreConfiguration<SingleFileStoreConfiguration> {
public static final AttributeDefinition<String> LOCATION = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.PATH, null, String.class).immutable().global(false).build();
/**
* @deprecated Since 13.0, will be removed in 16.0
*/
@Deprecated
public static final AttributeDefinition<Integer> MAX_ENTRIES = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.MAX_ENTRIES, -1).immutable().build();
public static final AttributeDefinition<Float> FRAGMENTATION_FACTOR = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.FRAGMENTATION_FACTOR, 0.75f).immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(SingleFileStoreConfiguration.class, AbstractStoreConfiguration.attributeDefinitionSet(), LOCATION, MAX_ENTRIES, FRAGMENTATION_FACTOR);
}
public SingleFileStoreConfiguration(AttributeSet attributes, AsyncStoreConfiguration async) {
super(Element.SINGLE_FILE_STORE, attributes, async);
}
public String location() {
return attributes.attribute(LOCATION).get();
}
/**
* @deprecated Since 13.0, will be removed in 16.0.
*/
@Deprecated
public int maxEntries() {
return attributes.attribute(MAX_ENTRIES).get();
}
public float fragmentationFactor() {
return attributes.attribute(FRAGMENTATION_FACTOR).get();
}
}
| 2,151
| 41.196078
| 197
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/MemoryConfiguration.java
|
package org.infinispan.configuration.cache;
import static org.infinispan.util.logging.Log.CONFIG;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.util.ByteQuantity;
import org.infinispan.configuration.parsing.Attribute;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.eviction.EvictionStrategy;
import org.infinispan.eviction.EvictionType;
/**
* Controls the memory storage configuration for the cache.
*
* @author William Burns
*/
public class MemoryConfiguration extends ConfigurationElement<MemoryConfiguration> {
public static final AttributeDefinition<StorageType> STORAGE = AttributeDefinition.builder(Attribute.STORAGE, StorageType.HEAP).immutable().build();
public static final AttributeDefinition<String> MAX_SIZE = AttributeDefinition.builder(Attribute.MAX_SIZE, null, String.class).build();
public static final AttributeDefinition<Long> MAX_COUNT = AttributeDefinition.builder(Attribute.MAX_COUNT, -1L).build();
public static final AttributeDefinition<EvictionStrategy> WHEN_FULL = AttributeDefinition.builder(Attribute.WHEN_FULL, EvictionStrategy.NONE).immutable().build();
private final MemoryStorageConfiguration memoryStorageConfiguration;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(MemoryConfiguration.class, STORAGE, MAX_SIZE, MAX_COUNT, WHEN_FULL);
}
MemoryConfiguration(AttributeSet attributes, MemoryStorageConfiguration memoryStorageConfiguration) {
super(Element.MEMORY, attributes);
this.memoryStorageConfiguration = memoryStorageConfiguration;
// Add a listener to keep new attributes in sync with legacy size without complicating MemoryStorageConfiguration
// Size is the only legacy attribute that can modify at runtime
// Unlike the builder, updates to the new attributes are handled directly in the setters
memoryStorageConfiguration.attributes().attribute(MemoryStorageConfiguration.SIZE)
.addListener((a, oldValue) -> updateSize(a.get()));
}
/**
* @return true if the storage is off-heap
*/
public boolean isOffHeap() {
return attributes.attribute(STORAGE).get() == StorageType.OFF_HEAP;
}
/**
* @return The max size in bytes or -1 if not configured.
*/
public long maxSizeBytes() {
return maxSizeToBytes(maxSize());
}
public String maxSize() {
return attributes.attribute(MAX_SIZE).get();
}
public void maxSize(String maxSize) {
if (!isSizeBounded()) throw CONFIG.cannotChangeMaxSize();
attributes.attribute(MAX_SIZE).set(maxSize);
memoryStorageConfiguration.attributes().attribute(MemoryStorageConfiguration.SIZE).set(maxSizeToBytes(maxSize));
}
/**
* @return the max number of entries in memory or -1 if not configured.
*/
public long maxCount() {
return attributes.attribute(MAX_COUNT).get();
}
public void maxCount(long maxCount) {
if (!isCountBounded()) throw CONFIG.cannotChangeMaxCount();
attributes.attribute(MAX_COUNT).set(maxCount);
memoryStorageConfiguration.attributes().attribute(MemoryStorageConfiguration.SIZE).set(maxCount);
}
/**
* Storage type to use for the data container
* @deprecated Use {@link #storage()} instead.
*/
@Deprecated
public StorageType storageType() {
return storage();
}
/**
* @return The memory {@link StorageType}.
*/
public StorageType storage() {
return attributes.attribute(STORAGE).get();
}
/**
* Size of the eviction, -1 if disabled
* @deprecated Since 11.0, use {@link #maxCount()} or {@link #maxSize()} to obtain
* either the maximum number of entries or the maximum size of the data container.
*/
@Deprecated
public long size() {
return memoryStorageConfiguration.size();
}
/**
* @deprecated Since 11.0, use {@link MemoryConfiguration#maxCount(long)} or
* {@link MemoryConfiguration#maxSize(String)} to dynamically configure the maximum number
* of entries or the maximum size of the data container.
*/
@Deprecated
public void size(long newSize) {
memoryStorageConfiguration.size(newSize);
}
private void updateSize(long newSize) {
if (isCountBounded()) {
attributes.attribute(MAX_COUNT).set(newSize);
} else {
attributes.attribute(MAX_SIZE).set(String.valueOf(newSize));
}
}
/**
* The configured eviction type
*
* @deprecated Since 11.0, use {@link #maxCount()} or {@link #maxSize()} to obtain either the maximum number of
* entries or the maximum size of the data container.
*/
@Deprecated
public EvictionType evictionType() {
return memoryStorageConfiguration.evictionType();
}
/**
* The configured eviction strategy
* @deprecated Since 11.0, use {@link #whenFull()}
*/
@Deprecated
public EvictionStrategy evictionStrategy() {
return memoryStorageConfiguration.evictionStrategy();
}
/**
* @return The configured {@link EvictionStrategy}.
*/
public EvictionStrategy whenFull() {
return attributes.attribute(WHEN_FULL).get();
}
/**
* Returns whether remove eviction is in use
*/
public boolean isEvictionEnabled() {
return (isSizeBounded() || isCountBounded()) && whenFull().isRemovalBased();
}
private boolean isSizeBounded() {
return maxSize() != null;
}
private boolean isCountBounded() {
return maxCount() > 0;
}
/**
* @deprecated Since 11.0, use {@link #evictionStrategy()}, {@link #maxSize()},
* {@link #maxCount()}, {@link #isOffHeap()} instead
*/
@Deprecated
public MemoryStorageConfiguration heapConfiguration() {
return memoryStorageConfiguration;
}
static long maxSizeToBytes(String maxSizeStr) {
return maxSizeStr != null ? ByteQuantity.parse(maxSizeStr) : -1;
}
}
| 6,132
| 33.072222
| 165
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/TakeOfflineConfiguration.java
|
package org.infinispan.configuration.cache;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Element;
/**
* @author Mircea Markus
* @since 5.2
*/
public class TakeOfflineConfiguration extends ConfigurationElement<TakeOfflineConfiguration> {
public static final AttributeDefinition<Integer> AFTER_FAILURES = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.TAKE_BACKUP_OFFLINE_AFTER_FAILURES, 0).immutable().build();
public static final AttributeDefinition<Long> MIN_TIME_TO_WAIT = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.TAKE_BACKUP_OFFLINE_MIN_WAIT, 0L).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(TakeOfflineConfiguration.class, AFTER_FAILURES, MIN_TIME_TO_WAIT);
}
public TakeOfflineConfiguration(AttributeSet attributes) {
super(Element.TAKE_OFFLINE, attributes);
}
/**
* @see TakeOfflineConfigurationBuilder#afterFailures(int)
*/
public int afterFailures() {
return attributes.attribute(AFTER_FAILURES).get();
}
/**
* @see TakeOfflineConfigurationBuilder#minTimeToWait(long)
*/
public long minTimeToWait() {
return attributes.attribute(MIN_TIME_TO_WAIT).get();
}
public boolean enabled() {
return afterFailures() > 0 || minTimeToWait() > 0;
}
}
| 1,574
| 36.5
| 203
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/AbstractStoreConfigurationChildBuilder.java
|
package org.infinispan.configuration.cache;
import java.util.Properties;
/**
* @author Mircea Markus
* @since 6.0
*/
public abstract class AbstractStoreConfigurationChildBuilder<S> extends AbstractPersistenceConfigurationChildBuilder implements StoreConfigurationChildBuilder<S> {
private final StoreConfigurationBuilder<? extends AbstractStoreConfiguration, ? extends StoreConfigurationBuilder<?,?>> builder;
protected AbstractStoreConfigurationChildBuilder(StoreConfigurationBuilder<? extends AbstractStoreConfiguration, ? extends StoreConfigurationBuilder<?,?>> builder) {
super(builder.persistence());
this.builder = builder;
}
@Override
public AsyncStoreConfigurationBuilder<S> async() {
return (AsyncStoreConfigurationBuilder<S>) builder.async();
}
@Override
public S fetchPersistentState(boolean b) {
return (S)builder.fetchPersistentState(b);
}
@Override
public S ignoreModifications(boolean b) {
return (S)builder.ignoreModifications(b);
}
@Override
public S purgeOnStartup(boolean b) {
return (S)builder.purgeOnStartup(b);
}
@Override
public S writeOnly(boolean b) {
return (S)builder.writeOnly(b);
}
@Override
public S preload(boolean b) {
return (S)builder.preload(b);
}
@Override
public S shared(boolean b) {
return (S)builder.shared(b);
}
@Override
public S transactional(boolean b) {
return (S)builder.transactional(b);
}
@Override
public S maxBatchSize(int maxBatchSize) {
return (S)builder.maxBatchSize(maxBatchSize);
}
@Override
public S segmented(boolean b) {
return (S)builder.segmented(b);
}
@Override
public S addProperty(String key, String value) {
return (S)builder.addProperty(key, value);
}
@Override
public S withProperties(Properties p) {
return (S)builder.withProperties(p);
}
}
| 1,928
| 23.730769
| 168
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/AbstractIndexingConfigurationChildBuilder.java
|
package org.infinispan.configuration.cache;
/**
* @since 12.0
*/
abstract class AbstractIndexingConfigurationChildBuilder
extends AbstractConfigurationChildBuilder implements IndexingConfigurationChildBuilder {
private final IndexingConfigurationBuilder indexingBuilder;
protected AbstractIndexingConfigurationChildBuilder(IndexingConfigurationBuilder builder) {
super(builder.getBuilder());
this.indexingBuilder = builder;
}
@Override
public IndexReaderConfigurationBuilder reader() {
return indexingBuilder.reader();
}
@Override
public IndexWriterConfigurationBuilder writer() {
return indexingBuilder.writer();
}
@Override
public IndexShardingConfigurationBuilder sharding() {
return indexingBuilder.sharding();
}
@Override
public IndexingConfigurationBuilder addIndexedEntity(String entity) {
return indexingBuilder.addIndexedEntities(entity);
}
@Override
public IndexingConfigurationBuilder enable() {
return indexingBuilder.enable();
}
@Override
public IndexingConfigurationBuilder disable() {
return indexingBuilder.disable();
}
@Override
public IndexingConfigurationBuilder path(String path) {
return indexingBuilder.path(path);
}
@Override
public IndexingConfigurationBuilder storage(IndexStorage storage) {
return indexingBuilder.storage(storage);
}
@Override
public IndexingConfigurationBuilder startupMode(IndexStartupMode startupMode) {
return indexingBuilder.startupMode(startupMode);
}
@Override
public IndexingConfigurationBuilder indexingMode(IndexingMode indexingMode) {
return indexingBuilder.indexingMode(indexingMode);
}
@Override
public IndexingConfigurationBuilder addKeyTransformer(Class<?> keyClass, Class<?> keyTransformerClass) {
return indexingBuilder.addKeyTransformer(keyClass, keyTransformerClass);
}
@Override
public IndexingConfigurationBuilder addIndexedEntities(String... indexedEntities) {
return indexingBuilder.addIndexedEntities(indexedEntities);
}
@Override
public IndexingConfigurationBuilder addIndexedEntity(Class<?> indexedEntity) {
return indexingBuilder.addIndexedEntity(indexedEntity);
}
@Override
public IndexingConfigurationBuilder addIndexedEntities(Class<?>... indexedEntities) {
return indexingBuilder.addIndexedEntities(indexedEntities);
}
}
| 2,451
| 27.511628
| 107
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/cache/ExpirationConfiguration.java
|
package org.infinispan.configuration.cache;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.expiration.TouchMode;
/**
* Controls the default expiration settings for entries in the cache.
*/
public class ExpirationConfiguration extends ConfigurationElement<ExpirationConfiguration> {
public static final AttributeDefinition<Long> LIFESPAN = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.LIFESPAN, -1L).build();
public static final AttributeDefinition<Long> MAX_IDLE = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.MAX_IDLE, -1L).build();
public static final AttributeDefinition<Boolean> REAPER_ENABLED = AttributeDefinition.builder("reaperEnabled", true).immutable().autoPersist(false).build();
public static final AttributeDefinition<Long> WAKEUP_INTERVAL = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.INTERVAL, TimeUnit.MINUTES.toMillis(1)).build();
public static final AttributeDefinition<TouchMode> TOUCH = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.TOUCH, TouchMode.SYNC).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ExpirationConfiguration.class, LIFESPAN, MAX_IDLE, REAPER_ENABLED, WAKEUP_INTERVAL, TOUCH);
}
private final Attribute<Long> lifespan;
private final Attribute<Long> maxIdle;
private final Attribute<Boolean> reaperEnabled;
private final Attribute<Long> wakeUpInterval;
private final Attribute<TouchMode> touch;
ExpirationConfiguration(AttributeSet attributes) {
super(Element.EXPIRATION, attributes);
lifespan = attributes.attribute(LIFESPAN);
maxIdle = attributes.attribute(MAX_IDLE);
reaperEnabled = attributes.attribute(REAPER_ENABLED);
wakeUpInterval = attributes.attribute(WAKEUP_INTERVAL);
touch = attributes.attribute(TOUCH);
}
/**
* Maximum lifespan of a cache entry, after which the entry is expired cluster-wide, in
* milliseconds. -1 means the entries never expire.
*
* Note that this can be overridden on a per-entry basis by using the Cache API.
*/
public long lifespan() {
return lifespan.get();
}
/**
* Maximum idle time a cache entry will be maintained in the cache, in milliseconds. If the idle
* time is exceeded, the entry will be expired cluster-wide. -1 means the entries never expire.
*
* Note that this can be overridden on a per-entry basis by using the Cache API.
*/
public long maxIdle() {
return maxIdle.get();
}
/**
* Determines whether the background reaper thread is enabled to test entries for expiration.
* Regardless of whether a reaper is used, entries are tested for expiration lazily when they are
* touched.
*/
public boolean reaperEnabled() {
return reaperEnabled.get();
}
/**
* Interval (in milliseconds) between subsequent runs to purge expired entries from memory and
* any cache stores. If you wish to disable the periodic eviction process altogether, set
* wakeupInterval to -1.
*/
public long wakeUpInterval() {
return wakeUpInterval.get();
}
/**
* Control how the timestamp of read keys are updated on all the key owners in a cluster.
*
* Default is {@link TouchMode#SYNC}.
* If the cache mode is ASYNC this attribute is ignored, and timestamps are updated asynchronously.
*/
public TouchMode touch() {
return touch.get();
}
}
| 3,876
| 42.561798
| 190
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalRoleConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import java.util.HashSet;
import java.util.Set;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Role;
import org.infinispan.security.impl.CacheRoleImpl;
/**
* GlobalRoleConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 7.0
*/
public class GlobalRoleConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements GlobalRolesConfigurationChildBuilder, Builder<Role> {
private Set<AuthorizationPermission> permissions = new HashSet<>();
private boolean inheritable = true;
private final GlobalAuthorizationConfigurationBuilder builder;
private final String name;
public GlobalRoleConfigurationBuilder(String name, GlobalAuthorizationConfigurationBuilder builder) {
super(builder.getGlobalConfig());
this.builder = builder;
this.name = name;
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
/**
* Adds a permission to a role
*
* @param permission the name of the permission to add to the role. See {@link AuthorizationPermission}
*/
public GlobalRoleConfigurationBuilder permission(String permission) {
permissions.add(AuthorizationPermission.valueOf(permission));
return this;
}
/**
* Adds multiple permissions to a role
*
* @param permissions the name of the permissions to add to the role. See {@link AuthorizationPermission}
*/
public GlobalRoleConfigurationBuilder permission(String... permissions) {
for (String permission : permissions) {
this.permissions.add(AuthorizationPermission.valueOf(permission));
}
return this;
}
/**
* Adds a permission to a role
*
* @param permission the permission to add to the role. See {@link AuthorizationPermission}
*/
public GlobalRoleConfigurationBuilder permission(AuthorizationPermission permission) {
permissions.add(permission);
return this;
}
/**
* Adds multiple permissions to a role
*
* @param permissions the permissions to add to the role. See {@link AuthorizationPermission}
*/
public GlobalRoleConfigurationBuilder permission(AuthorizationPermission... permissions) {
for (AuthorizationPermission permission : permissions) {
this.permissions.add(permission);
}
return this;
}
@Override
public GlobalRoleConfigurationBuilder role(String name) {
return builder.role(name);
}
/**
* Whether this role should be implicitly inherited by secure caches which don't define their roles.
* @param inheritable
* @return
*/
@Override
public GlobalRoleConfigurationBuilder inheritable(boolean inheritable) {
this.inheritable = inheritable;
return this;
}
@Override
public Role create() {
return new CacheRoleImpl(name, inheritable, permissions);
}
@Override
public Builder<?> read(Role template, Combine combine) {
permissions.clear();
permissions.addAll(template.getPermissions());
inheritable = template.isInheritable();
return this;
}
}
| 3,334
| 29.318182
| 151
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/AllowListConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.AllowListConfiguration.CLASSES;
import static org.infinispan.configuration.global.AllowListConfiguration.REGEXPS;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.ClassAllowList;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* Configures the {@link org.infinispan.manager.EmbeddedCacheManager} {@link ClassAllowList}.
*
* @author Ryan Emerson
* @since 10.0
*/
public class AllowListConfigurationBuilder implements Builder<AllowListConfiguration> {
private final AttributeSet attributes;
private final Set<String> classes = new HashSet<>();
private final List<String> regexps = new ArrayList<>();
private final GlobalConfigurationBuilder globalBuilder;
AllowListConfigurationBuilder(GlobalConfigurationBuilder globalBuilder) {
this.globalBuilder = globalBuilder;
attributes = AllowListConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Helper method that allows for registration of a class to the {@link ClassAllowList}.
*/
public <T> AllowListConfigurationBuilder addClass(String clazz) {
this.classes.add(clazz);
return this;
}
/**
* Helper method that allows for registration of classes to the {@link ClassAllowList}.
*/
public <T> AllowListConfigurationBuilder addClasses(String... classes) {
List<String> classNames = Arrays.asList(classes);
this.classes.addAll(classNames);
return this;
}
/**
* Helper method that allows for registration of classes to the {@link ClassAllowList}.
*/
public <T> AllowListConfigurationBuilder addClasses(Class... classes) {
List<String> classNames = Arrays.stream(classes).map(Class::getName).collect(Collectors.toList());
this.classes.addAll(classNames);
return this;
}
/**
* Helper method that allows for registration of a regexp to the {@link ClassAllowList}.
*/
public <T> AllowListConfigurationBuilder addRegexp(String regex) {
this.regexps.add(regex);
return this;
}
/**
* Helper method that allows for registration of regexps to the {@link ClassAllowList}.
*/
public <T> AllowListConfigurationBuilder addRegexps(String... regexps) {
this.regexps.addAll(Arrays.asList(regexps));
return this;
}
@Override
public void validate() {
// No-op, no validation required
}
@Override
public AllowListConfiguration create() {
if (!classes.isEmpty())
attributes.attribute(CLASSES).set(classes);
if (!regexps.isEmpty())
attributes.attribute(REGEXPS).set(regexps);
return new AllowListConfiguration(attributes.protect(), globalBuilder.getClassLoader());
}
@Override
public Builder<?> read(AllowListConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.classes.addAll(template.getClasses());
this.regexps.addAll(template.getRegexps());
return this;
}
}
| 3,391
| 30.700935
| 104
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/StackFileConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.remoting.transport.jgroups.JGroupsChannelConfigurator;
/**
* @since 10.0
*/
public class StackFileConfiguration extends ConfigurationElement<StackFileConfiguration> implements NamedStackConfiguration {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.NAME, null, String.class).build();
static final AttributeDefinition<String> PATH = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.PATH, null, String.class).build();
static final AttributeDefinition<Boolean> BUILTIN = AttributeDefinition.builder("builtin", false, Boolean.class).autoPersist(false).build();
private final JGroupsChannelConfigurator configurator;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(StackFileConfiguration.class, NAME, PATH, BUILTIN);
}
StackFileConfiguration(AttributeSet attributes, JGroupsChannelConfigurator configurator) {
super(Element.STACK_FILE, attributes);
this.configurator = configurator;
}
public String name() {
return attributes.attribute(NAME).get();
}
public String path() {
return attributes.attribute(PATH).get();
}
public boolean builtIn() {
return attributes.attribute(BUILTIN).get();
}
public JGroupsChannelConfigurator configurator() {
return configurator;
}
}
| 1,735
| 39.372093
| 160
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ScheduledThreadPoolConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
class ScheduledThreadPoolConfiguration {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", null, String.class).build();
static final AttributeDefinition<String> THREAD_FACTORY = AttributeDefinition.builder("threadFactory", null, String.class).build();
private final AttributeSet attributes;
private final Attribute<String> name;
private final Attribute<String> threadFactory;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ScheduledThreadPoolConfiguration.class, NAME, THREAD_FACTORY);
}
ScheduledThreadPoolConfiguration(AttributeSet attributes) {
this.attributes = attributes.checkProtection();
this.name = attributes.attribute(NAME);
this.threadFactory = attributes.attribute(THREAD_FACTORY);
}
public AttributeSet attributes() {
return attributes;
}
public String name() {
return name.get();
}
public String threadFactory() {
return threadFactory.get();
}
@Override
public String toString() {
return "ScheduledThreadPoolConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 1,435
| 31.636364
| 134
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/CacheContainerConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.CacheContainerConfiguration.ASYNC_EXECUTOR;
import static org.infinispan.configuration.global.CacheContainerConfiguration.BLOCKING_EXECUTOR;
import static org.infinispan.configuration.global.CacheContainerConfiguration.DEFAULT_CACHE;
import static org.infinispan.configuration.global.CacheContainerConfiguration.EXPIRATION_EXECUTOR;
import static org.infinispan.configuration.global.CacheContainerConfiguration.LISTENER_EXECUTOR;
import static org.infinispan.configuration.global.CacheContainerConfiguration.NAME;
import static org.infinispan.configuration.global.CacheContainerConfiguration.NON_BLOCKING_EXECUTOR;
import static org.infinispan.configuration.global.CacheContainerConfiguration.PERSISTENCE_EXECUTOR;
import static org.infinispan.configuration.global.CacheContainerConfiguration.STATE_TRANSFER_EXECUTOR;
import static org.infinispan.configuration.global.CacheContainerConfiguration.STATISTICS;
import static org.infinispan.configuration.global.CacheContainerConfiguration.ZERO_CAPACITY_NODE;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class CacheContainerConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<CacheContainerConfiguration> {
private final AttributeSet attributes;
private final GlobalMetricsConfigurationBuilder metrics;
private final GlobalJmxConfigurationBuilder jmx;
private final GlobalStateConfigurationBuilder globalState;
private final TransportConfigurationBuilder transport;
private final GlobalSecurityConfigurationBuilder security;
private final SerializationConfigurationBuilder serialization;
private final ShutdownConfigurationBuilder shutdown;
private final ThreadsConfigurationBuilder threads;
CacheContainerConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
this.attributes = CacheContainerConfiguration.attributeDefinitionSet();
this.metrics = new GlobalMetricsConfigurationBuilder(globalConfig);
this.jmx = new GlobalJmxConfigurationBuilder(globalConfig);
this.globalState = new GlobalStateConfigurationBuilder(globalConfig);
this.threads = new ThreadsConfigurationBuilder(globalConfig);
this.transport = new TransportConfigurationBuilder(globalConfig, threads);
this.security = new GlobalSecurityConfigurationBuilder(globalConfig);
this.serialization = new SerializationConfigurationBuilder(globalConfig);
this.shutdown = new ShutdownConfigurationBuilder(globalConfig);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public CacheContainerConfigurationBuilder clusteredDefault() {
transport().
defaultTransport()
.clearProperties();
return this;
}
public CacheContainerConfigurationBuilder nonClusteredDefault() {
transport()
.transport(null)
.clearProperties();
return this;
}
public static GlobalConfigurationBuilder defaultClusteredBuilder() {
GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder();
builder.transport().defaultTransport();
return builder;
}
public String defaultCacheName() {
return attributes.attribute(DEFAULT_CACHE).get();
}
@Override
public GlobalMetricsConfigurationBuilder metrics() {
return metrics;
}
@Override
public GlobalJmxConfigurationBuilder jmx() {
return jmx;
}
@Override
public GlobalStateConfigurationBuilder globalState() {
return globalState;
}
@Override
public TransportConfigurationBuilder transport() {
return transport;
}
public ThreadsConfigurationBuilder threads() {
return threads;
}
@Override
public ThreadPoolConfigurationBuilder asyncThreadPool() {
return threads.asyncThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder expirationThreadPool() {
return threads.expirationThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder persistenceThreadPool() {
return threads.persistenceThreadPool();
}
/**
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
@Override
public ThreadPoolConfigurationBuilder stateTransferThreadPool() {
return threads.stateTransferThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder listenerThreadPool() {
return threads.listenerThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder nonBlockingThreadPool() {
return threads.nonBlockingThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder blockingThreadPool() {
return threads.blockingThreadPool();
}
@Override
public GlobalSecurityConfigurationBuilder security() {
return security;
}
@Override
public SerializationConfigurationBuilder serialization() {
return serialization;
}
@Override
public ShutdownConfigurationBuilder shutdown() {
return shutdown;
}
public CacheContainerConfigurationBuilder defaultCache(String defaultCacheName) {
attributes.attribute(DEFAULT_CACHE).set(defaultCacheName);
return this;
}
public CacheContainerConfigurationBuilder name(String cacheManagerName) {
attributes.attribute(NAME).set(cacheManagerName);
return this;
}
public String name() {
return attributes.attribute(NAME).get();
}
public CacheContainerConfigurationBuilder statistics(boolean statistics) {
attributes.attribute(STATISTICS).set(statistics);
return this;
}
/**
* @deprecated Since 10.1.3. Use {@link #statistics(boolean)} instead.
*/
@Deprecated
public CacheContainerConfigurationBuilder statistics(Boolean statistics) {
return statistics(statistics.booleanValue());
}
public boolean statistics() {
return attributes.attribute(STATISTICS).get();
}
CacheContainerConfigurationBuilder zeroCapacityNode(boolean zeroCapacityNode) {
attributes.attribute(ZERO_CAPACITY_NODE).set(zeroCapacityNode);
return this;
}
public CacheContainerConfigurationBuilder asyncExecutor(String name) {
attributes.attribute(ASYNC_EXECUTOR).set(name);
return this;
}
CacheContainerConfigurationBuilder listenerExecutor(String name) {
attributes.attribute(LISTENER_EXECUTOR).set(name);
return this;
}
CacheContainerConfigurationBuilder expirationExecutor(String name) {
attributes.attribute(EXPIRATION_EXECUTOR).set(name);
return this;
}
public CacheContainerConfigurationBuilder persistenceExecutor(String name) {
attributes.attribute(PERSISTENCE_EXECUTOR).set(name);
return this;
}
/**
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
public CacheContainerConfigurationBuilder stateTransferExecutor(String name) {
attributes.attribute(STATE_TRANSFER_EXECUTOR).set(name);
return this;
}
public CacheContainerConfigurationBuilder nonBlockingExecutor(String name) {
attributes.attribute(NON_BLOCKING_EXECUTOR).set(name);
return this;
}
public CacheContainerConfigurationBuilder blockingExecutor(String name) {
attributes.attribute(BLOCKING_EXECUTOR).set(name);
return this;
}
public void validate() {
List<RuntimeException> validationExceptions = new ArrayList<>();
try {
attributes.validate();
} catch (RuntimeException e) {
validationExceptions.add(e);
}
Arrays.asList(
metrics,
jmx,
globalState,
transport,
security,
serialization,
shutdown,
threads
).forEach(c -> {
try {
c.validate();
} catch (RuntimeException e) {
validationExceptions.add(e);
}
});
CacheConfigurationException.fromMultipleRuntimeExceptions(validationExceptions).ifPresent(e -> {
throw e;
});
}
@Override
public CacheContainerConfiguration create() {
Attribute<String> attribute = attributes.attribute(NAME);
if (!attribute.isModified()) {
name(attribute.getAttributeDefinition().getDefaultValue());
}
return new CacheContainerConfiguration(
attributes.protect(),
threads.create(),
metrics.create(),
jmx.create(),
transport.create(),
security.create(),
serialization.create(),
globalState.create(),
shutdown.create(),
getGlobalConfig().getFeatures()
);
}
@Override
public Builder<?> read(CacheContainerConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.globalState.read(template.globalState(), combine);
this.metrics.read(template.metrics(), combine);
this.jmx.read(template.jmx(), combine);
this.transport.read(template.transport(), combine);
this.security.read(template.security(), combine);
this.serialization.read(template.serialization(), combine);
this.shutdown.read(template.shutdown(), combine);
this.threads.read(template.threads(), combine);
this.security.read(template.security(), combine);
return this;
}
}
| 9,735
| 31.781145
| 140
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ShutdownConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.Objects;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class ShutdownConfiguration {
static final AttributeDefinition<ShutdownHookBehavior> HOOK_BEHAVIOR = AttributeDefinition.builder("shutdownHook", ShutdownHookBehavior.DEFAULT).immutable().build();
private final AttributeSet attributes;
private final Attribute<ShutdownHookBehavior> hookBehavior;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ShutdownConfiguration.class, HOOK_BEHAVIOR);
}
ShutdownConfiguration(AttributeSet attributes) {
this.attributes = attributes.checkProtection();
hookBehavior = attributes.attribute(HOOK_BEHAVIOR);
}
public ShutdownHookBehavior hookBehavior() {
return hookBehavior.get();
}
@Override
public String toString() {
return "ShutdownConfiguration{" +
"attributes=" + attributes +
'}';
}
public AttributeSet attributes() {
return attributes;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ShutdownConfiguration that = (ShutdownConfiguration) o;
return Objects.equals(attributes, that.attributes);
}
@Override
public int hashCode() {
return attributes != null ? attributes.hashCode() : 0;
}
}
| 1,587
| 28.407407
| 168
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/package-info.java
|
/**
* {@link org.infinispan.manager.EmbeddedCacheManager} configuration
*
* @api.public
*/
package org.infinispan.configuration.global;
| 140
| 19.142857
| 68
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/SiteConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.remoting.transport.Transport;
/**
* @author Mircea.Markus@jboss.com
* @since 5.2
* @deprecated since 11.0. Use {@link Transport#localSiteName()}
*/
@Deprecated
public class SiteConfiguration {
private final String localSite;
SiteConfiguration(String localSite) {
this.localSite = localSite;
}
/**
* Returns the name of the local site. Must be a valid name defined in {@link #siteConfigurations()}
*/
@Deprecated
public final String localSite() {
return localSite;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof SiteConfiguration)) return false;
SiteConfiguration that = (SiteConfiguration) o;
if (localSite != null ? !localSite.equals(that.localSite) : that.localSite != null) return false;
return true;
}
@Override
public int hashCode() {
return localSite != null ? localSite.hashCode() : 0;
}
@Override
public String toString() {
return "SiteConfiguration{" +
"localSite='" + localSite + '\'' +
'}';
}
}
| 1,167
| 22.36
| 103
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ThreadFactoryConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.factories.threads.BlockingThreadFactory;
import org.infinispan.factories.threads.DefaultThreadFactory;
import org.infinispan.factories.threads.NonBlockingThreadFactory;
class ThreadFactoryConfiguration {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", null, String.class).build();
static final AttributeDefinition<String> GROUP = AttributeDefinition.builder("groupName", null, String.class).build();
static final AttributeDefinition<String> THREAD_NAME_PATTERN = AttributeDefinition.builder("threadNamePattern", null, String.class).build();
static final AttributeDefinition<Integer> PRIORITY = AttributeDefinition.builder("priority", null, Integer.class).build();
private final AttributeSet attributes;
private final Attribute<String> name;
private final Attribute<String> groupName;
private final Attribute<String> threadNamePattern;
private final Attribute<Integer> priority;
private String nodeName;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ThreadFactoryConfiguration.class, NAME, GROUP, THREAD_NAME_PATTERN, PRIORITY);
}
ThreadFactoryConfiguration(AttributeSet attributes, String nodeName) {
this.attributes = attributes.checkProtection();
this.name = attributes.attribute(NAME);
this.groupName = attributes.attribute(GROUP);
this.threadNamePattern = attributes.attribute(THREAD_NAME_PATTERN);
this.priority = attributes.attribute(PRIORITY);
this.nodeName = nodeName;
}
public DefaultThreadFactory getThreadFactory(boolean isNonBlocking) {
if (isNonBlocking) {
return new NonBlockingThreadFactory(name.get(), groupName.get(), priority.get(), threadNamePattern.get(), nodeName, null);
}
return new BlockingThreadFactory(name.get(), groupName.get(), priority.get(), threadNamePattern.get(), nodeName, null);
}
public AttributeSet attributes() {
return attributes;
}
public Attribute<String> name() {
return name;
}
public Attribute<String> groupName() {
return groupName;
}
public Attribute<String> threadPattern() {
return threadNamePattern;
}
public Attribute<Integer> priority() {
return priority;
}
public String getNodeName() {
return nodeName;
}
@Override
public String toString() {
return "ThreadFactoryConfiguration{" +
"attributes=" + attributes +
", nodeName='" + nodeName + '\'' +
'}';
}
}
| 2,808
| 35.960526
| 143
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/JGroupsConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.JGroupsConfiguration.TRANSPORT;
import static org.infinispan.util.logging.Log.CONFIG;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.remoting.transport.Transport;
/**
* @since 10.0
*/
public class JGroupsConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<JGroupsConfiguration> {
private final AttributeSet attributes;
private List<StackConfigurationBuilder> stackConfigurationBuilders = new ArrayList<>();
private List<StackFileConfigurationBuilder> stackFileConfigurationBuilders = new ArrayList<>();
private Set<String> buildersByName = new HashSet<>();
JGroupsConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = JGroupsConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public void validate() {
stackConfigurationBuilders.forEach(s -> validate());
stackFileConfigurationBuilders.forEach(s -> validate());
}
public StackConfigurationBuilder addStack(String name) {
if (buildersByName.contains(name)) {
throw CONFIG.duplicateJGroupsStack(name);
}
StackConfigurationBuilder stackConfigurationBuilder = new StackConfigurationBuilder(name, this);
buildersByName.add(name);
stackConfigurationBuilders.add(stackConfigurationBuilder);
return stackConfigurationBuilder;
}
public StackFileConfigurationBuilder addStackFile(String name) {
if (buildersByName.contains(name)) {
throw CONFIG.duplicateJGroupsStack(name);
}
StackFileConfigurationBuilder stackFileConfigurationBuilder = new StackFileConfigurationBuilder(name, this);
buildersByName.add(name);
stackFileConfigurationBuilders.add(stackFileConfigurationBuilder);
return stackFileConfigurationBuilder;
}
public JGroupsConfigurationBuilder transport(Transport transport) {
attributes.attribute(TRANSPORT).set(transport);
return this;
}
public JGroupsConfigurationBuilder clear() {
stackConfigurationBuilders = new ArrayList<>();
stackFileConfigurationBuilders = new ArrayList<>();
return this;
}
Transport jgroupsTransport() {
return attributes.attribute(TRANSPORT).get();
}
@Override
public JGroupsConfiguration create() {
List<StackFileConfiguration> stackFileConfigurations = stackFileConfigurationBuilders.stream()
.map(StackFileConfigurationBuilder::create).collect(Collectors.toList());
List<StackConfiguration> stackConfigurations = stackConfigurationBuilders.stream()
.map(StackConfigurationBuilder::create).collect(Collectors.toList());
return new JGroupsConfiguration(attributes.protect(), stackFileConfigurations, stackConfigurations);
}
@Override
public JGroupsConfigurationBuilder read(JGroupsConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
buildersByName.clear();
template.stackFiles().forEach(s -> addStackFile(s.name()).read(s, combine));
template.stacks().forEach(s -> addStack(s.name()).read(s, combine));
for(StackFileConfigurationBuilder b : stackFileConfigurationBuilders) {
buildersByName.add(b.getConfigurator().getName());
}
for(StackConfigurationBuilder b : stackConfigurationBuilders) {
buildersByName.add(b.getConfigurator().getName());
}
return this;
}
public boolean hasStack(String name) {
return buildersByName.contains(name);
}
@Override
public String toString() {
return "JGroupsConfigurationBuilder{" +
"attributes=" + attributes +
", stackConfigurationBuilders=" + stackConfigurationBuilders +
", stackFileConfigurationBuilders=" + stackFileConfigurationBuilders +
'}';
}
}
| 4,275
| 36.182609
| 126
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ScheduledExecutorFactoryConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.ScheduledExecutorFactoryConfiguration.FACTORY;
import static org.infinispan.configuration.global.ScheduledExecutorFactoryConfiguration.PROPERTIES;
import java.util.Properties;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.util.TypedProperties;
import org.infinispan.executors.ScheduledExecutorFactory;
/**
* Configures executor factory.
*/
public class ScheduledExecutorFactoryConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<ScheduledExecutorFactoryConfiguration> {
private final AttributeSet attributes;
ScheduledExecutorFactoryConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = ScheduledExecutorFactoryConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Specify factory class for executor
*
* NOTE: Currently Infinispan will not use the object instance, but instead instantiate a new
* instance of the class. Therefore, do not expect any state to survive, and provide a no-args
* constructor to any instance. This will be resolved in Infinispan 5.2.0
*
* @param factory clazz
* @return this ScheduledExecutorFactoryConfig
*/
public ScheduledExecutorFactoryConfigurationBuilder factory(ScheduledExecutorFactory factory) {
attributes.attribute(FACTORY).set(factory);
return this;
}
/**
* Add key/value property pair to this executor factory configuration
*
* @param key property key
* @param value property value
* @return previous value if exists, null otherwise
*/
public ScheduledExecutorFactoryConfigurationBuilder addProperty(String key, String value) {
attributes.attribute(PROPERTIES).get().put(key, value);
return this;
}
/**
* Set key/value properties to this executor factory configuration
*
* @param props Properties
* @return this ScheduledExecutorFactoryConfig
*/
public ScheduledExecutorFactoryConfigurationBuilder withProperties(Properties props) {
attributes.attribute(PROPERTIES).set(TypedProperties.toTypedProperties(props));
return this;
}
@Override
public
void validate() {
// No-op, no validation required
}
@Override
public
ScheduledExecutorFactoryConfiguration create() {
return new ScheduledExecutorFactoryConfiguration(attributes);
}
@Override
public ScheduledExecutorFactoryConfigurationBuilder read(ScheduledExecutorFactoryConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "ScheduledExecutorFactoryConfigurationBuilder [attributes=" + attributes + "]";
}
}
| 3,050
| 32.9
| 160
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/StackFileConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.StackFileConfiguration.BUILTIN;
import static org.infinispan.configuration.global.StackFileConfiguration.NAME;
import static org.infinispan.configuration.global.StackFileConfiguration.PATH;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.remoting.transport.jgroups.BuiltinJGroupsChannelConfigurator;
import org.infinispan.remoting.transport.jgroups.FileJGroupsChannelConfigurator;
import org.infinispan.remoting.transport.jgroups.JGroupsChannelConfigurator;
/*
* @since 10.0
*/
public class StackFileConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements StackBuilder<StackFileConfiguration> {
private final AttributeSet attributes;
private FileJGroupsChannelConfigurator configurator;
StackFileConfigurationBuilder(String name, JGroupsConfigurationBuilder jgroups) {
super(jgroups.getGlobalConfig());
attributes = StackFileConfiguration.attributeDefinitionSet();
attributes.attribute(NAME).set(name);
}
public AttributeSet attributes() {
return attributes;
}
public StackFileConfigurationBuilder path(String name) {
attributes.attribute(StackFileConfiguration.PATH).set(name);
return this;
}
public StackFileConfigurationBuilder fileChannelConfigurator(FileJGroupsChannelConfigurator configurator) {
this.configurator = configurator;
attributes.attribute(NAME).set(configurator.getName());
attributes.attribute(PATH).set(configurator.getPath());
attributes.attribute(BUILTIN).set(configurator instanceof BuiltinJGroupsChannelConfigurator);
return this;
}
@Override
public StackFileConfiguration create() {
return new StackFileConfiguration(attributes.protect(), configurator);
}
@Override
public StackFileConfigurationBuilder read(StackFileConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.configurator = (FileJGroupsChannelConfigurator) template.configurator();
return this;
}
@Override
public JGroupsChannelConfigurator getConfigurator() {
return configurator;
}
}
| 2,291
| 37.2
| 135
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalJmxStatisticsConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.jmx.MBeanServerLookup;
import org.infinispan.commons.util.TypedProperties;
/**
* @deprecated since 10.1.3 Use {@link GlobalJmxConfiguration} instead. This will be removed in next major version.
*/
@Deprecated
public abstract class GlobalJmxStatisticsConfiguration {
/**
* @return true if JMX is enabled.
*/
public abstract boolean enabled();
public abstract String domain();
public abstract TypedProperties properties();
/**
* @return the cache manager name
* @deprecated Since 10.1. please use {@link GlobalConfiguration#cacheManagerName()} instead.
*/
@Deprecated
public abstract String cacheManagerName();
public abstract MBeanServerLookup mbeanServerLookup();
}
| 794
| 25.5
| 115
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/RolePermissionMapperConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.security.RolePermissionMapper;
import org.infinispan.security.mappers.ClusterPermissionMapper;
/**
* @since 14.0
*/
public class RolePermissionMapperConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<RolePermissionMapperConfiguration> {
private final AttributeSet attributes;
private RolePermissionMapper permissionMapper = new ClusterPermissionMapper();
RolePermissionMapperConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = RolePermissionMapperConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public RolePermissionMapperConfigurationBuilder mapper(RolePermissionMapper permissionMapper) {
this.permissionMapper = permissionMapper;
return this;
}
@Override
public void validate() {
}
@Override
public RolePermissionMapperConfiguration create() {
return new RolePermissionMapperConfiguration(attributes.protect(), permissionMapper);
}
@Override
public RolePermissionMapperConfigurationBuilder read(RolePermissionMapperConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.permissionMapper = template.permissionMapper();
return this;
}
public RolePermissionMapper mapper() {
return permissionMapper;
}
}
| 1,657
| 31.509804
| 152
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalStatePathConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.ParseUtils;
public class GlobalStatePathConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<GlobalStatePathConfiguration> {
private final AttributeSet attributes;
private String elementName;
private String location;
GlobalStatePathConfigurationBuilder(GlobalConfigurationBuilder globalConfig, String elementName) {
super(globalConfig);
this.elementName = elementName;
attributes = GlobalStatePathConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public GlobalStatePathConfigurationBuilder location(String path, String relativeTo) {
location = ParseUtils.resolvePath(path, relativeTo);
attributes.attribute(GlobalStatePathConfiguration.PATH).set(path);
attributes.attribute(GlobalStatePathConfiguration.RELATIVE_TO).set(relativeTo);
return this;
}
public String getLocation() {
return location;
}
@Override
public GlobalStatePathConfiguration create() {
return new GlobalStatePathConfiguration(attributes.protect(), elementName);
}
@Override
public GlobalStatePathConfigurationBuilder read(GlobalStatePathConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
location = template.getLocation();
elementName = template.elementName();
return this;
}
}
| 1,686
| 33.428571
| 142
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/SerializationConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.SerializationConfiguration.ADVANCED_EXTERNALIZERS;
import static org.infinispan.configuration.global.SerializationConfiguration.MARSHALLER;
import static org.infinispan.configuration.global.SerializationConfiguration.SERIALIZATION_CONTEXT_INITIALIZERS;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.protostream.SerializationContextInitializer;
/**
* Configures serialization and marshalling settings.
*/
public class SerializationConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<SerializationConfiguration> {
private final AttributeSet attributes;
private final AllowListConfigurationBuilder allowListBuilder;
private Map<Integer, AdvancedExternalizer<?>> advancedExternalizers = new HashMap<>();
SerializationConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
this.allowListBuilder = new AllowListConfigurationBuilder(globalConfig);
this.attributes = SerializationConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Set the marshaller instance that will marshall and unmarshall cache entries.
*
* @param marshaller
*/
public SerializationConfigurationBuilder marshaller(Marshaller marshaller) {
attributes.attribute(MARSHALLER).set(marshaller);
return this;
}
public Marshaller getMarshaller() {
return attributes.attribute(MARSHALLER).get();
}
/**
* Helper method that allows for quick registration of an {@link AdvancedExternalizer}
* implementation alongside its corresponding identifier. Remember that the identifier needs to a be positive number,
* including 0, and cannot clash with other identifiers in the system.
*
* @param id
* @param advancedExternalizer
* @deprecated since 10.0, {@link AdvancedExternalizer}'s will be removed in a future release. Please utilise
* ProtoStream annotations on Java objects instead by configuring a {@link org.infinispan.protostream.SerializationContextInitializer}
* via {@link #addContextInitializer(SerializationContextInitializer)}, or specifying a custom marshaller for user types
* via {@link #marshaller(Marshaller)}.
*/
@Deprecated
public <T> SerializationConfigurationBuilder addAdvancedExternalizer(int id, AdvancedExternalizer<T> advancedExternalizer) {
AdvancedExternalizer<?> ext = advancedExternalizers.get(id);
if (ext != null)
throw new CacheConfigurationException(String.format(
"Duplicate externalizer id found! Externalizer id=%d for %s is shared by another externalizer (%s)",
id, advancedExternalizer.getClass().getName(), ext.getClass().getName()));
advancedExternalizers.put(id, advancedExternalizer);
return this;
}
/**
* Helper method that allows for quick registration of an {@link AdvancedExternalizer}
* implementation alongside its corresponding identifier. Remember that the identifier needs to a be positive number,
* including 0, and cannot clash with other identifiers in the system.
*
* @param advancedExternalizer
* @deprecated since 10.0, {@link AdvancedExternalizer}'s will be removed in a future release. Please utilise
* ProtoStream annotations on Java objects instead by configuring a {@link org.infinispan.protostream.SerializationContextInitializer}
* via {@link #addContextInitializer(SerializationContextInitializer)}, or specifying a custom marshaller for user types
* via {@link #marshaller(Marshaller)}.
*/
@Deprecated
public <T> SerializationConfigurationBuilder addAdvancedExternalizer(AdvancedExternalizer<T> advancedExternalizer) {
Integer id = advancedExternalizer.getId();
if (id == null)
throw new CacheConfigurationException(String.format(
"No advanced externalizer identifier set for externalizer %s",
advancedExternalizer.getClass().getName()));
this.addAdvancedExternalizer(id.intValue(), advancedExternalizer);
return this;
}
/**
* Helper method that allows for quick registration of {@link AdvancedExternalizer} implementations.
*
* @param advancedExternalizers
* @deprecated since 10.0, {@link AdvancedExternalizer}'s will be removed in a future release. Please utilise
* ProtoStream annotations on Java objects instead by configuring a {@link org.infinispan.protostream.SerializationContextInitializer}
* via {@link #addContextInitializer(SerializationContextInitializer)}, or specifying a custom marshaller for user types
* via {@link #marshaller(Marshaller)}.
*/
@Deprecated
public <T> SerializationConfigurationBuilder addAdvancedExternalizer(AdvancedExternalizer<T>... advancedExternalizers) {
for (AdvancedExternalizer<T> advancedExternalizer : advancedExternalizers) {
this.addAdvancedExternalizer(advancedExternalizer);
}
return this;
}
public SerializationConfigurationBuilder addContextInitializer(SerializationContextInitializer sci) {
if (sci == null)
throw new CacheConfigurationException("SerializationContextInitializer cannot be null");
attributes.attribute(SERIALIZATION_CONTEXT_INITIALIZERS).computeIfAbsent(ArrayList::new).add(sci);
return this;
}
public SerializationConfigurationBuilder addContextInitializers(SerializationContextInitializer... scis) {
return addContextInitializers(Arrays.asList(scis));
}
public SerializationConfigurationBuilder addContextInitializers(List<SerializationContextInitializer> scis) {
attributes.attribute(SERIALIZATION_CONTEXT_INITIALIZERS).computeIfAbsent(ArrayList::new).addAll(scis);
return this;
}
public AllowListConfigurationBuilder allowList() {
return allowListBuilder;
}
/**
* @deprecated since 12.0. Use {@link #allowList()} instead. To be removed in 14.0.
*/
@Deprecated
public WhiteListConfigurationBuilder whiteList() {
return new WhiteListConfigurationBuilder(allowListBuilder);
}
@Override
public void validate() {
// No-op, no validation required
}
@Override
public
SerializationConfiguration create() {
if (!advancedExternalizers.isEmpty()) attributes.attribute(ADVANCED_EXTERNALIZERS).set(advancedExternalizers);
return new SerializationConfiguration(attributes.protect(), allowListBuilder.create());
}
@Override
public
SerializationConfigurationBuilder read(SerializationConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.advancedExternalizers = template.advancedExternalizers();
this.allowListBuilder.read(template.allowList(), combine);
return this;
}
@Override
public String toString() {
return "SerializationConfigurationBuilder [attributes=" + attributes + ", advancedExternalizers=" + advancedExternalizers + "]";
}
}
| 7,542
| 42.601156
| 138
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/BoundedThreadPoolConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
class BoundedThreadPoolConfiguration {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", null, String.class).build();
static final AttributeDefinition<String> THREAD_FACTORY = AttributeDefinition.builder("threadFactory", null, String.class).build();
static final AttributeDefinition<Integer> MAX_THREADS = AttributeDefinition.builder("maxThreads", null, Integer.class).build();
static final AttributeDefinition<Integer> CORE_THREADS = AttributeDefinition.builder("coreThreads", null, Integer.class).build();
static final AttributeDefinition<Long> KEEP_ALIVE_TIME = AttributeDefinition.builder("keepAliveTime", null, Long.class).build();
static final AttributeDefinition<Integer> QUEUE_LENGTH = AttributeDefinition.builder("queue-length", null, Integer.class).build();
static final AttributeDefinition<Boolean> NON_BLOCKING = AttributeDefinition.builder("non-blocking", null, Boolean.class).build();
private final AttributeSet attributes;
private final Attribute<String> name;
private final Attribute<String> threadFactory;
private final Attribute<Integer> maxThreads;
private final Attribute<Integer> coreThreads;
private final Attribute<Long> keepAliveTime;
private final Attribute<Integer> queueLength;
private final Attribute<Boolean> nonBlocking;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(BoundedThreadPoolConfiguration.class, NAME, THREAD_FACTORY, MAX_THREADS, CORE_THREADS,
KEEP_ALIVE_TIME, QUEUE_LENGTH, NON_BLOCKING);
}
BoundedThreadPoolConfiguration(AttributeSet attributes) {
this.attributes = attributes.checkProtection();
this.name = attributes.attribute(NAME);
this.threadFactory = attributes.attribute(THREAD_FACTORY);
this.maxThreads = attributes.attribute(MAX_THREADS);
this.coreThreads = attributes.attribute(CORE_THREADS);
this.keepAliveTime = attributes.attribute(KEEP_ALIVE_TIME);
this.queueLength = attributes.attribute(QUEUE_LENGTH);
this.nonBlocking = attributes.attribute(NON_BLOCKING);
}
public AttributeSet attributes() {
return attributes;
}
public String name() {
return name.get();
}
public String threadFactory() {
return threadFactory.get();
}
public Integer getMaxThreads() {
return maxThreads.get();
}
public Integer getCoreThreads() {
return coreThreads.get();
}
public Long getKeepAliveTime() {
return keepAliveTime.get();
}
public Integer getQueueLength() {
return queueLength.get();
}
public Boolean isNonBlocking() {
return nonBlocking.get();
}
@Override
public String toString() {
return "BoundedThreadPoolConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 3,123
| 36.190476
| 134
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/RolePermissionMapperConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.Attribute;
import org.infinispan.security.RolePermissionMapper;
/**
* @since 14.0
*/
public class RolePermissionMapperConfiguration {
public static final AttributeDefinition<Class> CLASS = AttributeDefinition.builder(Attribute.CLASS, null, Class.class).immutable().build();
private final RolePermissionMapper permissionMapper;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RolePermissionMapperConfiguration.class, CLASS);
}
private final AttributeSet attributes;
RolePermissionMapperConfiguration(AttributeSet attributeSet, RolePermissionMapper permissionMapper) {
this.attributes = attributeSet;
this.permissionMapper = permissionMapper;
}
public AttributeSet attributes() {
return attributes;
}
public RolePermissionMapper permissionMapper() {
return permissionMapper;
}
}
| 1,115
| 30
| 142
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalJmxConfiguration.java
|
package org.infinispan.configuration.global;
import static org.infinispan.commons.configuration.attributes.IdentityAttributeCopier.identityCopier;
import java.util.Objects;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSerializer;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.PropertiesAttributeSerializer;
import org.infinispan.commons.jmx.MBeanServerLookup;
import org.infinispan.commons.util.TypedProperties;
import org.infinispan.configuration.parsing.Element;
/**
* @since 10.1.3
*/
public class GlobalJmxConfiguration extends GlobalJmxStatisticsConfiguration {
public static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.ENABLED, false).immutable().build();
public static final AttributeDefinition<String> DOMAIN = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.DOMAIN, "org.infinispan").immutable().build();
public static final AttributeDefinition<MBeanServerLookup> MBEAN_SERVER_LOOKUP = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.MBEAN_SERVER_LOOKUP, null, MBeanServerLookup.class)
.copier(identityCopier()).serializer(AttributeSerializer.INSTANCE_CLASS_NAME).immutable().build();
public static final AttributeDefinition<TypedProperties> PROPERTIES = AttributeDefinition.builder(Element.PROPERTIES, null, TypedProperties.class).immutable()
.initializer(TypedProperties::new).serializer(PropertiesAttributeSerializer.PROPERTIES).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GlobalJmxConfiguration.class, ENABLED, DOMAIN, MBEAN_SERVER_LOOKUP, PROPERTIES);
}
private final Attribute<Boolean> enabled;
private final Attribute<String> domain;
private final Attribute<MBeanServerLookup> mBeanServerLookup;
private final Attribute<TypedProperties> properties;
private final String cacheManagerName;
private final AttributeSet attributes;
GlobalJmxConfiguration(AttributeSet attributes, String cacheManagerName) {
this.attributes = attributes.checkProtection();
this.enabled = attributes.attribute(ENABLED);
this.domain = attributes.attribute(DOMAIN);
this.mBeanServerLookup = attributes.attribute(MBEAN_SERVER_LOOKUP);
this.properties = attributes.attribute(PROPERTIES);
this.cacheManagerName = cacheManagerName;
}
/**
* @return true if JMX is enabled.
*/
public boolean enabled() {
return enabled.get();
}
public String domain() {
return domain.get();
}
public TypedProperties properties() {
return properties.get();
}
/**
* @return the cache manager name
* @deprecated Since 10.1. please use {@link GlobalConfiguration#cacheManagerName()} instead.
*/
@Deprecated
public String cacheManagerName() {
return cacheManagerName;
}
public MBeanServerLookup mbeanServerLookup() {
return mBeanServerLookup.get();
}
public AttributeSet attributes() {
return attributes;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GlobalJmxConfiguration that = (GlobalJmxConfiguration) o;
if (!Objects.equals(cacheManagerName, that.cacheManagerName))
return false;
return Objects.equals(attributes, that.attributes);
}
@Override
public int hashCode() {
int result = cacheManagerName != null ? cacheManagerName.hashCode() : 0;
result = 31 * result + (attributes != null ? attributes.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "GlobalJmxConfiguration [" +
"cacheManagerName='" + cacheManagerName + '\'' +
", attributes=" + attributes +
']';
}
}
| 4,101
| 37.698113
| 210
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/StackBuilder.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.remoting.transport.jgroups.JGroupsChannelConfigurator;
public interface StackBuilder<T> extends Builder<T> {
JGroupsChannelConfigurator getConfigurator();
}
| 283
| 27.4
| 76
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/TemporaryGlobalStatePathConfiguration.java
|
package org.infinispan.configuration.global;
import java.nio.file.Paths;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class TemporaryGlobalStatePathConfiguration {
public static final AttributeDefinition<String> PATH = AttributeDefinition.builder("path", null, String.class)
.initializer(() -> Paths.get(System.getProperty("java.io.tmpdir")).toAbsolutePath().toString())
.immutable().build();
public static final AttributeDefinition<String> RELATIVE_TO = AttributeDefinition.builder("relativeTo", null, String.class).immutable().build();
private final Attribute<String> path;
private final Attribute<String> relativeTo;
private final String location;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GlobalStateConfiguration.class, PATH, RELATIVE_TO);
}
private final AttributeSet attributes;
public TemporaryGlobalStatePathConfiguration(AttributeSet attributes, String location) {
this.attributes = attributes.checkProtection();
this.path = attributes.attribute(PATH);
this.relativeTo = attributes.attribute(RELATIVE_TO);
this.location = location;
}
public AttributeSet attributes() {
return attributes;
}
public String getLocation() {
return location;
}
public String path() {
return path.get();
}
public String relativeTo() {
return relativeTo.get();
}
}
| 1,599
| 31
| 147
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalSecurityConfigurationChildBuilder.java
|
package org.infinispan.configuration.global;
import java.util.concurrent.TimeUnit;
/**
* GlobalSecurityConfigurationChildBuilder.
*
* @author Tristan Tarrant
* @since 7.0
*/
public interface GlobalSecurityConfigurationChildBuilder extends GlobalConfigurationChildBuilder {
/**
* Defines global roles as groups of permissions
*/
GlobalAuthorizationConfigurationBuilder authorization();
/**
* Defines the size for the access role cache. The default value is 1000.
* @param securityCacheSize the number of access roles to cache
*/
GlobalSecurityConfigurationBuilder securityCacheSize(int securityCacheSize);
/**
* Defines the timeout for which to cache user access roles. A value of -1 means the entries
* never expire. A value of 0 will disable the cache.
*
* @param securityCacheTimeout the timeout
* @param unit the {@link TimeUnit}
*/
GlobalSecurityConfigurationBuilder securityCacheTimeout(long securityCacheTimeout, TimeUnit unit);
}
| 1,008
| 30.53125
| 101
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalAuthorizationConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.GlobalAuthorizationConfiguration.AUDIT_LOGGER;
import static org.infinispan.configuration.global.GlobalAuthorizationConfiguration.ENABLED;
import static org.infinispan.configuration.global.GlobalAuthorizationConfiguration.GROUP_ONLY_MAPPING;
import static org.infinispan.configuration.global.GlobalAuthorizationConfiguration.ROLES;
import static org.infinispan.util.logging.Log.CONFIG;
import java.security.Principal;
import java.util.HashMap;
import java.util.Map;
import javax.security.auth.Subject;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.security.AuditLogger;
import org.infinispan.security.PrincipalRoleMapper;
import org.infinispan.security.Role;
import org.infinispan.security.RolePermissionMapper;
import org.infinispan.security.audit.LoggingAuditLogger;
import org.infinispan.security.audit.NullAuditLogger;
/**
* GlobalAuthorizationConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 7.0
*/
public class GlobalAuthorizationConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<GlobalAuthorizationConfiguration> {
private final AttributeSet attributes;
private final PrincipalRoleMapperConfigurationBuilder roleMapper;
private final RolePermissionMapperConfigurationBuilder permissionMapper;
private final Map<String, GlobalRoleConfigurationBuilder> roles = new HashMap<>();
public GlobalAuthorizationConfigurationBuilder(GlobalSecurityConfigurationBuilder builder) {
super(builder.getGlobalConfig());
roleMapper = new PrincipalRoleMapperConfigurationBuilder(getGlobalConfig());
permissionMapper = new RolePermissionMapperConfigurationBuilder(getGlobalConfig());
attributes = GlobalAuthorizationConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public GlobalAuthorizationConfigurationBuilder enable() {
return this.enabled(true);
}
public GlobalAuthorizationConfigurationBuilder disable() {
return this.enabled(false);
}
public GlobalAuthorizationConfigurationBuilder enabled(boolean enabled) {
attributes.attribute(ENABLED).set(enabled);
return this;
}
public boolean isEnabled() {
return attributes.attribute(ENABLED).get();
}
/**
* The instance of an {@link AuditLogger} to be used to track operations performed on caches and cachemanagers. The default logger is
* the {@link NullAuditLogger}. You can also use the {@link LoggingAuditLogger} which will send audit messages to the log.
* @param auditLogger
*/
public GlobalAuthorizationConfigurationBuilder auditLogger(AuditLogger auditLogger) {
attributes.attribute(AUDIT_LOGGER).set(auditLogger);
return this;
}
/**
* Determines whether role mapping applies to group principals only or also to user principals. Defaults to true.
* @param groupOnlyMapping
*/
public GlobalAuthorizationConfigurationBuilder groupOnlyMapping(boolean groupOnlyMapping) {
attributes.attribute(GROUP_ONLY_MAPPING).set(groupOnlyMapping);
return this;
}
/**
* The class of a mapper which converts the {@link Principal}s associated with a {@link Subject} into a set of roles
*
* @param principalRoleMapper
*/
public GlobalAuthorizationConfigurationBuilder principalRoleMapper(PrincipalRoleMapper principalRoleMapper) {
roleMapper.mapper(principalRoleMapper);
return this;
}
/**
* The class of a mapper which maps {@link Role}s to {@link org.infinispan.security.AuthorizationPermission}s
*
* @param rolePermissionMapper
*/
public GlobalAuthorizationConfigurationBuilder rolePermissionMapper(RolePermissionMapper rolePermissionMapper) {
permissionMapper.mapper(rolePermissionMapper);
return this;
}
public GlobalRoleConfigurationBuilder role(String name) {
GlobalRoleConfigurationBuilder role = new GlobalRoleConfigurationBuilder(name, this);
roles.put(name, role);
return role;
}
@Override
public void validate() {
roleMapper.validate();
if (attributes.attribute(ENABLED).get() && roleMapper.mapper() == null) {
throw CONFIG.invalidPrincipalRoleMapper();
}
}
@Override
public GlobalAuthorizationConfiguration create() {
Map<String, Role> rolesCfg = new HashMap<>();
for(GlobalRoleConfigurationBuilder role : this.roles.values()) {
Role roleCfg = role.create();
rolesCfg.put(roleCfg.getName(), roleCfg);
}
if (!rolesCfg.isEmpty()) attributes.attribute(ROLES).set(rolesCfg);
return new GlobalAuthorizationConfiguration(attributes.protect(), roleMapper.create(), permissionMapper.create());
}
@Override
public Builder<?> read(GlobalAuthorizationConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.roleMapper.read(template.roleMapperConfiguration(), combine);
this.permissionMapper.read(template.permissionMapperConfiguration(), combine);
this.roles.clear();
for(Role role : template.roles().values()) {
this.role(role.getName()).read(role, combine);
}
return this;
}
}
| 5,449
| 37.380282
| 150
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ScheduledExecutorFactoryConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.AbstractTypedPropertiesConfiguration;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.executors.DefaultScheduledExecutorFactory;
import org.infinispan.executors.ScheduledExecutorFactory;
public class ScheduledExecutorFactoryConfiguration extends AbstractTypedPropertiesConfiguration {
static final AttributeDefinition<ScheduledExecutorFactory> FACTORY = AttributeDefinition.builder("factory", (ScheduledExecutorFactory)new DefaultScheduledExecutorFactory()).immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ExecutorFactoryConfiguration.class, AbstractTypedPropertiesConfiguration.attributeSet(), FACTORY);
}
private final Attribute<ScheduledExecutorFactory> factory;
ScheduledExecutorFactoryConfiguration(AttributeSet attributes) {
super(attributes);
factory = attributes.attribute(FACTORY);
}
public ScheduledExecutorFactory factory() {
return factory.get();
}
AttributeSet attributes() {
return attributes;
}
@Override
public String toString() {
return "ScheduledExecutorFactoryConfiguration [attributes=" + attributes + "]";
}
}
| 1,439
| 37.918919
| 196
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/PrincipalRoleMapperConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.PrincipalRoleMapperConfiguration.CLASS;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.security.PrincipalRoleMapper;
import org.infinispan.security.mappers.ClusterRoleMapper;
public class PrincipalRoleMapperConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<PrincipalRoleMapperConfiguration> {
private final AttributeSet attributes;
private PrincipalRoleMapper principalRoleMapper = new ClusterRoleMapper();
PrincipalRoleMapperConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = PrincipalRoleMapperConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public PrincipalRoleMapperConfigurationBuilder mapper(PrincipalRoleMapper principalRoleMapper) {
this.principalRoleMapper = principalRoleMapper;
return this;
}
@Override
public void validate() {
if (principalRoleMapper != null && PrincipalRoleMapperConfiguration.isCustomMapper(principalRoleMapper)) {
attributes.attribute(CLASS).set(principalRoleMapper.getClass());
}
}
@Override
public PrincipalRoleMapperConfiguration create() {
return new PrincipalRoleMapperConfiguration(attributes.protect(), principalRoleMapper);
}
@Override
public PrincipalRoleMapperConfigurationBuilder read(PrincipalRoleMapperConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.principalRoleMapper = template.roleMapper();
return this;
}
public PrincipalRoleMapper mapper() {
return principalRoleMapper;
}
}
| 1,910
| 35.056604
| 150
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/CachedThreadPoolConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
class CachedThreadPoolConfiguration {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", null, String.class).build();
static final AttributeDefinition<String> THREAD_FACTORY = AttributeDefinition.builder("threadFactory", null, String.class).build();
private final AttributeSet attributes;
private final Attribute<String> name;
private final Attribute<String> threadFactory;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(CachedThreadPoolConfiguration.class, NAME, THREAD_FACTORY);
}
CachedThreadPoolConfiguration(AttributeSet attributes) {
this.attributes = attributes.checkProtection();
this.name = attributes.attribute(NAME);
this.threadFactory = attributes.attribute(THREAD_FACTORY);
}
public AttributeSet attributes() {
return attributes;
}
public String name() {
return name.get();
}
public String threadFactory() {
return threadFactory.get();
}
@Override
public String toString() {
return "CachedThreadPoolConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 1,425
| 30
| 134
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import org.infinispan.commons.util.Features;
import org.infinispan.commons.util.Version;
import org.infinispan.factories.annotations.SurvivesRestarts;
import org.infinispan.factories.scopes.Scope;
import org.infinispan.factories.scopes.Scopes;
/**
* <p>
* Configuration component that exposes the global configuration.
* </p>
*
* @author Manik Surtani
* @author Vladimir Blagojevic
* @author Mircea.Markus@jboss.com
* @author Galder Zamarreño
* @author Pete Muir
* @author Pedro Ruivo
* @since 5.1
*
* @see <a href="../../../config.html#ce_infinispan_global">Configuration reference</a>
*
*/
@Scope(Scopes.GLOBAL)
@SurvivesRestarts
public class GlobalConfiguration {
/**
* Default replication version, from {@link org.infinispan.commons.util.Version#getVersionShort}.
*
* @deprecated Since 9.4, use {@code Version.getVersionShort()} instead.
*/
@Deprecated
public static final short DEFAULT_MARSHALL_VERSION = Version.getVersionShort();
private final Map<Class<?>, ?> modules;
private final SiteConfiguration site;
private final ClassLoader cl;
private final CacheContainerConfiguration cacheContainerConfiguration;
private final Features features;
GlobalConfiguration(CacheContainerConfiguration cacheContainerConfiguration,
List<?> modules, SiteConfiguration site,
ClassLoader cl, Features features) {
this.cacheContainerConfiguration = cacheContainerConfiguration;
Map<Class<?>, Object> moduleMap = new HashMap<>();
for (Object module : modules) {
moduleMap.put(module.getClass(), module);
}
this.modules = Collections.unmodifiableMap(moduleMap);
this.site = site;
this.cl = cl;
this.features = features;
}
CacheContainerConfiguration cacheContainer() {
return cacheContainerConfiguration;
}
public boolean statistics() {
return cacheContainerConfiguration.statistics();
}
public ThreadPoolConfiguration expirationThreadPool() {
return cacheContainerConfiguration.expirationThreadPool();
}
public ThreadPoolConfiguration listenerThreadPool() {
return cacheContainerConfiguration.listenerThreadPool();
}
/**
* @return An empty {@code ThreadPoolConfiguration}.
* @deprecated Since 11.0, no longer used.
*/
@Deprecated
public ThreadPoolConfiguration persistenceThreadPool() {
return cacheContainerConfiguration.persistenceThreadPool();
}
/**
* @return An empty {@code ThreadPoolConfiguration}.
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
public ThreadPoolConfiguration stateTransferThreadPool() {
return cacheContainerConfiguration.stateTransferThreadPool();
}
/**
* @return An empty {@code ThreadPoolConfiguration}.
* @deprecated Since 11.0, no longer used.
*/
@Deprecated
public ThreadPoolConfiguration asyncThreadPool() {
return cacheContainerConfiguration.asyncThreadPool();
}
public ThreadPoolConfiguration nonBlockingThreadPool() {
return cacheContainerConfiguration.nonBlockingThreadPool();
}
public ThreadPoolConfiguration blockingThreadPool() {
return cacheContainerConfiguration.blockingThreadPool();
}
public GlobalMetricsConfiguration metrics() {
return cacheContainerConfiguration.metrics();
}
public GlobalJmxConfiguration jmx() {
return cacheContainerConfiguration.jmx();
}
/**
* @deprecated Since 10.1.3. Use {@link #jmx()} instead. This will be removed in next major version.
*/
@Deprecated
public GlobalJmxConfiguration globalJmxStatistics() {
return jmx();
}
public String cacheManagerName() {
return cacheContainerConfiguration.cacheManagerName();
}
public TransportConfiguration transport() {
return cacheContainerConfiguration.transport();
}
public GlobalSecurityConfiguration security() {
return cacheContainerConfiguration.security();
}
public SerializationConfiguration serialization() {
return cacheContainerConfiguration.serialization();
}
public ShutdownConfiguration shutdown() {
return cacheContainerConfiguration.shutdown();
}
public GlobalStateConfiguration globalState() {
return cacheContainerConfiguration.globalState();
}
/**
* @deprecated Since 11.0, no longer used.
*/
@Deprecated
public String asyncThreadPoolName() {
return cacheContainer().asyncExecutor();
}
public String nonBlockingThreadPoolName() {
return cacheContainer().nonBlockingExecutor();
}
public String listenerThreadPoolName() {
return cacheContainer().listenerExecutor();
}
public String expirationThreadPoolName() {
return cacheContainer().expirationExecutor();
}
/**
* @deprecated Since 11.0, no longer used.
*/
@Deprecated
public String persistenceThreadPoolName() {
return cacheContainer().persistenceExecutor();
}
public String blockingThreadPoolName() {
return cacheContainer().blockingExecutor();
}
/**
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
public String stateTransferThreadPoolName() {
return cacheContainer().stateTransferExecutor();
}
@SuppressWarnings("unchecked")
public <T> T module(Class<T> moduleClass) {
return (T) modules.get(moduleClass);
}
public Map<Class<?>, ?> modules() {
return modules;
}
/**
* Get the classloader in use by this configuration.
*/
public ClassLoader classLoader() {
return cl;
}
public SiteConfiguration sites() {
return site;
}
public Optional<String> defaultCacheName() {
return Optional.ofNullable(cacheContainerConfiguration.defaultCacheName());
}
public Features features() {
return features;
}
public boolean isClustered() {
return transport().transport() != null;
}
/**
* Returns true if this node is configured as a zero-capacity node.
* If the node is zero-capacity node, it won't hold any data except for replicated caches
*
* @return true or false
*/
public boolean isZeroCapacityNode() {
return cacheContainerConfiguration.getZeroCapacityNode();
}
@Override
public String toString() {
return "GlobalConfiguration{" +
", modules=" + modules +
", site=" + site +
", cl=" + cl +
'}';
}
}
| 6,659
| 26.183673
| 103
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalConfigurationChildBuilder.java
|
package org.infinispan.configuration.global;
import java.util.List;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.manager.EmbeddedCacheManager;
public interface GlobalConfigurationChildBuilder {
/**
* Transport-related (i.e. clustering) configuration
*/
TransportConfigurationBuilder transport();
/**
* Global metrics configuration.
*/
GlobalMetricsConfigurationBuilder metrics();
/**
* Global JMX configuration.
*/
GlobalJmxConfigurationBuilder jmx();
/**
* @deprecated Since 10.1.3. Use {@link #jmx()} instead. This will be removed in next major version.
*/
@Deprecated
default GlobalJmxConfigurationBuilder globalJmxStatistics() {
return jmx();
}
/**
* Global serialization (i.e. marshalling) configuration
*/
SerializationConfigurationBuilder serialization();
/**
* Configuration for the listener thread pool
*/
ThreadPoolConfigurationBuilder listenerThreadPool();
/**
* Configuration for the expiration thread pool
*/
ThreadPoolConfigurationBuilder expirationThreadPool();
/**
* Configuration for the persistence thread pool
*/
ThreadPoolConfigurationBuilder persistenceThreadPool();
/**
* Configuration for the state-transfer thread pool
*/
ThreadPoolConfigurationBuilder stateTransferThreadPool();
/**
* Configuration for the asynchronous operations thread pool
*/
ThreadPoolConfigurationBuilder asyncThreadPool();
/**
* Configuration for the non blocking thread pool
*/
ThreadPoolConfigurationBuilder nonBlockingThreadPool();
/**
* Configuration for the blocking thread pool
*/
ThreadPoolConfigurationBuilder blockingThreadPool();
/**
* Security-related configuration
*/
GlobalSecurityConfigurationBuilder security();
/**
* Shutdown configuration
*/
ShutdownConfigurationBuilder shutdown();
/**
* Cross-site replication configuration
*/
SiteConfigurationBuilder site();
/**
* Global state configuration
*/
GlobalStateConfigurationBuilder globalState();
/**
* Global modules configuration
*/
List<Builder<?>> modules();
/**
* Sets the name of the cache that acts as the default cache and is returned by
* {@link EmbeddedCacheManager#getCache()}. Not
*/
GlobalConfigurationBuilder defaultCacheName(String defaultCacheName);
/**
* Builds a {@link GlobalConfiguration} object using the settings applied to this builder
*/
GlobalConfiguration build();
}
| 2,590
| 22.770642
| 103
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/JGroupsConfiguration.java
|
package org.infinispan.configuration.global;
import static org.infinispan.commons.configuration.attributes.IdentityAttributeCopier.identityCopier;
import java.util.List;
import java.util.stream.Stream;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.remoting.transport.Transport;
import org.infinispan.remoting.transport.jgroups.JGroupsChannelConfigurator;
import org.infinispan.util.logging.Log;
/*
* @since 10.0
*/
public class JGroupsConfiguration {
static final AttributeDefinition<Transport> TRANSPORT = AttributeDefinition
.builder("transport", null, Transport.class)
.copier(identityCopier()).immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(JGroupsConfiguration.class, TRANSPORT);
}
private final Attribute<Transport> transport;
private final List<StackFileConfiguration> stackFileConfigurations;
private final List<StackConfiguration> stackConfigurations;
private final AttributeSet attributes;
JGroupsConfiguration(AttributeSet attributes, List<StackFileConfiguration> stackFileConfigurations, List<StackConfiguration> stackConfigurations) {
this.attributes = attributes.checkProtection();
this.transport = attributes.attribute(TRANSPORT);
this.stackFileConfigurations = stackFileConfigurations;
this.stackConfigurations = stackConfigurations;
this.stackConfigurations.forEach(c -> c.configurator().setConfiguration(this));
}
public AttributeSet attributes() {
return attributes;
}
public Transport transport() {
return transport.get();
}
public List<StackFileConfiguration> stackFiles() {
return stackFileConfigurations;
}
public List<StackConfiguration> stacks() {
return stackConfigurations;
}
public boolean isClustered() {
return transport.get() != null;
}
public JGroupsChannelConfigurator configurator(String name) {
if (name == null) {
return null;
}
return Stream.concat(stackConfigurations.stream(), stackFileConfigurations.stream())
.filter(s -> s.name().equals(name))
.map(NamedStackConfiguration::configurator)
.findFirst()
.orElseThrow(() -> Log.CONFIG.missingJGroupsStack(name));
}
@Override
public String toString() {
return "JGroupsConfiguration{" +
"transport=" + transport +
", stackFileConfigurations=" + stackFileConfigurations +
", stackConfigurations=" + stackConfigurations +
'}';
}
}
| 2,757
| 32.634146
| 150
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ThreadPoolConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import java.util.concurrent.ThreadFactory;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.executors.ThreadPoolExecutorFactory;
/**
* @author Galder Zamarreño
*/
public class ThreadPoolConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<ThreadPoolConfiguration> {
String name;
ThreadFactory threadFactory;
ThreadPoolExecutorFactory threadPoolFactory;
public ThreadPoolConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
@Override
public void validate() {
if (threadPoolFactory != null)
threadPoolFactory.validate();
}
public ThreadPoolConfigurationBuilder name(String name) {
this.name = name;
return this;
}
public ThreadPoolConfigurationBuilder threadFactory(ThreadFactory threadFactory) {
this.threadFactory = threadFactory;
return this;
}
public ThreadPoolConfigurationBuilder threadPoolFactory(ThreadPoolExecutorFactory threadPoolFactory) {
this.threadPoolFactory = threadPoolFactory;
return this;
}
@Override
public ThreadPoolConfiguration create() {
return new ThreadPoolConfiguration(name, threadFactory, threadPoolFactory);
}
@Override
public ThreadPoolConfigurationBuilder read(ThreadPoolConfiguration template, Combine combine) {
this.threadFactory = template.threadFactory();
this.threadPoolFactory = template.threadPoolFactory();
return this;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ThreadPoolConfigurationBuilder that = (ThreadPoolConfigurationBuilder) o;
if (threadPoolFactory != null ? !threadPoolFactory.equals(that.threadPoolFactory) : that.threadPoolFactory != null)
return false;
if (threadFactory != null ? !threadFactory.equals(that.threadFactory) : that.threadFactory != null)
return false;
return true;
}
@Override
public int hashCode() {
int result = threadFactory != null ? threadFactory.hashCode() : 0;
result = 31 * result + (threadPoolFactory != null ? threadPoolFactory.hashCode() : 0);
return result;
}
}
| 2,537
| 29.214286
| 132
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/TransportConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.TransportConfiguration.CLUSTER_NAME;
import static org.infinispan.configuration.global.TransportConfiguration.DISTRIBUTED_SYNC_TIMEOUT;
import static org.infinispan.configuration.global.TransportConfiguration.INITIAL_CLUSTER_SIZE;
import static org.infinispan.configuration.global.TransportConfiguration.INITIAL_CLUSTER_TIMEOUT;
import static org.infinispan.configuration.global.TransportConfiguration.MACHINE_ID;
import static org.infinispan.configuration.global.TransportConfiguration.NODE_NAME;
import static org.infinispan.configuration.global.TransportConfiguration.RACK_ID;
import static org.infinispan.configuration.global.TransportConfiguration.RAFT_MEMBERS;
import static org.infinispan.configuration.global.TransportConfiguration.REMOTE_EXECUTOR;
import static org.infinispan.configuration.global.TransportConfiguration.SITE_ID;
import static org.infinispan.configuration.global.TransportConfiguration.STACK;
import static org.infinispan.configuration.global.TransportConfiguration.TRANSPORT_EXECUTOR;
import static org.infinispan.util.logging.Log.CONFIG;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.util.TypedProperties;
import org.infinispan.commons.util.Util;
import org.infinispan.remoting.transport.Transport;
/**
* Configures the transport used for network communications across the cluster.
*/
public class TransportConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<TransportConfiguration> {
// Lazily instantiate this if the user doesn't request an alternate to avoid a hard dep on jgroups library
public static final String DEFAULT_TRANSPORT = "org.infinispan.remoting.transport.jgroups.JGroupsTransport";
private final ThreadsConfigurationBuilder threads;
private final AttributeSet attributes;
private final JGroupsConfigurationBuilder jgroupsConfigurationBuilder;
private TypedProperties typedProperties = new TypedProperties();
TransportConfigurationBuilder(GlobalConfigurationBuilder globalConfig, ThreadsConfigurationBuilder threads) {
super(globalConfig);
this.threads = threads;
this.attributes = TransportConfiguration.attributeSet();
this.jgroupsConfigurationBuilder = new JGroupsConfigurationBuilder(globalConfig);
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Defines the name of the cluster. Nodes only connect to clusters sharing the same name.
*
* @param clusterName
*/
public TransportConfigurationBuilder clusterName(String clusterName) {
attributes.attribute(CLUSTER_NAME).set(clusterName);
return this;
}
/**
* The id of the machine where this node runs. Used for <a
* href="http://community.jboss.org/wiki/DesigningServerHinting">server hinting</a> .
*/
public TransportConfigurationBuilder machineId(String machineId) {
attributes.attribute(MACHINE_ID).set(machineId);
return this;
}
/**
* The id of the rack where this node runs. Used for <a
* href="http://community.jboss.org/wiki/DesigningServerHinting">server hinting</a> .
*/
public TransportConfigurationBuilder rackId(String rackId) {
attributes.attribute(RACK_ID).set(rackId);
return this;
}
/**
* The id of the site where this node runs. Used for <a
* href="http://community.jboss.org/wiki/DesigningServerHinting">server hinting</a> .
*/
public TransportConfigurationBuilder siteId(String siteId) {
attributes.attribute(SITE_ID).set(siteId);
return this;
}
public TransportConfigurationBuilder stack(String stack) {
attributes.attribute(STACK).set(stack);
return this;
}
/**
* Timeout for coordinating cluster formation when nodes join or leave the cluster.
*
* @param distributedSyncTimeout
* @return
*/
public TransportConfigurationBuilder distributedSyncTimeout(long distributedSyncTimeout) {
attributes.attribute(DISTRIBUTED_SYNC_TIMEOUT).set(distributedSyncTimeout);
return this;
}
/**
* Timeout for coordinating cluster formation when nodes join or leave the cluster.
*
* @param distributedSyncTimeout
* @return
*/
public TransportConfigurationBuilder distributedSyncTimeout(long distributedSyncTimeout, TimeUnit unit) {
return distributedSyncTimeout(unit.toMillis(distributedSyncTimeout));
}
/**
* Sets the number of nodes that need to join before the cache container can start. The default is to start
* immediately without waiting.
*/
public TransportConfigurationBuilder initialClusterSize(int clusterSize) {
attributes.attribute(INITIAL_CLUSTER_SIZE).set(clusterSize);
return this;
}
/**
* Sets the timeout for the initial cluster to form. Defaults to 1 minute
*/
public TransportConfigurationBuilder initialClusterTimeout(long initialClusterTimeout, TimeUnit unit) {
attributes.attribute(INITIAL_CLUSTER_TIMEOUT).set(unit.toMillis(initialClusterTimeout));
return this;
}
/**
* Class that represents a network transport. Must implement
* org.infinispan.remoting.transport.Transport
*
* NOTE: Currently Infinispan will not use the object instance, but instead instantiate a new
* instance of the class. Therefore, do not expect any state to survive, and provide a no-args
* constructor to any instance.
*
* @param transport transport instance
*/
public TransportConfigurationBuilder transport(Transport transport) {
jgroupsConfigurationBuilder.transport(transport);
return this;
}
/**
* Name of the current node. This is a friendly name to make logs, etc. make more sense.
* Defaults to a combination of host name and a random number (to differentiate multiple nodes
* on the same host)
*
* @param nodeName
*/
public TransportConfigurationBuilder nodeName(String nodeName) {
attributes.attribute(NODE_NAME).set(nodeName);
return this;
}
/**
* Sets transport properties
*
* @param properties
* @return this TransportConfig
*/
public TransportConfigurationBuilder withProperties(Properties properties) {
this.typedProperties = TypedProperties.toTypedProperties(properties);
return this;
}
/**
* Clears the transport properties
*
* @return this TransportConfig
*/
public TransportConfigurationBuilder clearProperties() {
typedProperties.clear();
return this;
}
public TransportConfigurationBuilder addProperty(String key, Object value) {
typedProperties.put(key, value);
return this;
}
public TransportConfigurationBuilder removeProperty(String key) {
typedProperties.remove(key);
return this;
}
public String getProperty(String key) {
return String.valueOf(typedProperties.get(key));
}
public ThreadPoolConfigurationBuilder transportThreadPool() {
return threads.transportThreadPool();
}
public ThreadPoolConfigurationBuilder remoteCommandThreadPool() {
return threads.remoteCommandThreadPool();
}
@Override
public
void validate() {
if(attributes.attribute(CLUSTER_NAME).isNull()){
throw CONFIG.requireNonNullClusterName();
}
validateRaftMembers();
}
public JGroupsConfigurationBuilder jgroups() {
return jgroupsConfigurationBuilder;
}
@Override
public
TransportConfiguration create() {
//if (typedProperties.containsKey("stack")) attributes.attribute(STACK).set(typedProperties.getProperty("stack"));
return new TransportConfiguration(attributes.protect(),
jgroupsConfigurationBuilder.create(), threads.transportThreadPool().create(), threads.remoteCommandThreadPool().create(), typedProperties);
}
public TransportConfigurationBuilder defaultTransport() {
Transport transport = Util.getInstance(DEFAULT_TRANSPORT, this.getGlobalConfig().getClassLoader());
transport(transport);
return this;
}
@Deprecated
public TransportConfigurationBuilder transportExecutor(String threadPoolName) {
attributes.attribute(TRANSPORT_EXECUTOR).set(threadPoolName);
return this;
}
public TransportConfigurationBuilder remoteExecutor(String threadPoolName) {
attributes.attribute(REMOTE_EXECUTOR).set(threadPoolName);
return this;
}
/**
* Adds a single member to the {@code raft-members}.
*
* @param member The member to add
*/
public TransportConfigurationBuilder raftMember(String member) {
Set<String> newMembers = new HashSet<>(attributes.attribute(RAFT_MEMBERS).get());
if (newMembers.add(member)) {
attributes.attribute(RAFT_MEMBERS).set(Collections.unmodifiableSet(newMembers));
}
return this;
}
/**
* Adds multiple members to the {@code raft-members}.
*
* @param members The members to add
*/
public TransportConfigurationBuilder raftMembers(String... members) {
return raftMembers(Arrays.asList(members));
}
/**
* Adds multiple members to the {@code raft-members}.
*
* @param members The members to add
*/
public TransportConfigurationBuilder raftMembers(Collection<String> members) {
Set<String> newMembers = new HashSet<>(attributes.attribute(RAFT_MEMBERS).get());
if (newMembers.addAll(members)) {
attributes.attribute(RAFT_MEMBERS).set(Collections.unmodifiableSet(newMembers));
}
return this;
}
@Override
public
TransportConfigurationBuilder read(TransportConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.jgroupsConfigurationBuilder.read(template.jgroups(), combine);
this.typedProperties = new TypedProperties(template.properties());
if (template.transport() != null) {
Transport transport = Util.getInstance(template.transport().getClass().getName(), template.transport().getClass().getClassLoader());
transport(transport);
}
return this;
}
public Transport getTransport() {
return jgroupsConfigurationBuilder.jgroupsTransport();
}
@Override
public String toString() {
return "TransportConfigurationBuilder{" +
"threads=" + threads +
", attributes=" + attributes +
", jgroupsConfigurationBuilder=" + jgroupsConfigurationBuilder +
", typedProperties=" + typedProperties +
'}';
}
private void validateRaftMembers() {
Set<String> raftMembers = attributes.attribute(RAFT_MEMBERS).get();
if (raftMembers.isEmpty()) {
//RAFT not enabled
return;
}
String raftId = attributes.attribute(NODE_NAME).get();
if (raftId == null || raftId.isEmpty()) {
throw CONFIG.requireNodeName();
}
if (!raftMembers.contains(raftId)) {
throw CONFIG.nodeNameNotInRaftMembers(String.valueOf(raftMembers));
}
}
}
| 11,440
| 34.421053
| 151
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ThreadPoolBuilderAdapter.java
|
package org.infinispan.configuration.global;
public interface ThreadPoolBuilderAdapter {
ThreadPoolConfiguration asThreadPoolConfigurationBuilder();
}
| 157
| 18.75
| 62
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ThreadsConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.ArrayList;
import java.util.List;
public class ThreadsConfiguration {
private final List<ThreadFactoryConfiguration> threadFactories = new ArrayList<>();
private final List<BoundedThreadPoolConfiguration> boundedThreadPools = new ArrayList<>();
private final List<CachedThreadPoolConfiguration> cachedThreadPools = new ArrayList<>();
private final List<ScheduledThreadPoolConfiguration> scheduledThreadPools = new ArrayList<>();
private final ThreadPoolConfiguration asyncThreadPool;
private final ThreadPoolConfiguration expirationThreadPool;
private final ThreadPoolConfiguration listenerThreadPool;
private final ThreadPoolConfiguration persistenceThreadPool;
private final ThreadPoolConfiguration remoteThreadPool;
private final ThreadPoolConfiguration stateTransferThreadPool;
private final ThreadPoolConfiguration transportThreadPool;
private final ThreadPoolConfiguration nonBlockingThreadPool;
private final ThreadPoolConfiguration blockingThreadPool;
ThreadsConfiguration(List<ThreadFactoryConfiguration> threadFactories,
List<BoundedThreadPoolConfiguration> boundedThreadPools,
List<CachedThreadPoolConfiguration> cachedThreadPools,
List<ScheduledThreadPoolConfiguration> scheduledThreadPools,
ThreadPoolConfiguration asyncThreadPool,
ThreadPoolConfiguration expirationThreadPool,
ThreadPoolConfiguration listenerThreadPool,
ThreadPoolConfiguration persistenceThreadPool,
ThreadPoolConfiguration remoteThreadPool,
ThreadPoolConfiguration stateTransferThreadPool,
ThreadPoolConfiguration transportThreadPool,
ThreadPoolConfiguration nonBlockingThreadPool,
ThreadPoolConfiguration blockingThreadPool) {
this.asyncThreadPool = asyncThreadPool;
this.expirationThreadPool = expirationThreadPool;
this.listenerThreadPool = listenerThreadPool;
this.persistenceThreadPool = persistenceThreadPool;
this.remoteThreadPool = remoteThreadPool;
this.stateTransferThreadPool = stateTransferThreadPool;
this.transportThreadPool = transportThreadPool;
this.nonBlockingThreadPool = nonBlockingThreadPool;
this.blockingThreadPool = blockingThreadPool;
this.threadFactories.addAll(threadFactories);
this.boundedThreadPools.addAll(boundedThreadPools);
this.cachedThreadPools.addAll(cachedThreadPools);
this.scheduledThreadPools.addAll(scheduledThreadPools);
}
public ThreadPoolConfiguration asyncThreadPool() {
return asyncThreadPool;
}
public ThreadPoolConfiguration expirationThreadPool() {
return expirationThreadPool;
}
public ThreadPoolConfiguration listenerThreadPool() {
return listenerThreadPool;
}
public ThreadPoolConfiguration persistenceThreadPool() {
return persistenceThreadPool;
}
public ThreadPoolConfiguration remoteThreadPool() {
return remoteThreadPool;
}
/**
* @return An empty {@code ThreadPoolConfiguration}.
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
public ThreadPoolConfiguration stateTransferThreadPool() {
return stateTransferThreadPool;
}
/**
* @return An empty {@code ThreadPoolConfiguration}.
* @deprecated Since 11.0, no longer used.
*/
public ThreadPoolConfiguration transportThreadPool() {
return transportThreadPool;
}
public ThreadPoolConfiguration nonBlockingThreadPool() {
return nonBlockingThreadPool;
}
public ThreadPoolConfiguration blockingThreadPool() {
return blockingThreadPool;
}
public List<ThreadFactoryConfiguration> threadFactories() {
return threadFactories;
}
public List<BoundedThreadPoolConfiguration> boundedThreadPools() {
return boundedThreadPools;
}
public List<CachedThreadPoolConfiguration> cachedThreadPools() {
return cachedThreadPools;
}
public List<ScheduledThreadPoolConfiguration> scheduledThreadPools() {
return scheduledThreadPools;
}
@Override
public String toString() {
return "ThreadsConfiguration{" +
"threadFactories=" + threadFactories +
", boundedThreadPools=" + boundedThreadPools +
", cachedThreadPools=" + cachedThreadPools +
", scheduledThreadPools=" + scheduledThreadPools +
", asyncThreadPool=" + asyncThreadPool +
", expirationThreadPool=" + expirationThreadPool +
", listenerThreadPool=" + listenerThreadPool +
", persistenceThreadPool=" + persistenceThreadPool +
", remoteThreadPool=" + remoteThreadPool +
", stateTransferThreadPool=" + stateTransferThreadPool +
", transportThreadPool=" + transportThreadPool +
'}';
}
}
| 5,046
| 38.429688
| 97
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ShutdownConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.ShutdownConfiguration.HOOK_BEHAVIOR;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class ShutdownConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<ShutdownConfiguration> {
private final AttributeSet attributes;
ShutdownConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = ShutdownConfiguration.attributeDefinitionSet();
}
public ShutdownConfigurationBuilder hookBehavior(ShutdownHookBehavior hookBehavior) {
attributes.attribute(HOOK_BEHAVIOR).set(hookBehavior);
return this;
}
public AttributeSet attributes() {
return attributes;
}
@Override
public
void validate() {
// No-op, no validation required
}
@Override
public
ShutdownConfiguration create() {
return new ShutdownConfiguration(attributes.protect());
}
@Override
public
ShutdownConfigurationBuilder read(ShutdownConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "ShutdownConfigurationBuilder{" +
"attributes=" + attributes +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ShutdownConfigurationBuilder that = (ShutdownConfigurationBuilder) o;
return attributes.equals(that.attributes);
}
@Override
public int hashCode() {
return attributes.hashCode();
}
}
| 1,827
| 26.283582
| 128
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ThreadsConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class ThreadsConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<ThreadsConfiguration> {
private final ThreadPoolConfigurationBuilder asyncThreadPool;
private final ThreadPoolConfigurationBuilder expirationThreadPool;
private final ThreadPoolConfigurationBuilder listenerThreadPool;
private final ThreadPoolConfigurationBuilder persistenceThreadPool;
private final ThreadPoolConfigurationBuilder remoteCommandThreadPool;
private final ThreadPoolConfigurationBuilder stateTransferThreadPool;
private final ThreadPoolConfigurationBuilder transportThreadPool;
private final ThreadPoolConfigurationBuilder nonBlockingThreadPool;
private final ThreadPoolConfigurationBuilder blockingThreadPool;
private List<ThreadFactoryConfigurationBuilder> threadFactoryBuilders = new ArrayList<>();
private List<BoundedThreadPoolConfigurationBuilder> boundedThreadPoolBuilders = new ArrayList<>();
private List<ScheduledThreadPoolConfigurationBuilder> scheduledThreadPoolBuilders = new ArrayList<>();
private List<CachedThreadPoolConfigurationBuilder> cachedThreadPoolBuilders = new ArrayList<>();
private final Map<String, ThreadFactoryConfigurationBuilder> threadFactoryByName = new HashMap<>();
private final Map<String, ThreadPoolBuilderAdapter> threadPoolByName = new HashMap<>();
ThreadsConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
this.asyncThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.expirationThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.listenerThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.persistenceThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.stateTransferThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.remoteCommandThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.transportThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.nonBlockingThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
this.blockingThreadPool = new ThreadPoolConfigurationBuilder(globalConfig);
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
public ThreadFactoryConfigurationBuilder addThreadFactory(String name) {
ThreadFactoryConfigurationBuilder threadFactoryConfigurationBuilder = new ThreadFactoryConfigurationBuilder(getGlobalConfig(), name);
threadFactoryBuilders.add(threadFactoryConfigurationBuilder);
threadFactoryByName.put(name, threadFactoryConfigurationBuilder);
return threadFactoryConfigurationBuilder;
}
public BoundedThreadPoolConfigurationBuilder addBoundedThreadPool(String name) {
BoundedThreadPoolConfigurationBuilder configurationBuilder = new BoundedThreadPoolConfigurationBuilder(getGlobalConfig(), name);
boundedThreadPoolBuilders.add(configurationBuilder);
threadPoolByName.put(name, configurationBuilder);
return configurationBuilder;
}
public ScheduledThreadPoolConfigurationBuilder addScheduledThreadPool(String name) {
ScheduledThreadPoolConfigurationBuilder configurationBuilder = new ScheduledThreadPoolConfigurationBuilder(getGlobalConfig(), name);
scheduledThreadPoolBuilders.add(configurationBuilder);
threadPoolByName.put(name, configurationBuilder);
return configurationBuilder;
}
public CachedThreadPoolConfigurationBuilder addCachedThreadPool(String name) {
CachedThreadPoolConfigurationBuilder configurationBuilder = new CachedThreadPoolConfigurationBuilder(getGlobalConfig(), name);
cachedThreadPoolBuilders.add(configurationBuilder);
threadPoolByName.put(name, configurationBuilder);
return configurationBuilder;
}
@Override
public ThreadPoolConfigurationBuilder asyncThreadPool() {
return asyncThreadPool;
}
@Override
public ThreadPoolConfigurationBuilder expirationThreadPool() {
return expirationThreadPool;
}
@Override
public ThreadPoolConfigurationBuilder listenerThreadPool() {
return listenerThreadPool;
}
@Override
public ThreadPoolConfigurationBuilder persistenceThreadPool() {
return persistenceThreadPool;
}
public ThreadPoolConfigurationBuilder remoteCommandThreadPool() {
return remoteCommandThreadPool;
}
/**
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
@Override
public ThreadPoolConfigurationBuilder stateTransferThreadPool() {
return stateTransferThreadPool;
}
/**
* @deprecated Since 11.0, no longer used.
*/
@Deprecated
public ThreadPoolConfigurationBuilder transportThreadPool() {
return transportThreadPool;
}
@Override
public ThreadPoolConfigurationBuilder nonBlockingThreadPool() {
return nonBlockingThreadPool;
}
@Override
public ThreadPoolConfigurationBuilder blockingThreadPool() {
return blockingThreadPool;
}
@Override
public ThreadsConfigurationBuilder read(ThreadsConfiguration template, Combine combine) {
this.asyncThreadPool.read(template.asyncThreadPool(), combine);
this.expirationThreadPool.read(template.expirationThreadPool(), combine);
this.listenerThreadPool.read(template.listenerThreadPool(), combine);
this.persistenceThreadPool.read(template.persistenceThreadPool(), combine);
this.remoteCommandThreadPool.read(template.remoteThreadPool(), combine);
this.stateTransferThreadPool.read(template.stateTransferThreadPool(), combine);
this.transportThreadPool.read(template.transportThreadPool(), combine);
this.nonBlockingThreadPool.read(template.nonBlockingThreadPool(), combine);
this.blockingThreadPool.read(template.blockingThreadPool(), combine);
template.threadFactories().forEach(s -> threadFactoryBuilders.add(new ThreadFactoryConfigurationBuilder(getGlobalConfig(), s.name().get()).read(s, combine)));
template.boundedThreadPools().forEach(s -> boundedThreadPoolBuilders.add(new BoundedThreadPoolConfigurationBuilder(getGlobalConfig(), s.name()).read(s, combine)));
template.cachedThreadPools().forEach(s -> cachedThreadPoolBuilders.add(new CachedThreadPoolConfigurationBuilder(getGlobalConfig(), s.name()).read(s, combine)));
template.scheduledThreadPools().forEach(s -> scheduledThreadPoolBuilders.add(new ScheduledThreadPoolConfigurationBuilder(getGlobalConfig(), s.name()).read(s, combine)));
return this;
}
@Override
public ThreadsConfiguration create() {
List<ThreadFactoryConfiguration> threadFactoryConfigurations = threadFactoryBuilders
.stream().map(ThreadFactoryConfigurationBuilder::create).collect(Collectors.toList());
List<BoundedThreadPoolConfiguration> boundedThreadPoolConfigurations = boundedThreadPoolBuilders
.stream().map(BoundedThreadPoolConfigurationBuilder::create).collect(Collectors.toList());
List<ScheduledThreadPoolConfiguration> scheduledThreadPoolConfigurations = scheduledThreadPoolBuilders
.stream().map(ScheduledThreadPoolConfigurationBuilder::create).collect(Collectors.toList());
List<CachedThreadPoolConfiguration> cachedThreadPoolConfigurations = cachedThreadPoolBuilders
.stream().map(CachedThreadPoolConfigurationBuilder::create).collect(Collectors.toList());
return new ThreadsConfiguration(threadFactoryConfigurations, boundedThreadPoolConfigurations,
cachedThreadPoolConfigurations, scheduledThreadPoolConfigurations,
asyncThreadPool.create(),
expirationThreadPool.create(),
listenerThreadPool.create(),
persistenceThreadPool.create(),
remoteCommandThreadPool.create(),
stateTransferThreadPool.create(),
transportThreadPool.create(),
nonBlockingThreadPool.create(),
blockingThreadPool.create());
}
public ThreadsConfigurationBuilder nodeName(String value) {
threadFactoryBuilders.forEach(tfb -> tfb.nodeName(value));
return this;
}
public ThreadFactoryConfigurationBuilder getThreadFactory(String threadFactoryName) {
return threadFactoryByName.get(threadFactoryName);
}
public ThreadPoolBuilderAdapter getThreadPool(String threadFactoryName) {
return threadPoolByName.get(threadFactoryName);
}
}
| 8,809
| 45.368421
| 175
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalStateConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.Attribute;
import org.infinispan.globalstate.ConfigurationStorage;
import org.infinispan.globalstate.LocalConfigurationStorage;
/**
*
* GlobalStateConfiguration.
*
* @author Tristan Tarrant
* @since 8.1
*/
public class GlobalStateConfiguration {
public static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder(Attribute.ENABLED, false).autoPersist(false).immutable().build();
public static final AttributeDefinition<UncleanShutdownAction> UNCLEAN_SHUTDOWN_ACTION = AttributeDefinition.builder(Attribute.UNCLEAN_SHUTDOWN_ACTION, UncleanShutdownAction.FAIL).immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GlobalStateConfiguration.class, ENABLED, UNCLEAN_SHUTDOWN_ACTION);
}
private final AttributeSet attributes;
private final boolean enabled;
private final GlobalStatePathConfiguration persistenceLocationConfiguration;
private final GlobalStatePathConfiguration sharedPersistenceLocationConfiguration;
private final TemporaryGlobalStatePathConfiguration temporaryLocationConfiguration;
private final GlobalStorageConfiguration globalStorageConfiguration;
public GlobalStateConfiguration(AttributeSet attributes,
GlobalStatePathConfiguration persistenceLocationConfiguration,
GlobalStatePathConfiguration sharedPersistenceLocationConfiguration,
TemporaryGlobalStatePathConfiguration temporaryLocationConfiguration,
GlobalStorageConfiguration globalStorageConfiguration) {
this.attributes = attributes.checkProtection();
this.enabled = attributes.attribute(ENABLED).get();
this.persistenceLocationConfiguration = persistenceLocationConfiguration;
this.sharedPersistenceLocationConfiguration = sharedPersistenceLocationConfiguration;
this.temporaryLocationConfiguration = temporaryLocationConfiguration;
this.globalStorageConfiguration = globalStorageConfiguration;
}
public boolean enabled() {
return enabled;
}
public UncleanShutdownAction uncleanShutdownAction() {
return attributes.attribute(UNCLEAN_SHUTDOWN_ACTION).get();
}
/**
* Returns the filesystem path where persistent state data which needs to survive container
* restarts should be stored. Defaults to the user.dir system property which usually is where the
* application was started. Warning: this path must NOT be shared with other instances.
*/
public String persistentLocation() {
return persistenceLocationConfiguration.getLocation();
}
public GlobalStatePathConfiguration persistenceConfiguration() {
return persistenceLocationConfiguration;
}
/**
* Returns the filesystem path where shared persistent state data which needs to survive container
* restarts should be stored. Defaults to the {@link #persistentLocation()}.
* This path may be shared among multiple instances.
*/
public String sharedPersistentLocation() {
if (sharedPersistenceLocationConfiguration.isModified()) {
return sharedPersistenceLocationConfiguration.getLocation();
} else {
return persistentLocation();
}
}
public GlobalStatePathConfiguration sharedPersistenceConfiguration() {
return sharedPersistenceLocationConfiguration;
}
/**
* Returns the filesystem path where temporary state should be stored. Defaults to the value of
* the java.io.tmpdir system property.
*/
public String temporaryLocation() {
return temporaryLocationConfiguration.getLocation();
}
public TemporaryGlobalStatePathConfiguration temporaryLocationConfiguration() {
return temporaryLocationConfiguration;
}
public ConfigurationStorage configurationStorage() {
return globalStorageConfiguration.configurationStorage();
}
public GlobalStorageConfiguration globalStorageConfiguration() {
return globalStorageConfiguration;
}
/**
* Returns the {@link LocalConfigurationStorage} {@link Supplier}
*/
public Supplier<? extends LocalConfigurationStorage> configurationStorageClass() {
return globalStorageConfiguration.storageSupplier();
}
public AttributeSet attributes() {
return attributes;
}
@Override
public String toString() {
return "GlobalStateConfiguration [attributes=" + attributes + "]";
}
}
| 4,752
| 38.280992
| 203
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalAuthorizationConfiguration.java
|
package org.infinispan.configuration.global;
import static org.infinispan.commons.configuration.attributes.IdentityAttributeCopier.identityCopier;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeInitializer;
import org.infinispan.commons.configuration.attributes.AttributeSerializer;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.security.AuditLogger;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.PrincipalRoleMapper;
import org.infinispan.security.Role;
import org.infinispan.security.RolePermissionMapper;
import org.infinispan.security.audit.NullAuditLogger;
/**
* GlobalAuthorizationConfiguration.
*
* @author Tristan Tarrant
* @since 7.0
*/
public class GlobalAuthorizationConfiguration {
public static final Map<String, Role> DEFAULT_ROLES;
public static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.ENABLED, false).immutable().build();
public static final AttributeDefinition<AuditLogger> AUDIT_LOGGER = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.AUDIT_LOGGER, (AuditLogger) new NullAuditLogger())
.copier(identityCopier()).serializer(AttributeSerializer.INSTANCE_CLASS_NAME).immutable().build();
public static final AttributeDefinition<Map<String, Role>> ROLES = AttributeDefinition.<Map<String, Role>>builder(org.infinispan.configuration.parsing.Attribute.ROLES, new HashMap<>())
.initializer(new AttributeInitializer<>() {
@Override
public Map<String, Role> initialize() {
return DEFAULT_ROLES;
}
}).build();
public static final AttributeDefinition<Boolean> GROUP_ONLY_MAPPING = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.GROUP_ONLY_MAPPING, true, Boolean.class).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GlobalAuthorizationConfiguration.class, ENABLED, AUDIT_LOGGER, ROLES, GROUP_ONLY_MAPPING);
}
static {
DEFAULT_ROLES = Map.of(
"admin", Role.newRole("admin", true,
AuthorizationPermission.ALL
),
"application", Role.newRole("application", true,
AuthorizationPermission.ALL_READ,
AuthorizationPermission.ALL_WRITE,
AuthorizationPermission.LISTEN,
AuthorizationPermission.EXEC,
AuthorizationPermission.MONITOR
),
"deployer", Role.newRole("deployer", true,
AuthorizationPermission.ALL_READ,
AuthorizationPermission.ALL_WRITE,
AuthorizationPermission.LISTEN,
AuthorizationPermission.EXEC,
AuthorizationPermission.CREATE,
AuthorizationPermission.MONITOR
),
"observer", Role.newRole("observer", true,
AuthorizationPermission.ALL_READ,
AuthorizationPermission.MONITOR
),
"monitor", Role.newRole("monitor", true,
AuthorizationPermission.MONITOR
),
// Deprecated roles. Will be removed in Infinispan 16.0
"___schema_manager", Role.newRole("___schema_manager", false,
AuthorizationPermission.CREATE
),
"___script_manager", Role.newRole("___script_manager", false,
AuthorizationPermission.CREATE
));
}
private final Attribute<Boolean> enabled;
private final Attribute<AuditLogger> auditLogger;
private final Map<String, Role> roles;
private final PrincipalRoleMapperConfiguration roleMapperConfiguration;
private final RolePermissionMapperConfiguration permissionMapperConfiguration;
private final RolePermissionMapper rolePermissionMapper;
private final boolean groupOnlyMapping;
private final AttributeSet attributes;
public GlobalAuthorizationConfiguration(AttributeSet attributes, PrincipalRoleMapperConfiguration roleMapperConfiguration, RolePermissionMapperConfiguration permissionMapperConfiguration) {
this.attributes = attributes.checkProtection();
this.enabled = attributes.attribute(ENABLED);
this.auditLogger = attributes.attribute(AUDIT_LOGGER);
this.roles = attributes.attribute(ROLES).get();
this.roleMapperConfiguration = roleMapperConfiguration;
this.permissionMapperConfiguration = permissionMapperConfiguration;
this.rolePermissionMapper = permissionMapperConfiguration.permissionMapper();
this.groupOnlyMapping = attributes.attribute(GROUP_ONLY_MAPPING).get();
}
public boolean enabled() {
return enabled.get();
}
public AuditLogger auditLogger() {
return auditLogger.get();
}
public PrincipalRoleMapper principalRoleMapper() {
return roleMapperConfiguration.roleMapper();
}
public RolePermissionMapper rolePermissionMapper() {
return rolePermissionMapper;
}
public PrincipalRoleMapperConfiguration roleMapperConfiguration() {
return roleMapperConfiguration;
}
public boolean isDefaultRoles() {
return roles == DEFAULT_ROLES;
}
public boolean groupOnlyMapping() {
return groupOnlyMapping;
}
public RolePermissionMapperConfiguration permissionMapperConfiguration() {
return permissionMapperConfiguration;
}
public Map<String, Role> roles() {
Map<String, Role> all = new HashMap<>(roles);
if (rolePermissionMapper != null) {
all.putAll(rolePermissionMapper.getAllRoles());
}
return all;
}
public void addRole(Role role) {
roles.put(role.getName(), role);
}
public boolean hasRole(String name) {
return roles.containsKey(name) || (rolePermissionMapper != null && rolePermissionMapper.hasRole(name));
}
public Role getRole(String name) {
Role role = roles.get(name);
if (role != null) {
return role;
} else if (rolePermissionMapper != null) {
return rolePermissionMapper.getRole(name);
} else {
return null;
}
}
public AttributeSet attributes() {
return attributes;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GlobalAuthorizationConfiguration that = (GlobalAuthorizationConfiguration) o;
return Objects.equals(roleMapperConfiguration, that.roleMapperConfiguration) &&
Objects.equals(permissionMapperConfiguration, that.permissionMapperConfiguration) &&
Objects.equals(attributes, that.attributes);
}
@Override
public int hashCode() {
return Objects.hash(roleMapperConfiguration, permissionMapperConfiguration, attributes);
}
@Override
public String toString() {
return "GlobalAuthorizationConfiguration{" +
"roleMapperConfiguration=" + roleMapperConfiguration +
"permissionMapperConfiguration=" + permissionMapperConfiguration +
", attributes=" + attributes +
'}';
}
}
| 7,464
| 38.497354
| 209
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalMetricsConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.Objects;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* Configuration for metrics. See {@link GlobalMetricsConfigurationBuilder}.
*/
public class GlobalMetricsConfiguration {
public static final AttributeDefinition<Boolean> GAUGES = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.GAUGES, true).immutable().build();
public static final AttributeDefinition<Boolean> HISTOGRAMS = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.HISTOGRAMS, false).immutable().build();
public static final AttributeDefinition<String> PREFIX = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.PREFIX, "").immutable().build();
public static final AttributeDefinition<Boolean> NAMES_AS_TAGS = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.NAMES_AS_TAGS, false).immutable().build();
public static final AttributeDefinition<Boolean> ACCURATE_SIZE = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.ACCURATE_SIZE, false).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GlobalMetricsConfiguration.class, GAUGES, HISTOGRAMS, PREFIX, NAMES_AS_TAGS, ACCURATE_SIZE);
}
private final AttributeSet attributes;
private final Attribute<Boolean> gauges;
private final Attribute<Boolean> histograms;
private final Attribute<String> prefix;
private final Attribute<Boolean> namesAsTags;
private final Attribute<Boolean> accurateSize;
GlobalMetricsConfiguration(AttributeSet attributes) {
this.attributes = attributes.checkProtection();
this.gauges = attributes.attribute(GAUGES);
this.histograms = attributes.attribute(HISTOGRAMS);
this.prefix = attributes.attribute(PREFIX);
this.namesAsTags = attributes.attribute(NAMES_AS_TAGS);
this.accurateSize = attributes.attribute(ACCURATE_SIZE);
}
public AttributeSet attributes() {
return attributes;
}
/**
* Metrics are enabled if at least one of the metric types is enabled. See {@link #gauges()}, {@link #histograms()}.
*/
public boolean enabled() {
return gauges() || histograms();
}
/**
* Are gauges enabled?
*/
public boolean gauges() {
return gauges.get();
}
/**
* Are histograms enabled?
*/
public boolean histograms() {
return histograms.get();
}
/**
* The global prefix to add to all metric names.
*/
public String prefix() {
return prefix.get();
}
/**
* Put the cache manager and cache name in tags rather then include them in the metric name.
*/
public boolean namesAsTags() {
return namesAsTags.get();
}
/**
* Whether cache sizes should be computed
* @return
*/
public boolean accurateSize() {
return accurateSize.get();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GlobalMetricsConfiguration that = (GlobalMetricsConfiguration) o;
return Objects.equals(attributes, that.attributes);
}
@Override
public int hashCode() {
return attributes != null ? attributes.hashCode() : 0;
}
@Override
public String toString() {
return "GlobalMetricsConfiguration{attributes=" + attributes + '}';
}
}
| 3,615
| 33.438095
| 185
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/UncleanShutdownAction.java
|
package org.infinispan.configuration.global;
/**
* Defines the action taken when a dangling lock file is found in the persistent global state, signifying an
* unclean shutdown of the node (usually because of a crash or an external termination).
*
* @since 15.0
*/
public enum UncleanShutdownAction {
/**
* Prevents startup of the cache manager if a dangling lock file is found in the persistent global state.
*/
FAIL,
/**
* Clears the persistent global state if a dangling lock file is found in the persistent global state.
*/
PURGE,
/**
* Ignores the presence of a dangling lock file in the persistent global state.
*/
IGNORE
}
| 677
| 28.478261
| 108
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalJmxConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.GlobalJmxConfiguration.DOMAIN;
import static org.infinispan.configuration.global.GlobalJmxConfiguration.ENABLED;
import static org.infinispan.configuration.global.GlobalJmxConfiguration.MBEAN_SERVER_LOOKUP;
import static org.infinispan.configuration.global.GlobalJmxConfiguration.PROPERTIES;
import java.util.Properties;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.jmx.MBeanServerLookup;
import org.infinispan.commons.jmx.PlatformMBeanServerLookup;
import org.infinispan.commons.util.TypedProperties;
/**
* Configures JMX for the cache manager and its caches.
*
* @since 10.1.3
*/
public class GlobalJmxConfigurationBuilder extends GlobalJmxStatisticsConfigurationBuilder implements Builder<GlobalJmxConfiguration> {
private final AttributeSet attributes;
GlobalJmxConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = GlobalJmxConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Sets properties which are then passed to the MBean Server Lookup implementation specified.
*
* @param properties properties to pass to the MBean Server Lookup
*/
public GlobalJmxConfigurationBuilder withProperties(Properties properties) {
attributes.attribute(PROPERTIES).set(new TypedProperties(properties));
return this;
}
public GlobalJmxConfigurationBuilder addProperty(String key, String value) {
TypedProperties properties = attributes.attribute(PROPERTIES).get();
properties.put(key, value);
attributes.attribute(PROPERTIES).set(TypedProperties.toTypedProperties(properties));
return this;
}
/**
* If JMX is enabled then all 'published' JMX objects will appear under this name. This is optional, if not specified
* a default domain name will be set by default.
*
* @param domain
*/
public GlobalJmxConfigurationBuilder domain(String domain) {
attributes.attribute(DOMAIN).set(domain);
return this;
}
/**
* If JMX is enabled, this property represents the name of this cache manager. It offers the possibility for clients
* to provide a user-defined name to the cache manager which later can be used to identify the cache manager within a
* JMX based management tool amongst other cache managers that might be running under the same JVM.
*
* @deprecated Use {@link GlobalConfigurationBuilder#cacheManagerName(String)} instead
*/
@Deprecated
public GlobalJmxConfigurationBuilder cacheManagerName(String cacheManagerName) {
getGlobalConfig().cacheContainer().name(cacheManagerName);
return this;
}
/**
* Sets the instance of the {@link org.infinispan.commons.jmx.MBeanServerLookup} class to be used to bound JMX MBeans
* to.
*
* @param mBeanServerLookupInstance An instance of {@link org.infinispan.commons.jmx.MBeanServerLookup}
*/
public GlobalJmxConfigurationBuilder mBeanServerLookup(MBeanServerLookup mBeanServerLookupInstance) {
attributes.attribute(MBEAN_SERVER_LOOKUP).set(mBeanServerLookupInstance);
return this;
}
/**
* Disables JMX in the cache manager.
*/
public GlobalJmxConfigurationBuilder disable() {
enabled(false);
return this;
}
/**
* Enables JMX in the cache manager.
*/
public GlobalJmxConfigurationBuilder enable() {
enabled(true);
return this;
}
/**
* Enables JMX in the cache manager.
*/
public GlobalJmxConfigurationBuilder enabled(boolean enabled) {
attributes.attribute(ENABLED).set(enabled);
return this;
}
public boolean enabled() {
return attributes.attribute(ENABLED).get();
}
@Override
public GlobalJmxConfiguration create() {
if (enabled() && attributes.attribute(MBEAN_SERVER_LOOKUP).isNull()) {
mBeanServerLookup(new PlatformMBeanServerLookup());
}
return new GlobalJmxConfiguration(attributes.protect(), getGlobalConfig().cacheContainer().name());
}
@Override
public GlobalJmxConfigurationBuilder read(GlobalJmxConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "GlobalJmxConfigurationBuilder [attributes=" + attributes + "]";
}
}
| 4,639
| 33.37037
| 135
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ThreadPoolConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.concurrent.ThreadFactory;
import org.infinispan.commons.executors.ThreadPoolExecutorFactory;
/**
* @author Galder Zamarreño
*/
public class ThreadPoolConfiguration {
private final String name;
private final ThreadFactory threadFactory;
private final ThreadPoolExecutorFactory threadPoolFactory;
protected ThreadPoolConfiguration(String name, ThreadFactory threadFactory, ThreadPoolExecutorFactory threadPoolFactory) {
this.name = name;
this.threadFactory = threadFactory;
this.threadPoolFactory = threadPoolFactory;
}
public <T extends ThreadPoolExecutorFactory> T threadPoolFactory() {
return (T) threadPoolFactory;
}
public <T extends ThreadFactory> T threadFactory() {
return (T) threadFactory;
}
public String name() {
return name;
}
@Override
public String toString() {
return "ThreadPoolConfiguration{" +
"name=" + name +
", threadFactory=" + threadFactory +
", threadPoolFactory=" + threadPoolFactory +
'}';
}
}
| 1,125
| 24.590909
| 125
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalSecurityConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.GlobalSecurityConfiguration.CACHE_SIZE;
import static org.infinispan.configuration.global.GlobalSecurityConfiguration.CACHE_TIMEOUT;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* GlobalSecurityConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 7.0
*/
public class GlobalSecurityConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements GlobalSecurityConfigurationChildBuilder, Builder<GlobalSecurityConfiguration> {
private final GlobalAuthorizationConfigurationBuilder authorizationBuilder;
private final AttributeSet attributes;
public GlobalSecurityConfigurationBuilder(GlobalConfigurationBuilder builder) {
super(builder);
this.authorizationBuilder = new GlobalAuthorizationConfigurationBuilder(this);
this.attributes = GlobalSecurityConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public GlobalAuthorizationConfigurationBuilder authorization() {
return authorizationBuilder;
}
@Override
public GlobalSecurityConfigurationBuilder securityCacheSize(int securityCacheSize) {
attributes.attribute(CACHE_SIZE).set(securityCacheSize);
return this;
}
@Override
public GlobalSecurityConfigurationBuilder securityCacheTimeout(long securityCacheTimeout, TimeUnit unit) {
attributes.attribute(CACHE_TIMEOUT).set(unit.toMillis(securityCacheTimeout));
return this;
}
@Override
public void validate() {
authorizationBuilder.validate();
}
@Override
public GlobalSecurityConfiguration create() {
return new GlobalSecurityConfiguration(authorizationBuilder.create(), attributes.protect());
}
@Override
public GlobalSecurityConfigurationBuilder read(GlobalSecurityConfiguration template, Combine combine) {
this.authorizationBuilder.read(template.authorization(), combine);
this.attributes.read(template.attributes(), combine);
return this;
}
}
| 2,271
| 32.910448
| 181
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ScheduledThreadPoolConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.ScheduledThreadPoolConfiguration.NAME;
import static org.infinispan.configuration.global.ScheduledThreadPoolConfiguration.THREAD_FACTORY;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.executors.ScheduledThreadPoolExecutorFactory;
import org.infinispan.factories.threads.DefaultThreadFactory;
/*
* @since 10.0
*/
public class ScheduledThreadPoolConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<ScheduledThreadPoolConfiguration>, ThreadPoolBuilderAdapter {
private final AttributeSet attributes;
ScheduledThreadPoolConfigurationBuilder(GlobalConfigurationBuilder globalConfig, String name) {
super(globalConfig);
attributes = ScheduledThreadPoolConfiguration.attributeDefinitionSet();
attributes.attribute(NAME).set(name);
}
public AttributeSet attributes() {
return attributes;
}
public ScheduledThreadPoolConfigurationBuilder threadFactory(String threadFactory) {
attributes.attribute(THREAD_FACTORY).set(threadFactory);
return this;
}
public String threadFactory() {
return attributes.attribute(THREAD_FACTORY).get();
}
public String name() {
return attributes.attribute(CachedThreadPoolConfiguration.NAME).get();
}
@Override
public ScheduledThreadPoolConfiguration create() {
return new ScheduledThreadPoolConfiguration(attributes.protect());
}
@Override
public ScheduledThreadPoolConfigurationBuilder read(ScheduledThreadPoolConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "ScheduledThreadPoolConfigurationBuilder{" +
"attributes=" + attributes +
'}';
}
@Override
public ThreadPoolConfiguration asThreadPoolConfigurationBuilder() {
ThreadPoolConfigurationBuilder builder = new ThreadPoolConfigurationBuilder(getGlobalConfig());
builder.threadPoolFactory(ScheduledThreadPoolExecutorFactory.create());
DefaultThreadFactory threadFactory = getGlobalConfig().threads().getThreadFactory(threadFactory()).create().getThreadFactory(false);
builder.threadFactory(threadFactory);
builder.name(name());
return builder.create();
}
}
| 2,532
| 35.185714
| 176
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/SiteConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.remoting.transport.Transport;
/**
* @author Mircea.Markus@jboss.com
* @since 5.2
* @deprecated since 11.0. The local site name is fetched via {@link Transport#localSiteName()}
*/
@Deprecated
public class SiteConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<SiteConfiguration> {
private String localSite;
SiteConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
/**
* Sets the name of the local site. Must be a valid name from the list of sites defined.
*/
@Deprecated
public SiteConfigurationBuilder localSite(String localSite) {
this.localSite = localSite;
return this;
}
@Override
public
void validate() {
}
@Override
public
SiteConfiguration create() {
return new SiteConfiguration(localSite);
}
@Override
public SiteConfigurationBuilder read(SiteConfiguration template, Combine combine) {
this.localSite = template.localSite();
return this;
}
@Override
public String toString() {
return "SiteConfigurationBuilder{" +
"localSite='" + localSite + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof SiteConfigurationBuilder)) return false;
SiteConfigurationBuilder that = (SiteConfigurationBuilder) o;
if (localSite != null ? !localSite.equals(that.localSite) : that.localSite != null) return false;
return true;
}
@Override
public int hashCode() {
int result = localSite != null ? localSite.hashCode() : 0;
return result;
}
}
| 1,997
| 24.615385
| 120
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/PrincipalRoleMapperConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.Attribute;
import org.infinispan.security.PrincipalRoleMapper;
import org.infinispan.security.mappers.ClusterRoleMapper;
import org.infinispan.security.mappers.CommonNameRoleMapper;
import org.infinispan.security.mappers.IdentityRoleMapper;
/**
* @since 10.0
*/
public class PrincipalRoleMapperConfiguration {
public static final AttributeDefinition<Class> CLASS = AttributeDefinition.builder(Attribute.CLASS, null, Class.class).immutable().build();
private final PrincipalRoleMapper principalRoleMapper;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(PrincipalRoleMapperConfiguration.class, CLASS);
}
private final AttributeSet attributes;
PrincipalRoleMapperConfiguration(AttributeSet attributeSet, PrincipalRoleMapper principalRoleMapper) {
this.attributes = attributeSet;
this.principalRoleMapper = principalRoleMapper;
}
public AttributeSet attributes() {
return attributes;
}
public PrincipalRoleMapper roleMapper() {
return principalRoleMapper;
}
static boolean isCustomMapper(PrincipalRoleMapper mapper) {
return !(mapper instanceof IdentityRoleMapper) &&
!(mapper instanceof CommonNameRoleMapper) &&
!(mapper instanceof ClusterRoleMapper);
}
}
| 1,531
| 31.595745
| 142
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/CacheContainerConfiguration.java
|
package org.infinispan.configuration.global;
import static org.infinispan.util.logging.Log.CONFIG;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.util.Features;
import org.infinispan.util.ByteString;
/*
* @since 10.0
*/
class CacheContainerConfiguration {
private static final String ZERO_CAPACITY_NODE_FEATURE = "zero-capacity-node";
static final AttributeDefinition<String> DEFAULT_CACHE = AttributeDefinition.builder("defaultCache", null, String.class).immutable()
.validator(value -> {
if (value != null && !ByteString.isValid(value)) {
throw CONFIG.invalidNameSize(value);
}
}).build();
static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", "DefaultCacheManager").immutable().build();
static final AttributeDefinition<Boolean> STATISTICS = AttributeDefinition.builder("statistics", false).immutable().build();
static final AttributeDefinition<Boolean> ZERO_CAPACITY_NODE = AttributeDefinition.builder("zeroCapacityNode", Boolean.FALSE).immutable().build();
static final AttributeDefinition<String> ASYNC_EXECUTOR = AttributeDefinition.builder("asyncExecutor", "async-pool", String.class).immutable().build();
static final AttributeDefinition<String> LISTENER_EXECUTOR = AttributeDefinition.builder("listenerExecutor", "listener-pool", String.class).immutable().build();
static final AttributeDefinition<String> EXPIRATION_EXECUTOR = AttributeDefinition.builder("expirationExecutor", "expiration-pool", String.class).immutable().build();
static final AttributeDefinition<String> PERSISTENCE_EXECUTOR = AttributeDefinition.builder("persistenceExecutor", "persistence-pool", String.class).immutable().build();
static final AttributeDefinition<String> STATE_TRANSFER_EXECUTOR = AttributeDefinition.builder("stateTransferExecutor", "state-transfer-pool", String.class).immutable().build();
static final AttributeDefinition<String> NON_BLOCKING_EXECUTOR = AttributeDefinition.builder("nonBlockingExecutor", "non-blocking-pool", String.class).immutable().build();
static final AttributeDefinition<String> BLOCKING_EXECUTOR = AttributeDefinition.builder("blockingExecutor", "blocking-pool", String.class).immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(CacheContainerConfiguration.class, NAME, STATISTICS, ZERO_CAPACITY_NODE, DEFAULT_CACHE,
ASYNC_EXECUTOR, LISTENER_EXECUTOR, EXPIRATION_EXECUTOR, PERSISTENCE_EXECUTOR, STATE_TRANSFER_EXECUTOR,
NON_BLOCKING_EXECUTOR, BLOCKING_EXECUTOR);
}
private final Attribute<String> defaultCache;
private final Attribute<String> name;
private final Attribute<Boolean> statistics;
private final Attribute<Boolean> zeroCapacityNode;
private final boolean zeroCapacityAvailable;
private final ThreadsConfiguration threads;
private final GlobalMetricsConfiguration metrics;
private final GlobalJmxConfiguration jmx;
private final TransportConfiguration transport;
private final GlobalSecurityConfiguration security;
private final SerializationConfiguration serialization;
private final GlobalStateConfiguration globalState;
private final ShutdownConfiguration shutdown;
private final AttributeSet attributes;
CacheContainerConfiguration(AttributeSet attributes,
ThreadsConfiguration threadsConfiguration,
GlobalMetricsConfiguration metrics,
GlobalJmxConfiguration jmx,
TransportConfiguration transport,
GlobalSecurityConfiguration security,
SerializationConfiguration serialization,
GlobalStateConfiguration globalState,
ShutdownConfiguration shutdown,
Features features) {
this.attributes = attributes.checkProtection();
this.defaultCache = attributes.attribute(DEFAULT_CACHE);
this.name = attributes.attribute(NAME);
this.statistics = attributes.attribute(STATISTICS);
this.zeroCapacityNode = attributes.attribute(ZERO_CAPACITY_NODE);
this.threads = threadsConfiguration;
this.metrics = metrics;
this.jmx = jmx;
this.globalState = globalState;
this.shutdown = shutdown;
this.security = security;
this.serialization = serialization;
this.transport = transport;
this.zeroCapacityAvailable = features.isAvailable(ZERO_CAPACITY_NODE_FEATURE);
}
public AttributeSet attributes() {
return attributes;
}
public String defaultCacheName() {
return defaultCache.get();
}
public String cacheManagerName() {
return name.get();
}
public boolean statistics() {
return statistics.get();
}
public boolean getZeroCapacityNode() {
return zeroCapacityAvailable && zeroCapacityNode.get();
}
public GlobalMetricsConfiguration metrics() {
return metrics;
}
public GlobalJmxConfiguration jmx() {
return jmx;
}
/**
* @deprecated Since 10.1.3. Use {@link #jmx()} instead. This will be removed in next major version.
*/
@Deprecated
public GlobalJmxConfiguration globalJmxStatistics() {
return jmx();
}
public TransportConfiguration transport() {
return transport;
}
public GlobalSecurityConfiguration security() {
return security;
}
public SerializationConfiguration serialization() {
return serialization;
}
public ShutdownConfiguration shutdown() {
return shutdown;
}
@Deprecated
public String asyncExecutor() {
return attributes.attribute(ASYNC_EXECUTOR).get();
}
public String listenerExecutor() {
return attributes.attribute(LISTENER_EXECUTOR).get();
}
public String expirationExecutor() {
return attributes.attribute(EXPIRATION_EXECUTOR).get();
}
public String persistenceExecutor() {
return attributes.attribute(PERSISTENCE_EXECUTOR).get();
}
/**
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
public String stateTransferExecutor() {
return attributes.attribute(STATE_TRANSFER_EXECUTOR).get();
}
public String nonBlockingExecutor() {
return attributes.attribute(NON_BLOCKING_EXECUTOR).get();
}
public String blockingExecutor() {
return attributes.attribute(BLOCKING_EXECUTOR).get();
}
public GlobalStateConfiguration globalState() {
return globalState;
}
public boolean isClustered() {
return transport().transport() != null;
}
public ThreadsConfiguration threads() {
return threads;
}
public ThreadPoolConfiguration expirationThreadPool() {
return threads.expirationThreadPool();
}
public ThreadPoolConfiguration listenerThreadPool() {
return threads.listenerThreadPool();
}
public ThreadPoolConfiguration persistenceThreadPool() {
return threads.persistenceThreadPool();
}
/**
* @return An empty {@code ThreadPoolConfiguration}.
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
public ThreadPoolConfiguration stateTransferThreadPool() {
return threads.stateTransferThreadPool();
}
@Deprecated
public ThreadPoolConfiguration asyncThreadPool() {
return threads.asyncThreadPool();
}
public ThreadPoolConfiguration nonBlockingThreadPool() {
return threads.nonBlockingThreadPool();
}
public ThreadPoolConfiguration blockingThreadPool() {
return threads.blockingThreadPool();
}
@Override
public String toString() {
return "CacheContainerConfiguration{" +
"zeroCapacityAvailable=" + zeroCapacityAvailable +
", threads=" + threads +
", metrics=" + metrics +
", jmx=" + jmx +
", transport=" + transport +
", security=" + security +
", serialization=" + serialization +
", globalState=" + globalState +
", shutdown=" + shutdown +
", attributes=" + attributes +
'}';
}
}
| 8,397
| 35.513043
| 180
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalRolesConfigurationChildBuilder.java
|
package org.infinispan.configuration.global;
public interface GlobalRolesConfigurationChildBuilder {
GlobalRoleConfigurationBuilder role(String name);
GlobalRoleConfigurationBuilder inheritable(boolean inheritable);
}
| 226
| 27.375
| 67
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/TemporaryGlobalStatePathConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.ParseUtils;
public class TemporaryGlobalStatePathConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<TemporaryGlobalStatePathConfiguration> {
private final AttributeSet attributes;
private String location;
TemporaryGlobalStatePathConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = TemporaryGlobalStatePathConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public TemporaryGlobalStatePathConfigurationBuilder location(String path, String relativeTo) {
attributes.attribute(GlobalStatePathConfiguration.PATH).set(path);
attributes.attribute(GlobalStatePathConfiguration.RELATIVE_TO).set(relativeTo);
this.location = ParseUtils.resolvePath(path, relativeTo);
return this;
}
@Override
public TemporaryGlobalStatePathConfiguration create() {
return new TemporaryGlobalStatePathConfiguration(attributes.protect(), location);
}
@Override
public TemporaryGlobalStatePathConfigurationBuilder read(TemporaryGlobalStatePathConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
location = template.getLocation();
return this;
}
}
| 1,574
| 36.5
| 160
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalStorageConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.globalstate.ConfigurationStorage;
import org.infinispan.globalstate.LocalConfigurationStorage;
/**
* @since 10.0
*/
public class GlobalStorageConfiguration {
static final AttributeDefinition<Supplier<? extends LocalConfigurationStorage>> CONFIGURATION_STORAGE_SUPPLIER = AttributeDefinition
.supplierBuilder("class", LocalConfigurationStorage.class).autoPersist(false)
.immutable().build();
private final ConfigurationStorage storage;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GlobalStorageConfiguration.class, CONFIGURATION_STORAGE_SUPPLIER);
}
private final AttributeSet attributes;
GlobalStorageConfiguration(AttributeSet attributeSet, ConfigurationStorage storage) {
this.attributes = attributeSet;
this.storage = storage;
}
public AttributeSet attributes() {
return attributes;
}
public ConfigurationStorage configurationStorage() {
return storage;
}
Supplier<? extends LocalConfigurationStorage> storageSupplier() {
return attributes.attribute(CONFIGURATION_STORAGE_SUPPLIER).get();
}
}
| 1,383
| 30.454545
| 135
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalJmxStatisticsConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import java.util.Properties;
import org.infinispan.commons.jmx.MBeanServerLookup;
/**
* Configures JMX for the cache manager and its caches.
*
* @deprecated since 10.1.3. Use {@link GlobalJmxConfigurationBuilder} instead. This will be removed in next major version.
*/
@Deprecated
public abstract class GlobalJmxStatisticsConfigurationBuilder extends AbstractGlobalConfigurationBuilder {
GlobalJmxStatisticsConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
}
/**
* Sets properties which are then passed to the MBean Server Lookup implementation specified.
*
* @param properties properties to pass to the MBean Server Lookup
*/
public abstract GlobalJmxStatisticsConfigurationBuilder withProperties(Properties properties);
public abstract GlobalJmxStatisticsConfigurationBuilder addProperty(String key, String value);
/**
* If JMX is enabled then all 'published' JMX objects will appear under this name.
* This is optional, if not specified a default domain name will be set by default.
*
* @param domain
*/
public abstract GlobalJmxStatisticsConfigurationBuilder domain(String domain);
/**
* If JMX is enabled then all 'published' JMX objects will appear under this name.
* This is optional, if not specified a default domain name will be set by default.
*
* @deprecated Since 10.1.3, please use {@link #domain(String)} instead.
*/
@Deprecated
public GlobalJmxStatisticsConfigurationBuilder jmxDomain(String domain) {
return domain(domain);
}
/**
* If JMX statistics are enabled, this property represents the name of this cache manager. It
* offers the possibility for clients to provide a user-defined name to the cache manager
* which later can be used to identify the cache manager within a JMX based management tool
* amongst other cache managers that might be running under the same JVM.
*
* @deprecated Use {@link GlobalConfigurationBuilder#cacheManagerName(String)} instead
*/
@Deprecated
public abstract GlobalJmxStatisticsConfigurationBuilder cacheManagerName(String cacheManagerName);
/**
* Sets the instance of the {@link org.infinispan.commons.jmx.MBeanServerLookup} class to be used to bound JMX MBeans to.
*
* @param mBeanServerLookupInstance An instance of {@link org.infinispan.commons.jmx.MBeanServerLookup}
*/
public abstract GlobalJmxStatisticsConfigurationBuilder mBeanServerLookup(MBeanServerLookup mBeanServerLookupInstance);
/**
* Disables JMX in the cache manager.
*/
public abstract GlobalJmxStatisticsConfigurationBuilder disable();
/**
* Enables JMX in the cache manager.
*/
public abstract GlobalJmxStatisticsConfigurationBuilder enable();
/**
* Enables JMX in the cache manager.
*/
public abstract GlobalJmxStatisticsConfigurationBuilder enabled(boolean enabled);
}
| 2,994
| 36.4375
| 124
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/WhiteListConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.ClassAllowList;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @deprecated since 12.0. Use {@link AllowListConfigurationBuilder} through @{@link SerializationConfigurationBuilder#allowList()}. Will be removed in 14.0.
*/
@Deprecated
public class WhiteListConfigurationBuilder implements Builder<WhiteListConfiguration> {
private final AllowListConfigurationBuilder delegate;
WhiteListConfigurationBuilder(AllowListConfigurationBuilder delegate) {
this.delegate = delegate;
}
@Override
public AttributeSet attributes() {
return delegate.attributes();
}
/**
* Helper method that allows for registration of a class to the {@link ClassAllowList}.
*/
public <T> WhiteListConfigurationBuilder addClass(String clazz) {
delegate.addClass(clazz);
return this;
}
/**
* Helper method that allows for registration of classes to the {@link ClassAllowList}.
*/
public <T> WhiteListConfigurationBuilder addClasses(Class... classes) {
delegate.addClasses(classes);
return this;
}
/**
* Helper method that allows for registration of a regexp to the {@link ClassAllowList}.
*/
public <T> WhiteListConfigurationBuilder addRegexp(String regex) {
delegate.addRegexp(regex);
return this;
}
/**
* Helper method that allows for registration of regexps to the {@link ClassAllowList}.
*/
public <T> WhiteListConfigurationBuilder addRegexps(String... regexps) {
delegate.addRegexps(regexps);
return this;
}
@Override
public void validate() {
// No-op, no validation required
}
@Override
public WhiteListConfiguration create() {
throw new UnsupportedOperationException();
}
@Override
public Builder<?> read(WhiteListConfiguration template, Combine combine) {
delegate.read(template.delegate, combine);
return this;
}
}
| 2,125
| 28.123288
| 157
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/CachedThreadPoolConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.CachedThreadPoolConfiguration.NAME;
import static org.infinispan.configuration.global.CachedThreadPoolConfiguration.THREAD_FACTORY;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.executors.CachedThreadPoolExecutorFactory;
import org.infinispan.factories.threads.DefaultThreadFactory;
/*
* @since 10.0
*/
public class CachedThreadPoolConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<CachedThreadPoolConfiguration>, ThreadPoolBuilderAdapter {
private final AttributeSet attributes;
CachedThreadPoolConfigurationBuilder(GlobalConfigurationBuilder globalConfig, String name) {
super(globalConfig);
attributes = CachedThreadPoolConfiguration.attributeDefinitionSet();
attributes.attribute(NAME).set(name);
}
public AttributeSet attributes() {
return attributes;
}
public CachedThreadPoolConfigurationBuilder name(String name) {
attributes.attribute(NAME).set(name);
return this;
}
public CachedThreadPoolConfigurationBuilder threadFactory(String threadFactory) {
attributes.attribute(THREAD_FACTORY).set(threadFactory);
return this;
}
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public CachedThreadPoolConfiguration create() {
return new CachedThreadPoolConfiguration(attributes.protect());
}
@Override
public CachedThreadPoolConfigurationBuilder read(CachedThreadPoolConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "CachedThreadPoolConfigurationBuilder{" +
"attributes=" + attributes +
'}';
}
@Override
public ThreadPoolConfiguration asThreadPoolConfigurationBuilder() {
ThreadPoolConfigurationBuilder builder = new ThreadPoolConfigurationBuilder(getGlobalConfig());
builder.threadPoolFactory(CachedThreadPoolExecutorFactory.create());
DefaultThreadFactory threadFactory = getGlobalConfig().threads().getThreadFactory(threadFactory()).create().getThreadFactory(false);
builder.threadFactory(threadFactory);
builder.name(name());
return builder.create();
}
public String threadFactory() {
return attributes.attribute(ScheduledThreadPoolConfiguration.THREAD_FACTORY).get();
}
}
| 2,628
| 34.527027
| 170
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/StackConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.Attribute;
import org.infinispan.remoting.transport.jgroups.EmbeddedJGroupsChannelConfigurator;
/*
* @since 10.0
*/
public class StackConfiguration implements NamedStackConfiguration {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, null, String.class).build();
static final AttributeDefinition<String> EXTENDS = AttributeDefinition.builder(Attribute.EXTENDS, null, String.class).build();
private final EmbeddedJGroupsChannelConfigurator configurator;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(StackConfiguration.class, NAME, EXTENDS);
}
private final AttributeSet attributes;
StackConfiguration(AttributeSet attributes, EmbeddedJGroupsChannelConfigurator configurator) {
this.attributes = attributes.checkProtection();
this.configurator = configurator;
}
public AttributeSet attributes() {
return attributes;
}
public String name() {
return attributes.attribute(NAME).get();
}
public String extend() {
return attributes.attribute(EXTENDS).get();
}
public EmbeddedJGroupsChannelConfigurator configurator() {
return configurator;
}
@Override
public String toString() {
return "StackConfiguration{" +
"configurator=" + configurator +
", attributes=" + attributes +
'}';
}
}
| 1,639
| 31.156863
| 129
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/SerializationConfiguration.java
|
package org.infinispan.configuration.global;
import static org.infinispan.commons.configuration.attributes.CollectionAttributeCopier.collectionCopier;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSerializer;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.protostream.SerializationContextInitializer;
public class SerializationConfiguration {
public static final AttributeDefinition<Marshaller> MARSHALLER = AttributeDefinition.builder("marshaller", null, Marshaller.class)
.serializer(AttributeSerializer.INSTANCE_CLASS_NAME)
.immutable().build();
public static final AttributeDefinition<Map<Integer, AdvancedExternalizer<?>>> ADVANCED_EXTERNALIZERS = AttributeDefinition.builder("advancedExternalizer", null, (Class<Map<Integer, AdvancedExternalizer<?>>>) (Class<?>) Map.class)
.copier(collectionCopier())
.initializer(HashMap::new).immutable().build();
public static final AttributeDefinition<List<SerializationContextInitializer>> SERIALIZATION_CONTEXT_INITIALIZERS =
AttributeDefinition.builder("contextInitializers", null, (Class<List<SerializationContextInitializer>>) (Class<?>) List.class)
.immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(SerializationConfiguration.class, MARSHALLER, ADVANCED_EXTERNALIZERS, SERIALIZATION_CONTEXT_INITIALIZERS);
}
private final Attribute<Map<Integer, AdvancedExternalizer<?>>> advancedExternalizers;
private final Attribute<Marshaller> marshaller;
private final Attribute<List<SerializationContextInitializer>> contextInitializers;
private final AttributeSet attributes;
private final AllowListConfiguration allowListConfig;
SerializationConfiguration(AttributeSet attributes, AllowListConfiguration allowListConfig) {
this.attributes = attributes.checkProtection();
this.marshaller = attributes.attribute(MARSHALLER);
this.advancedExternalizers = attributes.attribute(ADVANCED_EXTERNALIZERS);
this.contextInitializers = attributes.attribute(SERIALIZATION_CONTEXT_INITIALIZERS);
this.allowListConfig = allowListConfig;
}
public Marshaller marshaller() {
return marshaller.get();
}
/**
* @deprecated since 10.0, {@link AdvancedExternalizer}'s will be removed in a future release.
*/
@Deprecated
public Map<Integer, AdvancedExternalizer<?>> advancedExternalizers() {
return advancedExternalizers.get();
}
public List<SerializationContextInitializer> contextInitializers() {
return contextInitializers.get();
}
public AttributeSet attributes() {
return attributes;
}
public AllowListConfiguration allowList() {
return allowListConfig;
}
@Deprecated
public WhiteListConfiguration whiteList() {
return new WhiteListConfiguration(allowListConfig);
}
@Override
public String toString() {
return "SerializationConfiguration{" +
"attributes=" + attributes +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
SerializationConfiguration that = (SerializationConfiguration) o;
return Objects.equals(attributes, that.attributes);
}
@Override
public int hashCode() {
return attributes != null ? attributes.hashCode() : 0;
}
}
| 3,826
| 38.05102
| 233
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalStorageConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.GlobalStorageConfiguration.CONFIGURATION_STORAGE_SUPPLIER;
import static org.infinispan.util.logging.Log.CONFIG;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.globalstate.ConfigurationStorage;
import org.infinispan.globalstate.LocalConfigurationStorage;
public class GlobalStorageConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<GlobalStorageConfiguration> {
private final AttributeSet attributes;
private ConfigurationStorage storage = ConfigurationStorage.VOLATILE;
GlobalStorageConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = GlobalStorageConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public GlobalStorageConfigurationBuilder supplier(Supplier<? extends LocalConfigurationStorage> configurationStorageSupplier) {
attributes.attribute(CONFIGURATION_STORAGE_SUPPLIER).set(configurationStorageSupplier);
return this;
}
public GlobalStorageConfigurationBuilder configurationStorage(ConfigurationStorage configurationStorage) {
storage = configurationStorage;
return this;
}
@Override
public void validate() {
if (storage.equals(ConfigurationStorage.CUSTOM) && attributes.attribute(CONFIGURATION_STORAGE_SUPPLIER).isNull()) {
throw CONFIG.customStorageStrategyNotSet();
}
}
@Override
public GlobalStorageConfiguration create() {
return new GlobalStorageConfiguration(attributes.protect(), storage);
}
@Override
public GlobalStorageConfigurationBuilder read(GlobalStorageConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
this.storage = template.configurationStorage();
return this;
}
}
| 2,111
| 36.052632
| 138
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/BoundedThreadPoolConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.CORE_THREADS;
import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.KEEP_ALIVE_TIME;
import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.MAX_THREADS;
import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.NON_BLOCKING;
import static org.infinispan.configuration.global.BoundedThreadPoolConfiguration.QUEUE_LENGTH;
import static org.infinispan.configuration.global.CachedThreadPoolConfiguration.NAME;
import static org.infinispan.configuration.global.CachedThreadPoolConfiguration.THREAD_FACTORY;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.factories.threads.CoreExecutorFactory;
import org.infinispan.factories.threads.DefaultThreadFactory;
/*
* @since 10.0
*/
public class BoundedThreadPoolConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<BoundedThreadPoolConfiguration>, ThreadPoolBuilderAdapter {
private final AttributeSet attributes;
BoundedThreadPoolConfigurationBuilder(GlobalConfigurationBuilder globalConfig, String name) {
super(globalConfig);
attributes = BoundedThreadPoolConfiguration.attributeDefinitionSet();
attributes.attribute(NAME).set(name);
}
public AttributeSet attributes() {
return attributes;
}
public BoundedThreadPoolConfigurationBuilder threadFactory(String threadFactory) {
attributes.attribute(THREAD_FACTORY).set(threadFactory);
return this;
}
public BoundedThreadPoolConfigurationBuilder maxThreads(Integer maxThreads) {
attributes.attribute(MAX_THREADS).set(maxThreads);
return this;
}
public Integer maxThreads() {
return attributes.attribute(MAX_THREADS).get();
}
public BoundedThreadPoolConfigurationBuilder coreThreads(Integer coreThreads) {
attributes.attribute(CORE_THREADS).set(coreThreads);
return this;
}
public Integer coreThreads() {
return attributes.attribute(CORE_THREADS).get();
}
public BoundedThreadPoolConfigurationBuilder keepAliveTime(Long keepAlive) {
attributes.attribute(KEEP_ALIVE_TIME).set(keepAlive);
return this;
}
public Long keepAliveTime() {
return attributes.attribute(KEEP_ALIVE_TIME).get();
}
public BoundedThreadPoolConfigurationBuilder queueLength(Integer queueLength) {
attributes.attribute(QUEUE_LENGTH).set(queueLength);
return this;
}
public Integer queueLength() {
return attributes.attribute(QUEUE_LENGTH).get();
}
public BoundedThreadPoolConfigurationBuilder nonBlocking(Boolean nonBlocking) {
attributes.attribute(NON_BLOCKING).set(nonBlocking);
return this;
}
public Boolean isNonBlocking() {
return attributes.attribute(NON_BLOCKING).get();
}
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public BoundedThreadPoolConfiguration create() {
return new BoundedThreadPoolConfiguration(attributes.protect());
}
@Override
public BoundedThreadPoolConfigurationBuilder read(BoundedThreadPoolConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
public String threadFactory() {
return attributes.attribute(THREAD_FACTORY).get();
}
@Override
public String toString() {
return "BoundedThreadPoolConfigurationBuilder{" +
"attributes=" + attributes +
'}';
}
@Override
public ThreadPoolConfiguration asThreadPoolConfigurationBuilder() {
ThreadPoolConfigurationBuilder builder = new ThreadPoolConfigurationBuilder(getGlobalConfig());
boolean isNonBlocking = isNonBlocking();
builder.threadPoolFactory(CoreExecutorFactory.executorFactory(maxThreads(), coreThreads(), queueLength(),
keepAliveTime(), isNonBlocking));
builder.name(name());
if (threadFactory() != null) {
DefaultThreadFactory threadFactory = getGlobalConfig().threads().getThreadFactory(threadFactory()).create().getThreadFactory(isNonBlocking);
builder.threadFactory(threadFactory);
}
return builder.create();
}
}
| 4,429
| 35.01626
| 172
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import java.lang.reflect.Constructor;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.util.Features;
public class GlobalConfigurationBuilder implements GlobalConfigurationChildBuilder {
private ClassLoader cl;
private final CacheContainerConfigurationBuilder cacheContainerConfiguration;
private final Map<Class<?>, Builder<?>> modules;
private final SiteConfigurationBuilder site;
private Features features;
public GlobalConfigurationBuilder() {
ClassLoader defaultCL = Thread.currentThread().getContextClassLoader();
if (defaultCL == null) defaultCL = GlobalConfigurationBuilder.class.getClassLoader();
this.cl = defaultCL;
this.cacheContainerConfiguration = new CacheContainerConfigurationBuilder(this);
this.site = new SiteConfigurationBuilder(this);
this.modules = new LinkedHashMap<>();
}
public CacheContainerConfigurationBuilder cacheContainer() {
return cacheContainerConfiguration;
}
/**
* Helper method that gets you a default constructed GlobalConfiguration, preconfigured to use the default clustering
* stack.
*
* @return a new global configuration
*/
public GlobalConfigurationBuilder clusteredDefault() {
cacheContainerConfiguration.clusteredDefault();
return this;
}
/**
* Helper method that gets you a default constructed GlobalConfiguration, preconfigured for use in LOCAL mode
*
* @return a new global configuration
*/
public GlobalConfigurationBuilder nonClusteredDefault() {
cacheContainerConfiguration.nonClusteredDefault();
return this;
}
protected ClassLoader getClassLoader() {
return cl;
}
public GlobalConfigurationBuilder classLoader(ClassLoader cl) {
this.cl = cl;
return this;
}
@Override
public TransportConfigurationBuilder transport() {
return cacheContainerConfiguration.transport();
}
public GlobalConfigurationBuilder cacheManagerName(String name) {
cacheContainerConfiguration.name(name);
return this;
}
@Override
public GlobalMetricsConfigurationBuilder metrics() {
return cacheContainerConfiguration.metrics();
}
@Override
public GlobalJmxConfigurationBuilder jmx() {
return cacheContainerConfiguration.jmx();
}
@Override
public SerializationConfigurationBuilder serialization() {
return cacheContainerConfiguration.serialization();
}
@Override
public ThreadPoolConfigurationBuilder expirationThreadPool() {
return cacheContainerConfiguration.expirationThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder listenerThreadPool() {
return cacheContainerConfiguration.listenerThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder persistenceThreadPool() {
return cacheContainerConfiguration.persistenceThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder stateTransferThreadPool() {
return cacheContainerConfiguration.stateTransferThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder asyncThreadPool() {
return cacheContainerConfiguration.asyncThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder blockingThreadPool() {
return cacheContainerConfiguration.blockingThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder nonBlockingThreadPool() {
return cacheContainerConfiguration.nonBlockingThreadPool();
}
public GlobalConfigurationBuilder asyncThreadPoolName(String name) {
cacheContainer().asyncExecutor(name);
return this;
}
public GlobalConfigurationBuilder listenerThreadPoolName(String name) {
cacheContainer().listenerExecutor(name);
return this;
}
public GlobalConfigurationBuilder expirationThreadPoolName(String name) {
cacheContainer().expirationExecutor(name);
return this;
}
public GlobalConfigurationBuilder persistenceThreadPoolName(String name) {
cacheContainer().persistenceExecutor(name);
return this;
}
/**
* @deprecated Since 10.1, no longer used.
*/
@Deprecated
public GlobalConfigurationBuilder stateTransferThreadPoolName(String name) {
cacheContainer().stateTransferExecutor(name);
return this;
}
public GlobalConfigurationBuilder nonBlockingThreadPoolName(String name) {
cacheContainer().nonBlockingExecutor(name);
return this;
}
public GlobalConfigurationBuilder blockingThreadPoolName(String name) {
cacheContainer().blockingExecutor(name);
return this;
}
@Override
public GlobalSecurityConfigurationBuilder security() {
return cacheContainerConfiguration.security();
}
@Override
public ShutdownConfigurationBuilder shutdown() {
return cacheContainerConfiguration.shutdown();
}
@Override
public List<Builder<?>> modules() {
return Collections.unmodifiableList(new ArrayList<>(modules.values()));
}
public <T> T module(Class<T> moduleClass) {
return (T) modules.get(moduleClass);
}
/**
* Set the zero capacity node to true to configure a global capacity factor 0.0f for every distributed cache.
* The node will join the cluster but won't keep data on it.
* However, this flag does not affect replicated caches.
* Replicated caches will continue to keep copies of the data in this node.
* Use only distributed caches to make the best use of this feature.
*
* @param zeroCapacityNode value, true or false
* @return GlobalConfigurationBuilder instance
*/
public GlobalConfigurationBuilder zeroCapacityNode(boolean zeroCapacityNode) {
cacheContainerConfiguration.zeroCapacityNode(zeroCapacityNode);
return this;
}
public GlobalConfigurationBuilder clearModules() {
modules.clear();
return this;
}
@Override
public SiteConfigurationBuilder site() {
return site;
}
public <T extends Builder<?>> T addModule(Class<T> klass) {
try {
Constructor<T> constructor = klass.getDeclaredConstructor(GlobalConfigurationBuilder.class);
T builder = constructor.newInstance(this);
T existing = (T) this.modules.putIfAbsent(klass, builder);
return existing != null ? existing : builder;
} catch (Exception e) {
throw new CacheConfigurationException("Could not instantiate module configuration builder '" + klass.getName() + "'", e);
}
}
@Override
public GlobalStateConfigurationBuilder globalState() {
return cacheContainerConfiguration.globalState();
}
@Override
public GlobalConfigurationBuilder defaultCacheName(String defaultCacheName) {
cacheContainerConfiguration.defaultCache(defaultCacheName);
return this;
}
public Optional<String> defaultCacheName() {
return Optional.ofNullable(cacheContainerConfiguration.defaultCacheName());
}
public void validate() {
features = new Features(cl);
List<RuntimeException> validationExceptions = new ArrayList<>();
Arrays.asList(
cacheContainerConfiguration,
site
).forEach(c -> {
try {
c.validate();
} catch (RuntimeException e) {
validationExceptions.add(e);
}
});
modules.values().forEach(c -> {
try {
c.validate();
} catch (RuntimeException e) {
validationExceptions.add(e);
}
});
CacheConfigurationException.fromMultipleRuntimeExceptions(validationExceptions).ifPresent(e -> {
throw e;
});
}
@Override
public GlobalConfiguration build() {
validate();
List<Object> modulesConfig = new LinkedList<>();
for (Builder<?> module : modules.values())
modulesConfig.add(module.create());
return new GlobalConfiguration(
cacheContainerConfiguration.create(),
modulesConfig,
site.create(),
cl,
features);
}
public Features getFeatures() {
return features;
}
public GlobalConfigurationBuilder read(GlobalConfiguration template) {
this.cl = template.classLoader();
for (Object c : template.modules().values()) {
BuiltBy builtBy = c.getClass().getAnnotation(BuiltBy.class);
Builder<Object> builder = this.addModule(builtBy.value());
builder.read(c, Combine.DEFAULT);
}
cacheContainerConfiguration.read(template.cacheContainer(), Combine.DEFAULT);
site.read(template.sites(), Combine.DEFAULT);
return this;
}
public static GlobalConfigurationBuilder defaultClusteredBuilder() {
GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder();
builder.transport().defaultTransport();
return builder;
}
@Override
public String toString() {
return "GlobalConfigurationBuilder{" +
"cl=" + cl +
", cacheContainerConfiguration=" + cacheContainerConfiguration +
", modules=" + modules +
", site=" + site +
", features=" + features +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GlobalConfigurationBuilder that = (GlobalConfigurationBuilder) o;
return Objects.equals(cl, that.cl) && Objects.equals(cacheContainerConfiguration, that.cacheContainerConfiguration) && Objects.equals(modules, that.modules) && Objects.equals(site, that.site) && Objects.equals(features, that.features);
}
@Override
public int hashCode() {
return Objects.hash(cl, cacheContainerConfiguration, modules, site, features);
}
public ThreadsConfigurationBuilder threads() {
return cacheContainerConfiguration.threads();
}
}
| 10,375
| 30.347432
| 241
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalSecurityConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.Objects;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* GlobalSecurityConfiguration.
*
* @author Tristan Tarrant
* @since 7.0
*/
public class GlobalSecurityConfiguration {
private final GlobalAuthorizationConfiguration authorization;
public static final AttributeDefinition<Integer> CACHE_SIZE = AttributeDefinition.builder("securityCacheSize", 1000).build();
public static final AttributeDefinition<Long> CACHE_TIMEOUT = AttributeDefinition.builder("securityCacheTimeout", TimeUnit.MINUTES.toMillis(5)).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(GlobalSecurityConfiguration.class, CACHE_SIZE, CACHE_TIMEOUT);
}
private final AttributeSet attributes;
public GlobalSecurityConfiguration(GlobalAuthorizationConfiguration authorization, AttributeSet attributes) {
this.authorization = authorization;
this.attributes = attributes;
}
public GlobalAuthorizationConfiguration authorization() {
return authorization;
}
public long securityCacheSize() {
return attributes.attribute(CACHE_SIZE).get();
}
public long securityCacheTimeout() {
return attributes.attribute(CACHE_TIMEOUT).get();
}
public AttributeSet attributes() {
return attributes;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
GlobalSecurityConfiguration that = (GlobalSecurityConfiguration) o;
return Objects.equals(authorization, that.authorization) && Objects.equals(attributes, that.attributes);
}
@Override
public int hashCode() {
return Objects.hash(authorization, attributes);
}
@Override
public String toString() {
return "GlobalSecurityConfiguration{" +
"authorization=" + authorization +
", attributes=" + attributes +
'}';
}
}
| 2,130
| 29.884058
| 155
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/AbstractGlobalConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import java.util.List;
import org.infinispan.commons.configuration.Builder;
abstract class AbstractGlobalConfigurationBuilder implements GlobalConfigurationChildBuilder {
private final GlobalConfigurationBuilder globalConfig;
protected AbstractGlobalConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
this.globalConfig = globalConfig;
}
protected GlobalConfigurationBuilder getGlobalConfig() {
return globalConfig;
}
@Override
public TransportConfigurationBuilder transport() {
return globalConfig.transport();
}
@Override
public GlobalMetricsConfigurationBuilder metrics() {
return globalConfig.metrics();
}
@Override
public GlobalJmxConfigurationBuilder jmx() {
//TODO [anistor] globalConfig.jmx().enabled(true); ????
return globalConfig.jmx();
}
@Override
public GlobalStateConfigurationBuilder globalState() {
globalConfig.globalState().enable();
return globalConfig.globalState();
}
@Override
public SerializationConfigurationBuilder serialization() {
return globalConfig.serialization();
}
@Override
public ThreadPoolConfigurationBuilder listenerThreadPool() {
return globalConfig.listenerThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder asyncThreadPool() {
return globalConfig.asyncThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder expirationThreadPool() {
return globalConfig.expirationThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder persistenceThreadPool() {
return globalConfig.persistenceThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder stateTransferThreadPool() {
return globalConfig.stateTransferThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder blockingThreadPool() {
return globalConfig.blockingThreadPool();
}
@Override
public ThreadPoolConfigurationBuilder nonBlockingThreadPool() {
return globalConfig.nonBlockingThreadPool();
}
@Override
public GlobalSecurityConfigurationBuilder security() {
return globalConfig.security();
}
@Override
public ShutdownConfigurationBuilder shutdown() {
return globalConfig.shutdown();
}
@Override
public SiteConfigurationBuilder site() {
return globalConfig.site();
}
@Override
public List<Builder<?>> modules() {
return globalConfig.modules();
}
@Override
public GlobalConfigurationBuilder defaultCacheName(String defaultCacheName) {
return globalConfig.defaultCacheName(defaultCacheName);
}
@Override
public GlobalConfiguration build() {
return globalConfig.build();
}
}
| 2,791
| 24.153153
| 94
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/AllowListConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.ClassAllowList;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
@BuiltBy(AllowListConfigurationBuilder.class)
public class AllowListConfiguration {
static final AttributeDefinition<Set<String>> CLASSES = AttributeDefinition.builder("classes", new HashSet<>(), (Class<Set<String>>) (Class<?>) Set.class)
.initializer(HashSet::new).immutable().build();
static final AttributeDefinition<List<String>> REGEXPS = AttributeDefinition.builder("regexps", new ArrayList<>(), (Class<List<String>>) (Class<?>) List.class)
.initializer(ArrayList::new).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(AllowListConfiguration.class, CLASSES, REGEXPS);
}
private final AttributeSet attributes;
private final ClassLoader classLoader;
AllowListConfiguration(AttributeSet attributes, ClassLoader classLoader) {
this.attributes = attributes.checkProtection();
this.classLoader = classLoader;
}
public AttributeSet attributes() {
return attributes;
}
public ClassAllowList create() {
return new ClassAllowList(attributes.attribute(CLASSES).get(), attributes.attribute(REGEXPS).get(), classLoader);
}
public Set<String> getClasses() {
return attributes.attribute(CLASSES).get();
}
public List<String> getRegexps() {
return attributes.attribute(REGEXPS).get();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
AllowListConfiguration that = (AllowListConfiguration) o;
return Objects.equals(attributes, that.attributes);
}
@Override
public int hashCode() {
return attributes != null ? attributes.hashCode() : 0;
}
@Override
public String toString() {
return "AllowListConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 2,301
| 31.885714
| 162
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ExecutorFactoryConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.ExecutorFactoryConfiguration.FACTORY;
import static org.infinispan.configuration.global.ExecutorFactoryConfiguration.PROPERTIES;
import java.util.Properties;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.executors.ExecutorFactory;
import org.infinispan.commons.util.TypedProperties;
/**
* Configures executor factory.
*/
public class ExecutorFactoryConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<ExecutorFactoryConfiguration> {
private final AttributeSet attributes;
ExecutorFactoryConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
this.attributes = ExecutorFactoryConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Specify factory class for executor
*
* NOTE: Currently Infinispan will not use the object instance, but instead instantiate a new
* instance of the class. Therefore, do not expect any state to survive, and provide a no-args
* constructor to any instance. This will be resolved in Infinispan 5.2.0
*
* @param factory clazz
* @return this ExecutorFactoryConfig
*/
public ExecutorFactoryConfigurationBuilder factory(ExecutorFactory factory) {
attributes.attribute(FACTORY).set(factory);
return this;
}
/**
* Add key/value property pair to this executor factory configuration
*
* @param key property key
* @param value property value
* @return this ExecutorFactoryConfig
*/
public ExecutorFactoryConfigurationBuilder addProperty(String key, String value) {
attributes.attribute(PROPERTIES).get().put(key, value);
return this;
}
/**
* Set key/value properties to this executor factory configuration
*
* @param props Properties
* @return this ExecutorFactoryConfig
*/
public ExecutorFactoryConfigurationBuilder withProperties(Properties props) {
attributes.attribute(PROPERTIES).set(TypedProperties.toTypedProperties(props));
return this;
}
@Override
public void validate() {
// No-op, no validation required
}
@Override
public
ExecutorFactoryConfiguration create() {
return new ExecutorFactoryConfiguration(attributes);
}
@Override
public
ExecutorFactoryConfigurationBuilder read(ExecutorFactoryConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "ExecutorFactoryConfigurationBuilder [attributes=" + attributes + "]";
}
}
| 2,888
| 30.747253
| 142
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ThreadFactoryConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.ThreadFactoryConfiguration.GROUP;
import static org.infinispan.configuration.global.ThreadFactoryConfiguration.NAME;
import static org.infinispan.configuration.global.ThreadFactoryConfiguration.PRIORITY;
import static org.infinispan.configuration.global.ThreadFactoryConfiguration.THREAD_NAME_PATTERN;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/*
* @since 10.0
*/
public class ThreadFactoryConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<ThreadFactoryConfiguration> {
private final AttributeSet attributes;
private String nodeName;
ThreadFactoryConfigurationBuilder(GlobalConfigurationBuilder globalConfig, String name) {
super(globalConfig);
attributes = ThreadFactoryConfiguration.attributeDefinitionSet();
attributes.attribute(NAME).set(name);
}
public AttributeSet attributes() {
return attributes;
}
public ThreadFactoryConfigurationBuilder groupName(String threadGroupName) {
attributes.attribute(GROUP).set(threadGroupName);
return this;
}
public ThreadFactoryConfigurationBuilder threadNamePattern(String threadNamePattern) {
attributes.attribute(THREAD_NAME_PATTERN).set(threadNamePattern);
return this;
}
public ThreadFactoryConfigurationBuilder priority(Integer priority) {
attributes.attribute(PRIORITY).set(priority);
return this;
}
public ThreadFactoryConfigurationBuilder nodeName(String nodeName) {
this.nodeName = nodeName;
return this;
}
public String name() {
return attributes.attribute(NAME).get();
}
public Integer priority() {
return attributes.attribute(PRIORITY).get();
}
public String groupName() {
return attributes.attribute(GROUP).get();
}
public String threadNamePattern() {
return attributes.attribute(THREAD_NAME_PATTERN).get();
}
public String nodeName() {
return nodeName;
}
@Override
public ThreadFactoryConfiguration create() {
return new ThreadFactoryConfiguration(attributes.protect(), nodeName);
}
@Override
public ThreadFactoryConfigurationBuilder read(ThreadFactoryConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 2,506
| 30.3375
| 138
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/TransportConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.Collections;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.util.TypedProperties;
import org.infinispan.remoting.transport.Transport;
public class TransportConfiguration {
public static final AttributeDefinition<String> CLUSTER_NAME = AttributeDefinition.builder("cluster", "ISPN")
.immutable().build();
public static final AttributeDefinition<String> MACHINE_ID = AttributeDefinition.builder("machine", null, String.class)
.immutable().build();
public static final AttributeDefinition<String> RACK_ID = AttributeDefinition.builder("rack", null, String.class)
.immutable().build();
public static final AttributeDefinition<String> SITE_ID = AttributeDefinition.builder("site", null, String.class)
.immutable().build();
public static final AttributeDefinition<String> NODE_NAME = AttributeDefinition.builder("nodeName", null, String.class)
.immutable().build();
public static final AttributeDefinition<Long> DISTRIBUTED_SYNC_TIMEOUT = AttributeDefinition.builder(
"lockTimeout", TimeUnit.MINUTES.toMillis(4)).build();
public static final AttributeDefinition<Integer> INITIAL_CLUSTER_SIZE = AttributeDefinition.builder("initialClusterSize", -1)
.immutable().build();
public static final AttributeDefinition<Long> INITIAL_CLUSTER_TIMEOUT = AttributeDefinition.builder(
"initialClusterTimeout", TimeUnit.MINUTES.toMillis(1)).build();
public static final AttributeDefinition<String> STACK = AttributeDefinition.builder("stack", null, String.class).build();
public static final AttributeDefinition<String> TRANSPORT_EXECUTOR = AttributeDefinition.builder("executor", "transport-pool", String.class).build();
public static final AttributeDefinition<String> REMOTE_EXECUTOR = AttributeDefinition.builder("remoteCommandExecutor", "remote-command-pool", String.class).build();
@SuppressWarnings("unchecked")
public static final AttributeDefinition<Set<String>> RAFT_MEMBERS = AttributeDefinition.builder(org.infinispan.configuration.parsing.Attribute.RAFT_MEMBERS, null, (Class<Set<String>>) (Class<?>) Set.class)
.initializer(Collections::emptySet)
// unable to use AttributeSerializer.STRING_COLLECTION because it breaks the parser for JSON and YAML
.serializer((writer, name, value) -> writer.writeAttribute(name, String.join(" ", value)))
.immutable()
.build();
static AttributeSet attributeSet() {
return new AttributeSet(TransportConfiguration.class, CLUSTER_NAME, MACHINE_ID, RACK_ID, SITE_ID, NODE_NAME,
DISTRIBUTED_SYNC_TIMEOUT, INITIAL_CLUSTER_SIZE, INITIAL_CLUSTER_TIMEOUT, STACK, TRANSPORT_EXECUTOR, REMOTE_EXECUTOR,
RAFT_MEMBERS);
}
private final Attribute<String> clusterName;
private final Attribute<String> stack;
private final Attribute<String> machineId;
private final Attribute<String> rackId;
private final Attribute<String> siteId;
private final Attribute<String> nodeName;
private final Attribute<Long> distributedSyncTimeout;
private final Attribute<Integer> initialClusterSize;
private final Attribute<Long> initialClusterTimeout;
private final AttributeSet attributes;
private final JGroupsConfiguration jgroupsConfiguration;
private final ThreadPoolConfiguration transportThreadPool;
private final ThreadPoolConfiguration remoteCommandThreadPool;
private final TypedProperties properties;
TransportConfiguration(AttributeSet attributes,
JGroupsConfiguration jgroupsConfiguration,
ThreadPoolConfiguration transportThreadPool,
ThreadPoolConfiguration remoteCommandThreadPool,
TypedProperties properties) {
this.attributes = attributes.checkProtection();
this.jgroupsConfiguration = jgroupsConfiguration;
this.transportThreadPool = transportThreadPool;
this.remoteCommandThreadPool = remoteCommandThreadPool;
this.properties = properties;
clusterName = attributes.attribute(CLUSTER_NAME);
stack = attributes.attribute(STACK);
machineId = attributes.attribute(MACHINE_ID);
rackId = attributes.attribute(RACK_ID);
siteId = attributes.attribute(SITE_ID);
distributedSyncTimeout = attributes.attribute(DISTRIBUTED_SYNC_TIMEOUT);
initialClusterSize = attributes.attribute(INITIAL_CLUSTER_SIZE);
initialClusterTimeout = attributes.attribute(INITIAL_CLUSTER_TIMEOUT);
nodeName = attributes.attribute(NODE_NAME);
}
public String clusterName() {
return clusterName.get();
}
public String stack() {
return stack.get();
}
public String machineId() {
return machineId.get();
}
public String rackId() {
return rackId.get();
}
public String siteId() {
return siteId.get();
}
public long distributedSyncTimeout() {
return distributedSyncTimeout.get();
}
public int initialClusterSize() {
return initialClusterSize.get();
}
public long initialClusterTimeout() {
return initialClusterTimeout.get();
}
public Transport transport() {
return jgroupsConfiguration.transport();
}
public String nodeName() {
return nodeName.get();
}
public TypedProperties properties() {
return properties;
}
public boolean hasTopologyInfo() {
return siteId() != null || rackId() != null || machineId() != null;
}
@Deprecated
public ThreadPoolConfiguration transportThreadPool() {
return transportThreadPool;
}
@Deprecated
public ThreadPoolConfiguration remoteCommandThreadPool() {
return remoteCommandThreadPool;
}
public String transportThreadPoolName() {
return attributes.attribute(TRANSPORT_EXECUTOR).get();
}
public String remoteThreadPoolName() {
return attributes.attribute(REMOTE_EXECUTOR).get();
}
public JGroupsConfiguration jgroups() {
return jgroupsConfiguration;
}
public Set<String> raftMembers() {
return attributes.attribute(RAFT_MEMBERS).get();
}
public AttributeSet attributes() {
return attributes;
}
}
| 6,500
| 39.378882
| 208
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalStateConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.GlobalStateConfiguration.ENABLED;
import static org.infinispan.configuration.global.GlobalStateConfiguration.UNCLEAN_SHUTDOWN_ACTION;
import static org.infinispan.util.logging.Log.CONFIG;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.globalstate.ConfigurationStorage;
import org.infinispan.globalstate.LocalConfigurationStorage;
/**
* GlobalStateConfigurationBuilder. Configures filesystem paths where global state is stored.
*
* @author Tristan Tarrant
* @since 8.1
*/
public class GlobalStateConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<GlobalStateConfiguration> {
private final AttributeSet attributes;
private GlobalStatePathConfigurationBuilder persistentLocation;
private GlobalStatePathConfigurationBuilder sharedPersistentLocation;
private TemporaryGlobalStatePathConfigurationBuilder temporaryLocation;
private GlobalStorageConfigurationBuilder storageConfiguration;
GlobalStateConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = GlobalStateConfiguration.attributeDefinitionSet();
this.persistentLocation = new GlobalStatePathConfigurationBuilder(globalConfig, Element.PERSISTENT_LOCATION.getLocalName());
this.sharedPersistentLocation = new GlobalStatePathConfigurationBuilder(globalConfig, Element.SHARED_PERSISTENT_LOCATION.getLocalName());
this.temporaryLocation = new TemporaryGlobalStatePathConfigurationBuilder(globalConfig);
this.storageConfiguration = new GlobalStorageConfigurationBuilder(globalConfig);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public GlobalStateConfigurationBuilder enable() {
return enabled(true);
}
public GlobalStateConfigurationBuilder disable() {
return enabled(false);
}
/**
* Enables or disables the storage of global state.
*/
public GlobalStateConfigurationBuilder enabled(boolean enabled) {
attributes.attribute(ENABLED).set(enabled);
return this;
}
public boolean enabled() {
return attributes.attribute(ENABLED).get();
}
/**
* Defines the action taken when a dangling lock file is found in the persistent global state, signifying an
* unclean shutdown of the node (usually because of a crash or an external termination).
*/
public GlobalStateConfigurationBuilder uncleanShutdownAction(UncleanShutdownAction action) {
attributes.attribute(UNCLEAN_SHUTDOWN_ACTION).set(action);
return this;
}
/**
* Defines the filesystem path where node-specific persistent data which needs to survive container restarts
* should be stored. This path will be used as the default storage location for file-based cache stores such as
* the default {@link org.infinispan.persistence.file.SingleFileStore} as well as the consistent hash for all caches
* which enables graceful shutdown and restart. Because the data stored in the persistent
* location is specific to the node that owns it, this path <b>MUST NOT</b> be shared among multiple instances.
* Defaults to the user.dir system property which usually is where the application was started.
* This value should be overridden to a more appropriate location.
*/
public GlobalStateConfigurationBuilder persistentLocation(String location) {
persistentLocation.location(location, null);
return this;
}
public GlobalStateConfigurationBuilder persistentLocation(String path, String relativeTo) {
persistentLocation.location(path, relativeTo);
return this;
}
/**
* Defines the filesystem path where shared persistent state data which needs to survive container restarts
* should be stored. In particular this path will contain persistent dynamic configuration, as that managed by the
* {@link org.infinispan.globalstate.impl.OverlayLocalConfigurationStorage}.
* This path <b>MAY</b> be safely shared among multiple instances.
* If not set, this will use the {@link #persistentLocation} value.
* This value should be overridden to a more appropriate location.
*/
public GlobalStateConfigurationBuilder sharedPersistentLocation(String location) {
sharedPersistentLocation.location(location, null);
return this;
}
public GlobalStateConfigurationBuilder sharedPersistentLocation(String path, String relativeTo) {
sharedPersistentLocation.location(path, relativeTo);
return this;
}
/**
* Defines the filesystem path where temporary state should be stored. Defaults to the value of the
* java.io.tmpdir system property.
*/
public GlobalStateConfigurationBuilder temporaryLocation(String location) {
temporaryLocation.location(location, null);
return this;
}
public GlobalStateConfigurationBuilder temporaryLocation(String path, String relativeTo) {
temporaryLocation.location(path, relativeTo);
return this;
}
/**
* Defines the {@link ConfigurationStorage} strategy to use. If using {@link ConfigurationStorage#CUSTOM}, then
* the actual implementation must be passed by invoking {@link #configurationStorageSupplier(Supplier)}
*/
public GlobalStateConfigurationBuilder configurationStorage(ConfigurationStorage storage) {
storageConfiguration.configurationStorage(storage);
return this;
}
/**
* Defines the @{@link LocalConfigurationStorage}. Defaults to @{@link org.infinispan.globalstate.impl.VolatileLocalConfigurationStorage}
*/
public GlobalStateConfigurationBuilder configurationStorageSupplier(Supplier<? extends LocalConfigurationStorage> configurationStorageSupplier) {
storageConfiguration.supplier(configurationStorageSupplier);
return this;
}
@Override
public void validate() {
if (attributes.attribute(ENABLED).get() && persistentLocation.getLocation() == null) {
CONFIG.missingGlobalStatePersistentLocation();
}
storageConfiguration.validate();
}
@Override
public GlobalStateConfiguration create() {
return new GlobalStateConfiguration(attributes.protect(), persistentLocation.create(), sharedPersistentLocation.create(), temporaryLocation.create(), storageConfiguration.create());
}
@Override
public Builder<?> read(GlobalStateConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
persistentLocation.read(template.persistenceConfiguration(), combine);
sharedPersistentLocation.read(template.sharedPersistenceConfiguration(), combine);
temporaryLocation.read(template.temporaryLocationConfiguration(), combine);
storageConfiguration.read(template.globalStorageConfiguration(), combine);
return this;
}
}
| 7,117
| 42.402439
| 187
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/NamedStackConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.remoting.transport.jgroups.JGroupsChannelConfigurator;
/**
* @since 14.0
**/
public interface NamedStackConfiguration {
String name();
JGroupsChannelConfigurator configurator();
}
| 257
| 20.5
| 76
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ExecutorFactoryConfiguration.java
|
package org.infinispan.configuration.global;
import org.infinispan.commons.configuration.AbstractTypedPropertiesConfiguration;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.executors.ExecutorFactory;
import org.infinispan.executors.DefaultExecutorFactory;
public class ExecutorFactoryConfiguration extends AbstractTypedPropertiesConfiguration {
static final AttributeDefinition<ExecutorFactory> FACTORY = AttributeDefinition.builder("factory", (ExecutorFactory)new DefaultExecutorFactory()).immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ExecutorFactoryConfiguration.class, AbstractTypedPropertiesConfiguration.attributeSet(), FACTORY);
}
private final Attribute<ExecutorFactory> factory;
ExecutorFactoryConfiguration(AttributeSet attributes) {
super(attributes);
factory = attributes.attribute(FACTORY);
}
public ExecutorFactory factory() {
return factory.get();
}
public AttributeSet attributes() {
return attributes;
}
@Override
public String toString() {
return "ExecutorFactoryConfiguration [attributes=" + attributes + "]";
}
}
| 1,366
| 34.051282
| 169
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/WhiteListConfiguration.java
|
package org.infinispan.configuration.global;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.ClassAllowList;
import org.infinispan.commons.configuration.attributes.AttributeSet;
@Deprecated
@BuiltBy(WhiteListConfigurationBuilder.class)
public class WhiteListConfiguration {
AllowListConfiguration delegate;
WhiteListConfiguration(AllowListConfiguration delegate) {
this.delegate = delegate;
}
public AttributeSet attributes() {
return delegate.attributes();
}
public ClassAllowList create() {
return delegate.create();
}
public Set<String> getClasses() {
return delegate.getClasses();
}
public List<String> getRegexps() {
return delegate.getRegexps();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
WhiteListConfiguration that = (WhiteListConfiguration) o;
return Objects.equals(delegate.attributes(), that.delegate.attributes());
}
@Override
public int hashCode() {
return delegate.hashCode();
}
@Override
public String toString() {
return delegate.toString();
}
}
| 1,312
| 22.035088
| 79
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/GlobalMetricsConfigurationBuilder.java
|
package org.infinispan.configuration.global;
import static org.infinispan.configuration.global.GlobalMetricsConfiguration.ACCURATE_SIZE;
import static org.infinispan.configuration.global.GlobalMetricsConfiguration.GAUGES;
import static org.infinispan.configuration.global.GlobalMetricsConfiguration.HISTOGRAMS;
import static org.infinispan.configuration.global.GlobalMetricsConfiguration.NAMES_AS_TAGS;
import static org.infinispan.configuration.global.GlobalMetricsConfiguration.PREFIX;
import org.infinispan.Cache;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* Configures the types of metrics gathered and exported via Micrometer metrics for all caches owned by this Cache Manager.
* Gauges do not have any performance penalty so are enabled by default.
* Histograms are more expensive to compute so must be enabled manually.
* Enabling metrics in configuration has no effect unless the necessary
* Micrometer JAR is available on the classpath.
*/
public class GlobalMetricsConfigurationBuilder extends AbstractGlobalConfigurationBuilder implements Builder<GlobalMetricsConfiguration> {
private final AttributeSet attributes;
GlobalMetricsConfigurationBuilder(GlobalConfigurationBuilder globalConfig) {
super(globalConfig);
attributes = GlobalMetricsConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
/**
* Metrics are enabled if at least one of the metric types is enabled. See {@link #gauges()}, {@link #histograms()}.
*/
public boolean enabled() {
return gauges() || histograms();
}
/**
* Are gauges enabled?
*/
public boolean gauges() {
return attributes.attribute(GAUGES).get();
}
/**
* Enables or disables gauges.
*/
public GlobalMetricsConfigurationBuilder gauges(boolean gauges) {
attributes.attribute(GAUGES).set(gauges);
return this;
}
/**
* Are histograms enabled?
*/
public boolean histograms() {
return attributes.attribute(HISTOGRAMS).get();
}
/**
* Enables or disables histograms.
*/
public GlobalMetricsConfigurationBuilder histograms(boolean histograms) {
attributes.attribute(HISTOGRAMS).set(histograms);
return this;
}
/**
* The global prefix to add to all metric names.
*/
public String prefix() {
return attributes.attribute(PREFIX).get();
}
/**
* The global prefix to add to all metric names.
*/
public GlobalMetricsConfigurationBuilder prefix(String prefix) {
attributes.attribute(PREFIX).set(prefix);
return this;
}
/**
* Put the cache manager and cache name in tags rather then include them in the metric name.
*/
public boolean namesAsTags() {
return attributes.attribute(NAMES_AS_TAGS).get();
}
/**
* Put the cache manager and cache name in tags rather then include them in the metric name.
*/
public GlobalMetricsConfigurationBuilder namesAsTags(boolean namesAsTags) {
attributes.attribute(NAMES_AS_TAGS).set(namesAsTags);
return this;
}
/**
* Enables accurate size computation for numberOfEntries statistics. Note that this doesn't affect invocations of
* the {@link Cache#size()} method.
*/
public GlobalMetricsConfigurationBuilder accurateSize(boolean accurateSize) {
attributes.attribute(ACCURATE_SIZE).set(accurateSize);
return this;
}
@Override
public GlobalMetricsConfiguration create() {
return new GlobalMetricsConfiguration(attributes.protect());
}
@Override
public GlobalMetricsConfigurationBuilder read(GlobalMetricsConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "GlobalMetricsConfigurationBuilder [attributes=" + attributes + "]";
}
}
| 4,050
| 30.897638
| 138
|
java
|
null |
infinispan-main/core/src/main/java/org/infinispan/configuration/global/ShutdownHookBehavior.java
|
package org.infinispan.configuration.global;
/**
* Behavior of the JVM shutdown hook registered by the cache
*/
public enum ShutdownHookBehavior {
/**
* By default a shutdown hook is registered if no MBean server (apart from the JDK default) is detected.
*/
DEFAULT,
/**
* Forces the cache to register a shutdown hook even if an MBean server is detected.
*/
REGISTER,
/**
* Forces the cache NOT to register a shutdown hook, even if no MBean server is detected.
*/
DONT_REGISTER
}
| 525
| 25.3
| 107
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.