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/persistence/remote/src/test/java/org/infinispan/persistence/remote/configuration/XmlFileParsingTest.java
|
package org.infinispan.persistence.remote.configuration;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
@Test(groups = "unit", testName = "persistence.remote.configuration.XmlFileParsingTest")
public class XmlFileParsingTest extends AbstractInfinispanTest {
private EmbeddedCacheManager cacheManager;
@AfterMethod
public void cleanup() {
TestingUtil.killCacheManagers(cacheManager);
}
public void testRemoteCacheStore() throws Exception {
String config = TestingUtil.wrapXMLWithSchema(
"<cache-container default-cache=\"default\">" +
" <local-cache name=\"default\">\n" +
" <persistence>\n" +
" <remote-store xmlns=\"urn:infinispan:config:store:remote:"+ Version.getSchemaVersion() + "\" >\n" +
" <remote-server host=\"one\" />\n" +
" <remote-server host=\"two\" />\n" +
" <connection-pool max-active=\"10\" exhausted-action=\"CREATE_NEW\" />\n" +
" <async-executor>\n" +
" <property name=\"maxThreads\">4</property>" +
" </async-executor>\n" +
" <write-behind/>\n" +
" </remote-store>\n" +
" </persistence>\n" +
" </local-cache>\n" +
"</cache-container>"
);
RemoteStoreConfiguration store = (RemoteStoreConfiguration) buildCacheManagerWithCacheStore(config);
assertEquals(2, store.servers().size());
assertEquals(ExhaustedAction.CREATE_NEW, store.connectionPool().exhaustedAction());
assertEquals(4, store.asyncExecutorFactory().properties().getIntProperty("maxThreads", 0));
assertTrue(store.async().enabled());
}
private StoreConfiguration buildCacheManagerWithCacheStore(final String config) {
InputStream is = new ByteArrayInputStream(config.getBytes());
cacheManager = TestCacheManagerFactory.fromStream(is, true, false);
assert cacheManager.getDefaultCacheConfiguration().persistence().stores().size() == 1;
return cacheManager.getDefaultCacheConfiguration().persistence().stores().get(0);
}
}
| 2,672
| 42.819672
| 119
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeDynamicWithStoreTest.java
|
package org.infinispan.persistence.remote.upgrade;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.dummy.DummyInMemoryStoreConfigurationBuilder;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationBuilder;
import org.infinispan.util.concurrent.IsolationLevel;
import org.testng.annotations.Test;
/**
* Same as {@link HotRodUpgradeWithStoreTest} but using remote store created dynamically.
*
* @since 13.0
*/
@Test(testName = "upgrade.hotrod.HotRodUpgradeDynamicWithStoreTest", groups = "functional")
public class HotRodUpgradeDynamicWithStoreTest extends HotRodUpgradeWithStoreTest {
protected TestCluster configureTargetCluster() {
ConfigurationBuilder targetStoreBuilder = new ConfigurationBuilder();
targetStoreBuilder.clustering().cacheMode(CacheMode.DIST_SYNC)
.locking().isolationLevel(IsolationLevel.REPEATABLE_READ)
.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class).shared(true).storeName("targetStore");
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(CACHE_NAME).configuredWith(targetStoreBuilder)
.build();
}
protected void connectTargetCluster() {
ConfigurationBuilder builder = new ConfigurationBuilder();
RemoteStoreConfigurationBuilder storeBuilder = builder.persistence().addStore(RemoteStoreConfigurationBuilder.class);
storeBuilder.rawValues(true).shared(true).segmented(false).remoteCacheName(CACHE_NAME).addServer()
.host("localhost").port(sourceCluster.getHotRodPort());
targetCluster.connectSource(CACHE_NAME, builder.build().persistence().stores().get(0));
}
}
| 1,801
| 44.05
| 123
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/SerializationCtx.java
|
package org.infinispan.persistence.remote.upgrade;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
@AutoProtoSchemaBuilder(
includeClasses = {CustomObject.class},
schemaFileName = "rolling.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.persistence.remote.upgrade")
public interface SerializationCtx extends SerializationContextInitializer {
SerializationCtx INSTANCE = new SerializationCtxImpl();
}
| 550
| 38.357143
| 75
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/TestCluster.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.client.hotrod.ProtocolVersion.DEFAULT_PROTOCOL_VERSION;
import static org.infinispan.client.hotrod.ProtocolVersion.PROTOCOL_VERSION_23;
import static org.infinispan.test.AbstractCacheTest.getDefaultClusteredCacheConfig;
import static org.infinispan.test.TestingUtil.waitForNoRebalanceAcrossManagers;
import static org.infinispan.test.fwk.TestCacheManagerFactory.createClusteredCacheManager;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.infinispan.Cache;
import org.infinispan.client.hotrod.DataFormat;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.TransactionMode;
import org.infinispan.client.hotrod.test.HotRodClientTestingUtil;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.marshall.JavaSerializationMarshaller;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.marshall.ProtoStreamMarshaller;
import org.infinispan.commons.marshall.UTF8StringMarshaller;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.internal.PrivateGlobalConfigurationBuilder;
import org.infinispan.jboss.marshalling.commons.GenericJBossMarshaller;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationBuilder;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.ServerAddress;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.test.TestingUtil;
import org.infinispan.transaction.tm.EmbeddedTransactionManager;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.testng.Assert;
class TestCluster {
private List<HotRodServer> hotRodServers;
private List<EmbeddedCacheManager> embeddedCacheManagers;
private RemoteCacheManager remoteCacheManager;
private EmbeddedTransactionManager transactionManager = EmbeddedTransactionManager.getInstance();
private TestCluster(List<HotRodServer> hotRodServers, List<EmbeddedCacheManager> embeddedCacheManagers,
RemoteCacheManager remoteCacheManager) {
this.hotRodServers = hotRodServers;
this.embeddedCacheManagers = embeddedCacheManagers;
this.remoteCacheManager = remoteCacheManager;
}
<K, V> RemoteCache<K, V> getRemoteCache(String cacheName) {
return remoteCacheManager.getCache(cacheName);
}
<K, V> RemoteCache<K, V> getRemoteCache(String cacheName, MediaType mediaType) {
if (mediaType == null) return getRemoteCache(cacheName);
Marshaller marshaller;
switch (mediaType.toString()) {
case MediaType.TEXT_PLAIN_TYPE:
marshaller = new UTF8StringMarshaller();
break;
case MediaType.APPLICATION_SERIALIZED_OBJECT_TYPE:
marshaller = new JavaSerializationMarshaller();
break;
default:
marshaller = new ProtoStreamMarshaller();
}
DataFormat dataFormat = DataFormat.builder().keyMarshaller(marshaller).valueMarshaller(marshaller).build();
return remoteCacheManager.getCache(cacheName).withDataFormat(dataFormat);
}
<K, V> RemoteCache<K, V> getRemoteCache(String cacheName, boolean transactional) {
if (!transactional) {
return getRemoteCache(cacheName);
} else {
return remoteCacheManager.getCache(cacheName, TransactionMode.NON_XA, transactionManager);
}
}
void destroy() {
embeddedCacheManagers.forEach(TestingUtil::killCacheManagers);
embeddedCacheManagers.clear();
hotRodServers.forEach(HotRodClientTestingUtil::killServers);
hotRodServers.clear();
HotRodClientTestingUtil.killRemoteCacheManagers(remoteCacheManager);
remoteCacheManager = null;
EmbeddedTransactionManager.destroy();
}
<K, V> Cache<K, V> getEmbeddedCache(String name) {
return embeddedCacheManagers.get(0).getCache(name);
}
List<Cache<String, String>> getEmbeddedCaches(String name) {
return embeddedCacheManagers.stream().map(cm -> cm.<String, String>getCache(name)).collect(Collectors.toList());
}
RollingUpgradeManager getRollingUpgradeManager(String cacheName) {
return embeddedCacheManagers.get(0).getCache(cacheName).getAdvancedCache().getComponentRegistry()
.getComponent(RollingUpgradeManager.class);
}
int getHotRodPort() {
return hotRodServers.get(0).getPort();
}
void cleanAllCaches() {
embeddedCacheManagers.stream().flatMap(m -> m.getCacheNames().stream().map(m::getCache)).forEach(Cache::clear);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
String members = embeddedCacheManagers.stream().map(EmbeddedCacheManager::getMembers).map(Object::toString).collect(Collectors.joining(","));
sb.append("Cluster members: ").append(members);
String addresses = hotRodServers.stream().map(HotRodServer::getAddress).map(ServerAddress::toString).collect(Collectors.joining(","));
sb.append("Servers: ").append(addresses);
sb.append(addresses);
return sb.toString();
}
public void connectSource(String cacheName, StoreConfiguration configuration) {
EmbeddedCacheManager cacheManager = embeddedCacheManagers.iterator().next();
RollingUpgradeManager rum = cacheManager.getCache(cacheName).getAdvancedCache().getComponentRegistry().getComponent(RollingUpgradeManager.class);
try {
rum.connectSource("hotrod", configuration);
} catch (Exception e) {
Assert.fail("Failed to connect target!", e);
}
}
public void disconnectSource(String cacheName) {
embeddedCacheManagers.forEach(c -> {
RollingUpgradeManager rum = c.getCache(cacheName).getAdvancedCache().getComponentRegistry().getComponent(RollingUpgradeManager.class);
try {
rum.disconnectSource("hotrod");
} catch (Exception e) {
Assert.fail("Failed to disconnect source!");
}
});
}
static class Builder {
private String name = "cluster1";
private int numMembers = 1;
private Map<String, ConfigurationBuilder> caches = new HashMap<>();
private HotRodServerConfigurationBuilder hotRodBuilder = new HotRodServerConfigurationBuilder();
private String trustStoreFileName;
private char[] trustStorePassword;
private char[] keyStorePassword;
private String keyStoreFileName;
private boolean segmented;
private SerializationCtx ctx;
private Class<? extends Marshaller> marshaller;
Builder setNumMembers(int numMembers) {
this.numMembers = numMembers;
return this;
}
public Builder marshaller(Class<? extends Marshaller> marshaller) {
this.marshaller = marshaller;
return this;
}
public Builder ctx(SerializationCtx ctx) {
this.ctx = ctx;
return this;
}
public Builder setName(String name) {
this.name = name;
return this;
}
CacheDefinitionBuilder cache() {
return new CacheDefinitionBuilder(this);
}
static class CacheDefinitionBuilder {
private final Builder builder;
private ConfigurationBuilder configurationBuilder;
private String name;
private ProtocolVersion protocolVersion = DEFAULT_PROTOCOL_VERSION;
private Integer remotePort;
private boolean wrapping = true;
private boolean rawValues = true;
private Class<? extends Marshaller> marshaller;
CacheDefinitionBuilder(Builder builder) {
this.builder = builder;
}
public CacheDefinitionBuilder name(String name) {
this.name = name;
return this;
}
CacheDefinitionBuilder remotePort(Integer remotePort) {
this.remotePort = remotePort;
return this;
}
CacheDefinitionBuilder remoteStoreWrapping(boolean wrapping) {
this.wrapping = wrapping;
return this;
}
CacheDefinitionBuilder remoteStoreRawValues(boolean rawValues) {
this.rawValues = rawValues;
return this;
}
CacheDefinitionBuilder remoteStoreMarshaller(Class<? extends Marshaller> marshaller) {
this.marshaller = marshaller;
return this;
}
CacheDefinitionBuilder remoteProtocolVersion(ProtocolVersion version) {
this.protocolVersion = version;
return this;
}
CacheDefinitionBuilder configuredWith(ConfigurationBuilder configurationBuilder) {
this.configurationBuilder = configurationBuilder;
return this;
}
CacheDefinitionBuilder cache() {
return addNewCache();
}
TestCluster build() {
addNewCache();
return builder.build();
}
private CacheDefinitionBuilder addNewCache() {
if (configurationBuilder == null)
configurationBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC);
if (remotePort != null) {
RemoteStoreConfigurationBuilder store = configurationBuilder.persistence().addStore(RemoteStoreConfigurationBuilder.class);
store.hotRodWrapping(wrapping).rawValues(rawValues)
.remoteCacheName(name).protocolVersion(protocolVersion).shared(true)
.addServer().host("localhost").port(remotePort);
if (builder.trustStoreFileName != null) {
store.remoteSecurity().ssl().enable().trustStoreFileName(builder.trustStoreFileName).trustStorePassword(builder.trustStorePassword);
}
if (builder.keyStoreFileName != null) {
store.remoteSecurity().ssl().keyStoreFileName(builder.keyStoreFileName).keyStorePassword(builder.keyStorePassword);
}
if (builder.segmented) {
if (protocolVersion.compareTo(PROTOCOL_VERSION_23) < 0) {
throw new AssertionError("Protocol version less than 2.3 cannot be segmented");
}
store.segmented(true);
} else {
store.segmented(false);
}
if (marshaller != null) {
store.marshaller(marshaller);
}
}
builder.addCache(name, configurationBuilder);
return new CacheDefinitionBuilder(builder);
}
}
Builder withHotRodBuilder(HotRodServerConfigurationBuilder hotRodBuilder) {
this.hotRodBuilder = hotRodBuilder;
return this;
}
Builder withSSLTrustStore(String trustStoreFileName, char[] trustStorePassword) {
this.trustStoreFileName = trustStoreFileName;
this.trustStorePassword = trustStorePassword;
return this;
}
Builder withSSLKeyStore(String keyStoreFileName, char[] keyStorePassword) {
this.keyStoreFileName = keyStoreFileName;
this.keyStorePassword = keyStorePassword;
return this;
}
Builder segmented(boolean segmented) {
this.segmented = segmented;
return this;
}
private void addCache(String name, ConfigurationBuilder cfg) {
caches.put(name, cfg);
}
public TestCluster build() {
List<HotRodServer> hotRodServers = new ArrayList<>();
List<EmbeddedCacheManager> embeddedCacheManagers = new ArrayList<>();
for (int i = 0; i < numMembers; i++) {
GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder();
gcb.serialization().allowList().addClasses(CustomObject.class);
if (ctx != null) {
gcb.serialization().addContextInitializer(ctx);
}
gcb.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true);
gcb.transport().defaultTransport().clusterName(name);
EmbeddedCacheManager clusteredCacheManager =
createClusteredCacheManager(gcb, getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC));
caches.forEach((key, value) -> clusteredCacheManager.defineConfiguration(key, value.build()));
embeddedCacheManagers.add(clusteredCacheManager);
hotRodServers.add(HotRodClientTestingUtil.startHotRodServer(clusteredCacheManager, hotRodBuilder));
}
embeddedCacheManagers.forEach(cm -> caches.keySet().forEach(cm::getCache));
waitForNoRebalanceAcrossManagers(embeddedCacheManagers.toArray(new EmbeddedCacheManager[0]));
int port = hotRodServers.get(0).getPort();
org.infinispan.client.hotrod.configuration.ConfigurationBuilder clientBuilder = new org.infinispan.client.hotrod.configuration.ConfigurationBuilder();
clientBuilder.addServer().port(port).host("localhost");
if (ctx != null) {
clientBuilder.addContextInitializer(ctx);
}
if (trustStoreFileName != null) {
clientBuilder.security().ssl().enable().trustStoreFileName(trustStoreFileName).trustStorePassword(trustStorePassword);
}
if (keyStoreFileName != null) {
clientBuilder.security().ssl().keyStoreFileName(keyStoreFileName).keyStorePassword(keyStorePassword);
}
if (marshaller != null) {
clientBuilder.marshaller(marshaller);
} else {
clientBuilder.marshaller(GenericJBossMarshaller.class);
}
clientBuilder.addJavaSerialAllowList(".*");
return new TestCluster(hotRodServers, embeddedCacheManagers, new RemoteCacheManager(clientBuilder.build()));
}
}
}
| 14,329
| 39.942857
| 159
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeDynamicWithSSLTest.java
|
package org.infinispan.persistence.remote.upgrade;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.commons.test.security.TestCertificates;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationBuilder;
import org.testng.annotations.Test;
/**
* Same as {@link HotRodUpgradeWithSSLTest} but using remote store created dynamically.
*/
@Test(testName = "upgrade.hotrod.HotRodUpgradeDynamicWithSSLTest", groups = "functional")
public class HotRodUpgradeDynamicWithSSLTest extends HotRodUpgradeWithSSLTest {
@Override
protected TestCluster configureTargetCluster() {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.withSSLKeyStore(TestCertificates.certificate("client"), TestCertificates.KEY_PASSWORD)
.withSSLTrustStore(TestCertificates.certificate("ca"), TestCertificates.KEY_PASSWORD)
.withHotRodBuilder(getHotRodServerBuilder())
.cache().name(OLD_CACHE)
.cache().name(TEST_CACHE)
.build();
}
@Override
protected void connectTargetCluster() {
ConfigurationBuilder remoteStoreOldCache = createStoreBuilder(OLD_CACHE, OLD_PROTOCOL_VERSION);
ConfigurationBuilder remoteStoreNewCache = createStoreBuilder(TEST_CACHE, NEW_PROTOCOL_VERSION);
targetCluster.connectSource(OLD_CACHE, remoteStoreOldCache.build().persistence().stores().get(0));
targetCluster.connectSource(TEST_CACHE, remoteStoreNewCache.build().persistence().stores().get(0));
}
private ConfigurationBuilder createStoreBuilder(String cacheName, ProtocolVersion version) {
ConfigurationBuilder builder = new ConfigurationBuilder();
RemoteStoreConfigurationBuilder storeBuilder = builder.persistence().addStore(RemoteStoreConfigurationBuilder.class);
storeBuilder.remoteCacheName(cacheName).rawValues(true).protocolVersion(version).shared(true).segmented(false)
.remoteSecurity().ssl().enable().trustStoreFileName(TestCertificates.certificate("ca")).trustStorePassword(TestCertificates.KEY_PASSWORD)
.keyStoreFileName(TestCertificates.certificate("client")).keyStorePassword(TestCertificates.KEY_PASSWORD)
.addServer().host("localhost").port(sourceCluster.getHotRodPort());
return builder;
}
}
| 2,386
| 50.891304
| 149
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeWithSSLTest.java
|
package org.infinispan.persistence.remote.upgrade;
import org.infinispan.commons.test.security.TestCertificates;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
@Test(testName = "upgrade.hotrod.HotRodUpgradeWithSSLTest", groups = "functional")
public class HotRodUpgradeWithSSLTest extends HotRodUpgradeSynchronizerTest {
@BeforeMethod
public void setup() throws Exception {
HotRodServerConfigurationBuilder sourceHotRodBuilder = new HotRodServerConfigurationBuilder();
sourceHotRodBuilder
.ssl()
.enable()
.requireClientAuth(true)
.keyStoreFileName(TestCertificates.certificate("server"))
.keyStorePassword(TestCertificates.KEY_PASSWORD)
.keyAlias("server")
.trustStoreFileName(TestCertificates.certificate("ca"))
.trustStorePassword(TestCertificates.KEY_PASSWORD);
sourceCluster = new TestCluster.Builder().setName("sourceCluster").setNumMembers(2)
.withSSLKeyStore(TestCertificates.certificate("client"), TestCertificates.KEY_PASSWORD)
.withSSLTrustStore(TestCertificates.certificate("ca"), TestCertificates.KEY_PASSWORD)
.withHotRodBuilder(sourceHotRodBuilder)
.cache().name(OLD_CACHE)
.cache().name(TEST_CACHE)
.build();
targetCluster = configureTargetCluster();
}
@Override
protected TestCluster configureTargetCluster() {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.withSSLKeyStore(TestCertificates.certificate("client"), TestCertificates.KEY_PASSWORD)
.withSSLTrustStore(TestCertificates.certificate("ca"), TestCertificates.KEY_PASSWORD)
.withHotRodBuilder(getHotRodServerBuilder())
.cache().name(OLD_CACHE).remotePort(sourceCluster.getHotRodPort()).remoteProtocolVersion(OLD_PROTOCOL_VERSION)
.cache().name(TEST_CACHE).remotePort(sourceCluster.getHotRodPort()).remoteProtocolVersion(NEW_PROTOCOL_VERSION)
.build();
}
HotRodServerConfigurationBuilder getHotRodServerBuilder() {
HotRodServerConfigurationBuilder targetHotRodBuilder = new HotRodServerConfigurationBuilder();
targetHotRodBuilder
.ssl()
.enable()
.requireClientAuth(true)
.keyStoreFileName(TestCertificates.certificate("server"))
.keyStorePassword(TestCertificates.KEY_PASSWORD)
.keyAlias("server")
.trustStoreFileName(TestCertificates.certificate("ca"))
.trustStorePassword(TestCertificates.KEY_PASSWORD);
return targetHotRodBuilder;
}
}
| 2,773
| 45.233333
| 123
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeStressTest.java
|
package org.infinispan.persistence.remote.upgrade;
import static java.util.stream.IntStream.range;
import static org.testng.Assert.assertEquals;
import java.util.concurrent.atomic.AtomicInteger;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@Test(testName = "upgrade.hotrod.HotRodUpgradeStressTest", groups = "stress")
public class HotRodUpgradeStressTest extends AbstractInfinispanTest {
private static final String CACHE_NAME = "stress";
private TestCluster sourceCluster, targetCluster;
@BeforeClass
public void setup() throws Exception {
sourceCluster = new TestCluster.Builder().setName("sourceCluster").setNumMembers(2)
.cache().name(CACHE_NAME)
.build();
targetCluster = new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(CACHE_NAME).remotePort(sourceCluster.getHotRodPort())
.build();
}
@AfterClass
public void tearDown() {
targetCluster.destroy();
sourceCluster.destroy();
}
void loadSourceCluster(int entries) {
RemoteCache<String, String> remoteCache = sourceCluster.getRemoteCache(CACHE_NAME);
AtomicInteger count = new AtomicInteger(0);
range(0, entries).boxed().parallel().map(String::valueOf).forEach(k -> {
remoteCache.put(k, "value" + k);
int progress = count.incrementAndGet();
if (progress % 10_000 == 0) {
System.out.printf("Loaded %d\n", progress);
}
});
}
@Test
public void testMigrate() throws Exception {
loadSourceCluster(1_000_000);
long start = System.currentTimeMillis();
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(CACHE_NAME);
rum.synchronizeData("hotrod", 1000, 5);
System.out.println("Elapsed (s): " + (System.currentTimeMillis() - start) / 1000);
rum.disconnectSource("hotrod");
assertEquals(targetCluster.getRemoteCache(CACHE_NAME).size(), sourceCluster.getRemoteCache(CACHE_NAME).size());
}
}
| 2,255
| 30.774648
| 117
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeDynamicEncodingsTest.java
|
package org.infinispan.persistence.remote.upgrade;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.StorageType;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationBuilder;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* Same as {@link HotRodUpgradeEncodingsTest} but using remote store created dynamically.
*
* @since 13.0
*/
@Test(groups = "functional", testName = "upgrade.hotrod.HotRodUpgradeDynamicEncodingsTest")
public class HotRodUpgradeDynamicEncodingsTest extends HotRodUpgradeEncodingsTest {
@Factory
public Object[] factory() {
return new Object[]{
new HotRodUpgradeDynamicEncodingsTest().withStorage(StorageType.HEAP),
new HotRodUpgradeDynamicEncodingsTest().withStorage(StorageType.OFF_HEAP)
};
}
@Override
protected TestCluster configureTargetCluster() {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(CACHE_NAME).configuredWith(getConfigurationBuilder()).build();
}
@Override
protected void connectTargetCluster() {
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
RemoteStoreConfigurationBuilder store = configurationBuilder.persistence().addStore(RemoteStoreConfigurationBuilder.class);
store.rawValues(true).remoteCacheName(CACHE_NAME).shared(true).segmented(false).addServer().host("localhost").port(sourceCluster.getHotRodPort());
targetCluster.connectSource(CACHE_NAME, configurationBuilder.build().persistence().stores().get(0));
}
}
| 1,655
| 40.4
| 152
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeDynamicStoreTest.java
|
package org.infinispan.persistence.remote.upgrade;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationBuilder;
import org.testng.annotations.Test;
/**
* Same as {@link HotRodUpgradeSynchronizerTest} but using remote store created dynamically.
*
* @since 13.0
*/
@Test(testName = "upgrade.hotrod.HotRodUpgradeDynamicStoreTest", groups = "functional")
public class HotRodUpgradeDynamicStoreTest extends HotRodUpgradeSynchronizerTest {
@Override
protected TestCluster configureTargetCluster() {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(OLD_CACHE)
.cache().name(TEST_CACHE).build();
}
@Override
protected void connectTargetCluster() {
targetCluster.connectSource(OLD_CACHE, getConfiguration(OLD_CACHE, OLD_PROTOCOL_VERSION));
targetCluster.connectSource(TEST_CACHE, getConfiguration(TEST_CACHE, NEW_PROTOCOL_VERSION));
}
private StoreConfiguration getConfiguration(String cacheName, ProtocolVersion version) {
ConfigurationBuilder builder = new ConfigurationBuilder();
RemoteStoreConfigurationBuilder storeBuilder = builder.persistence().addStore(RemoteStoreConfigurationBuilder.class);
storeBuilder.rawValues(true).remoteCacheName(cacheName).protocolVersion(version).shared(true).segmented(false)
.addServer().host("localhost").port(sourceCluster.getHotRodPort());
return storeBuilder.build().persistence().stores().get(0);
}
}
| 1,691
| 43.526316
| 123
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeDynamicPojoTest.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.transaction.TransactionMode.TRANSACTIONAL;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.jboss.marshalling.commons.GenericJBossMarshaller;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationBuilder;
import org.infinispan.transaction.TransactionMode;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* Same as {@link HotRodUpgradePojoTest} but using remote store created dynamically.
*
* @since 13.0
*/
@Test(testName = "upgrade.hotrod.HotRodUpgradeDynamicPojoTest", groups = "functional")
public class HotRodUpgradeDynamicPojoTest extends HotRodUpgradePojoTest {
@Factory
public Object[] factory() {
return new Object[]{
new HotRodUpgradeDynamicPojoTest().autoCommit(false).transaction(TRANSACTIONAL),
new HotRodUpgradeDynamicPojoTest().autoCommit(true).transaction(TRANSACTIONAL),
new HotRodUpgradeDynamicPojoTest().transaction(TransactionMode.NON_TRANSACTIONAL),
};
}
@Override
protected TestCluster configureTargetCluster(ConfigurationBuilder cacheConfig) {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.marshaller(GenericJBossMarshaller.class)
.cache().name(CACHE_NAME).configuredWith(cacheConfig)
.build();
}
@Override
protected void connectTargetCluster() {
ConfigurationBuilder cfg = new ConfigurationBuilder();
RemoteStoreConfigurationBuilder storeBuilder = cfg.persistence().addStore(RemoteStoreConfigurationBuilder.class);
storeBuilder.rawValues(false).marshaller(GenericJBossMarshaller.class).remoteCacheName(CACHE_NAME).segmented(false).shared(true)
.addServer().host("localhost").port(sourceCluster.getHotRodPort());
targetCluster.connectSource(CACHE_NAME, cfg.build().persistence().stores().get(0));
}
}
| 1,989
| 42.26087
| 134
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeSynchronizerTest.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.test.TestingUtil.extractComponent;
import static org.mockito.ArgumentMatchers.anySet;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.spy;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNull;
import java.io.IOException;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;
import org.infinispan.client.hotrod.MetadataValue;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.impl.RemoteCacheImpl;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.commons.util.IteratorMapper;
import org.infinispan.jboss.marshalling.commons.GenericJBossMarshaller;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.remote.RemoteStore;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
@Test(testName = "upgrade.hotrod.HotRodUpgradeSynchronizerTest", groups = "functional")
public class HotRodUpgradeSynchronizerTest extends AbstractInfinispanTest {
protected TestCluster sourceCluster, targetCluster;
protected static final String OLD_CACHE = "old-cache";
protected String TEST_CACHE = this.getClass().getName();
protected static final ProtocolVersion OLD_PROTOCOL_VERSION = ProtocolVersion.PROTOCOL_VERSION_20;
protected static final ProtocolVersion NEW_PROTOCOL_VERSION = ProtocolVersion.DEFAULT_PROTOCOL_VERSION;
@BeforeMethod
public void setup() throws Exception {
sourceCluster = new TestCluster.Builder().setName("sourceCluster").setNumMembers(2)
.cache().name(OLD_CACHE)
.cache().name(TEST_CACHE)
.build();
targetCluster = configureTargetCluster();
}
private void fillCluster(TestCluster cluster, String cacheName) {
for (char ch = 'A'; ch <= 'Z'; ch++) {
String s = Character.toString(ch);
cluster.getRemoteCache(cacheName).put(s, s, 20, TimeUnit.SECONDS, 30, TimeUnit.SECONDS);
}
}
protected TestCluster configureTargetCluster() {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(OLD_CACHE).remotePort(sourceCluster.getHotRodPort()).remoteProtocolVersion(OLD_PROTOCOL_VERSION)
.cache().name(TEST_CACHE).remotePort(sourceCluster.getHotRodPort()).remoteProtocolVersion(NEW_PROTOCOL_VERSION)
.build();
}
protected void connectTargetCluster() {
// No op, target cluster is already connected to the source (static remote store added).
}
public void testSynchronization() throws Exception {
connectTargetCluster();
RemoteCache<String, String> sourceRemoteCache = sourceCluster.getRemoteCache(TEST_CACHE);
RemoteCache<String, String> targetRemoteCache = targetCluster.getRemoteCache(TEST_CACHE);
for (char ch = 'A'; ch <= 'Z'; ch++) {
String s = Character.toString(ch);
sourceRemoteCache.put(s, s, 20, TimeUnit.SECONDS, 30, TimeUnit.SECONDS);
}
// Verify access to some of the data from the new cluster
assertEquals("A", targetRemoteCache.get("A"));
RollingUpgradeManager upgradeManager = targetCluster.getRollingUpgradeManager(TEST_CACHE);
long count = upgradeManager.synchronizeData("hotrod");
assertEquals(26, count);
assertEquals(sourceCluster.getEmbeddedCache(TEST_CACHE).size(), targetCluster.getEmbeddedCache(TEST_CACHE).size());
upgradeManager.disconnectSource("hotrod");
MetadataValue<String> metadataValue = targetRemoteCache.getWithMetadata("Z");
assertEquals(20, metadataValue.getLifespan());
assertEquals(30, metadataValue.getMaxIdle());
}
public void testSynchronizationWithClientDeleteBefore() throws Exception {
connectTargetCluster();
// fill source cluster with data
fillCluster(sourceCluster, TEST_CACHE);
// Change data in the target cluster
RemoteCache<String, String> remoteCache = targetCluster.getRemoteCache(TEST_CACHE);
remoteCache.remove("G");
assertFalse(remoteCache.containsKey("G"));
// Perform rolling upgrade
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(TEST_CACHE);
rum.synchronizeData("hotrod");
rum.disconnectSource("hotrod");
// Verify data is consistent
assertFalse(remoteCache.containsKey("G"));
assertEquals("A", remoteCache.get("A"));
assertEquals("U", remoteCache.get("U"));
}
public void testSynchronizationWithClientWriteBefore() throws Exception {
connectTargetCluster();
// fill source cluster with data
fillCluster(sourceCluster, TEST_CACHE);
// Writes data in the target cluster
RemoteCache<String, String> remoteCache = targetCluster.getRemoteCache(TEST_CACHE);
remoteCache.put("U", "I");
remoteCache.put("a", "a");
assertEquals("a", remoteCache.get("a"));
assertEquals("I", remoteCache.get("U"));
// Perform rolling upgrade
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(TEST_CACHE);
rum.synchronizeData("hotrod");
rum.disconnectSource("hotrod");
// Verify data is consistent
assertEquals("a", remoteCache.get("a"));
assertEquals("I", remoteCache.get("U"));
}
public void testSynchronizationWithClientReadsBefore() throws Exception {
connectTargetCluster();
// fill source cluster with data
fillCluster(sourceCluster, TEST_CACHE);
// Read data in the target cluster
RemoteCache<String, String> remoteCache = targetCluster.getRemoteCache(TEST_CACHE);
assertEquals("X", remoteCache.get("X"));
// Perform rolling upgrade
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(TEST_CACHE);
rum.synchronizeData("hotrod");
rum.disconnectSource("hotrod");
// Verify data is consistent
assertEquals("X", remoteCache.get("X"));
}
@Test
public void testSynchronizationWithInFlightUpdates() throws Exception {
connectTargetCluster();
// fill source cluster with data
fillCluster(sourceCluster, TEST_CACHE);
RemoteCache<String, String> remoteCache = targetCluster.getRemoteCache(TEST_CACHE);
doWhenSourceIterationReaches("M", targetCluster, TEST_CACHE, key -> remoteCache.put("M", "changed"));
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(TEST_CACHE);
rum.synchronizeData("hotrod");
rum.disconnectSource("hotrod");
// Verify data is not overridden
assertEquals("changed", remoteCache.get("M"));
}
@Test
public void testSynchronizationWithInFlightDeletes() throws Exception {
connectTargetCluster();
// fill source cluster with data
fillCluster(sourceCluster, TEST_CACHE);
RemoteCache<String, String> remoteCache = targetCluster.getRemoteCache(TEST_CACHE);
doWhenSourceIterationReaches("L", targetCluster, TEST_CACHE, key -> remoteCache.remove("L"));
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(TEST_CACHE);
rum.synchronizeData("hotrod");
rum.disconnectSource("hotrod");
// Verify data is not re-added
assertNull(remoteCache.get("L"));
assertEquals("A", remoteCache.get("A"));
assertEquals("I", remoteCache.get("I"));
}
public void testSynchronizationWithInFlightReads() throws Exception {
connectTargetCluster();
// fill source cluster with data
fillCluster(sourceCluster, TEST_CACHE);
RemoteCache<String, String> remoteCache = targetCluster.getRemoteCache(TEST_CACHE);
doWhenSourceIterationReaches("G", targetCluster, TEST_CACHE, key -> remoteCache.get("G"));
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(TEST_CACHE);
rum.synchronizeData("hotrod");
rum.disconnectSource("hotrod");
assertEquals("G", remoteCache.get("G"));
}
private void doWhenSourceIterationReaches(String key, TestCluster cluster, String cacheName, IterationCallBack callback) {
cluster.getEmbeddedCaches(cacheName).forEach(c -> {
PersistenceManager pm = extractComponent(c, PersistenceManager.class);
RemoteStore remoteStore = pm.getStores(RemoteStore.class).iterator().next();
RemoteCacheImpl remoteCache = TestingUtil.extractField(remoteStore, "remoteCache");
RemoteCacheImpl spy = spy(remoteCache);
doAnswer(invocation -> {
Object[] params = invocation.getArguments();
CloseableIterator<Map.Entry<Object, Object>> iterator = remoteCache.retrieveEntriesWithMetadata((Set<Integer>) params[0], (int) params[1]);
Marshaller marshaller = new GenericJBossMarshaller();
return new IteratorMapper<>(iterator, entry -> {
try {
if (key.equals(marshaller.objectFromByteBuffer((byte[]) entry.getKey()))) {
callback.iterationReached(key);
}
} catch (IOException | ClassNotFoundException ex) {
throw new RuntimeException(ex);
}
return entry;
});
}).when(spy).retrieveEntriesWithMetadata(anySet(), anyInt());
TestingUtil.replaceField(spy, "remoteCache", remoteStore, RemoteStore.class);
});
}
@AfterMethod
public void tearDown() {
sourceCluster.destroy();
targetCluster.destroy();
}
}
| 9,958
| 38.836
| 151
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeWithStoreTest.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.test.TestingUtil.extractComponent;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;
import org.infinispan.client.hotrod.MetadataValue;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.dummy.DummyInMemoryStore;
import org.infinispan.persistence.dummy.DummyInMemoryStoreConfigurationBuilder;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.infinispan.util.concurrent.IsolationLevel;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@Test(testName = "upgrade.hotrod.HotRodUpgradeWithStoreTest", groups = "functional")
public class HotRodUpgradeWithStoreTest extends AbstractInfinispanTest {
protected TestCluster sourceCluster, targetCluster;
protected String CACHE_NAME = this.getClass().getName();
private static final int INITIAL_NUM_ENTRIES = 10;
@BeforeClass
public void setup() throws Exception {
ConfigurationBuilder sourceStoreBuilder = new ConfigurationBuilder();
sourceStoreBuilder.clustering().cacheMode(CacheMode.DIST_SYNC)
.locking().isolationLevel(IsolationLevel.REPEATABLE_READ)
.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class).shared(true).storeName("sourceStore");
sourceCluster = new TestCluster.Builder().setName("sourceCluster").setNumMembers(2)
.cache().name(CACHE_NAME).configuredWith(sourceStoreBuilder)
.build();
targetCluster = configureTargetCluster();
}
protected TestCluster configureTargetCluster() {
ConfigurationBuilder targetStoreBuilder = new ConfigurationBuilder();
targetStoreBuilder.clustering().cacheMode(CacheMode.DIST_SYNC)
.locking().isolationLevel(IsolationLevel.REPEATABLE_READ)
.persistence().addStore(DummyInMemoryStoreConfigurationBuilder.class).shared(true).storeName("targetStore");
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(CACHE_NAME).remotePort(sourceCluster.getHotRodPort()).configuredWith(targetStoreBuilder)
.build();
}
protected void connectTargetCluster() {
// No op, target cluster is already connected to the source (static remote store added).
}
public void testSynchronization() throws Exception {
connectTargetCluster();
RemoteCache<String, String> sourceRemoteCache = sourceCluster.getRemoteCache(CACHE_NAME);
RemoteCache<String, String> targetRemoteCache = targetCluster.getRemoteCache(CACHE_NAME);
IntStream.rangeClosed(1, INITIAL_NUM_ENTRIES).boxed().map(String::valueOf)
.forEach(s -> sourceRemoteCache.put(s, s, 10, TimeUnit.MINUTES, 30, TimeUnit.MINUTES));
// Check data is persisted in the source cluster
assertEquals(INITIAL_NUM_ENTRIES, storeWrites(sourceCluster));
// Verify data is accessible from the target cluster
assertEquals("4", targetRemoteCache.get("4"));
// Change data from the target cluster and check it propagates to the source cluster's store
targetRemoteCache.put("8", "changed", 10, TimeUnit.MINUTES, 30, TimeUnit.MINUTES);
targetRemoteCache.remove("5");
targetRemoteCache.remove("1");
targetRemoteCache.put("new key", "new value", 10, TimeUnit.MINUTES, 30, TimeUnit.MINUTES);
assertEquals(INITIAL_NUM_ENTRIES - 1, storeSize(sourceCluster));
assertEquals(INITIAL_NUM_ENTRIES + 2, storeWrites(sourceCluster));
// Verify modified entries are in the target clusters' store
assertEquals(2, storeSize(targetCluster));
// Synchronize data
RollingUpgradeManager upgradeManager = targetCluster.getRollingUpgradeManager(CACHE_NAME);
long migrated = upgradeManager.synchronizeData("hotrod", 10, 1);
upgradeManager.disconnectSource("hotrod");
assertEquals(INITIAL_NUM_ENTRIES - 1, migrated);
assertEquals(sourceCluster.getEmbeddedCache(CACHE_NAME).size(), targetCluster.getEmbeddedCache(CACHE_NAME).size());
MetadataValue<String> metadataValue = targetRemoteCache.getWithMetadata("10");
assertEquals(10 * 60, metadataValue.getLifespan());
assertEquals(30 * 60, metadataValue.getMaxIdle());
// Verify data correctly migrated
assertFalse(targetRemoteCache.containsKey("5"));
assertFalse(targetRemoteCache.containsKey("1"));
assertEquals("4", targetRemoteCache.get("4"));
assertEquals("changed", targetRemoteCache.get("8"));
assertEquals("new value", targetRemoteCache.get("new key"));
// Source cluster's store should not have changed
assertEquals(INITIAL_NUM_ENTRIES - 1, storeSize(sourceCluster));
// Target cluster's store should have the migrated entries
assertEquals(INITIAL_NUM_ENTRIES - 1, targetRemoteCache.size());
assertEquals(INITIAL_NUM_ENTRIES - 1, storeSize(targetCluster));
// No data should be written to the source cluster during migration
assertEquals(INITIAL_NUM_ENTRIES + 2, storeWrites(sourceCluster));
}
private DummyInMemoryStore getDummyStore(TestCluster testCluster) {
PersistenceManager pm = extractComponent(testCluster.getEmbeddedCache(CACHE_NAME), PersistenceManager.class);
return pm.getStores(DummyInMemoryStore.class).iterator().next();
}
private long storeSize(TestCluster cluster) {
return getDummyStore(cluster).size();
}
private int storeWrites(TestCluster cluster) {
return getDummyStore(cluster).stats().get("write");
}
@AfterClass
public void tearDown() {
targetCluster.destroy();
sourceCluster.destroy();
}
}
| 6,066
| 43.284672
| 121
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradePojoTest.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OBJECT_TYPE;
import static org.infinispan.transaction.TransactionMode.TRANSACTIONAL;
import static org.testng.AssertJUnit.assertEquals;
import java.util.concurrent.TimeUnit;
import org.infinispan.Cache;
import org.infinispan.client.hotrod.MetadataValue;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.commons.marshall.ProtoStreamMarshaller;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.jboss.marshalling.commons.GenericJBossMarshaller;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.transaction.TransactionMode;
import org.infinispan.transaction.lookup.EmbeddedTransactionManagerLookup;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* Test for Hot Rod Rolling Upgrades from caches storing application/x-java-object.
*
* @since 12.0
*/
@Test(testName = "upgrade.hotrod.HotRodUpgradePojoTest", groups = "functional")
public class HotRodUpgradePojoTest extends AbstractInfinispanTest {
protected TestCluster sourceCluster, targetCluster;
protected static final String CACHE_NAME = "theCache";
public static final int ENTRIES = 50;
private TransactionMode transactionMode;
private boolean autoCommit;
@Factory
public Object[] factory() {
return new Object[]{
new HotRodUpgradePojoTest().autoCommit(false).transaction(TRANSACTIONAL),
new HotRodUpgradePojoTest().autoCommit(true).transaction(TRANSACTIONAL),
new HotRodUpgradePojoTest().transaction(TransactionMode.NON_TRANSACTIONAL),
};
}
@Override
protected String parameters() {
return "[" + transactionMode + ", autoCommit=" + autoCommit + "]";
}
protected HotRodUpgradePojoTest transaction(TransactionMode transactionMode) {
this.transactionMode = transactionMode;
return this;
}
protected HotRodUpgradePojoTest autoCommit(boolean autoCommit) {
this.autoCommit = autoCommit;
return this;
}
@BeforeMethod
public void setup() throws Exception {
ConfigurationBuilder config = new ConfigurationBuilder();
config.clustering().cacheMode(CacheMode.DIST_SYNC);
config.encoding().key().mediaType(APPLICATION_OBJECT_TYPE);
config.encoding().value().mediaType(APPLICATION_OBJECT_TYPE);
config.transaction().transactionMode(transactionMode);
if (transactionMode != TransactionMode.NON_TRANSACTIONAL) {
config.transaction().transactionMode(transactionMode).autoCommit(autoCommit)
.transactionManagerLookup(new EmbeddedTransactionManagerLookup());
}
sourceCluster = new TestCluster.Builder().setName("sourceCluster").setNumMembers(2)
.marshaller(ProtoStreamMarshaller.class)
.ctx(SerializationCtx.INSTANCE)
.cache().name(CACHE_NAME).configuredWith(config)
.build();
targetCluster = configureTargetCluster(config);
}
protected TestCluster configureTargetCluster(ConfigurationBuilder cacheConfig) {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.marshaller(GenericJBossMarshaller.class)
.cache().name(CACHE_NAME).configuredWith(cacheConfig)
.remotePort(sourceCluster.getHotRodPort()).remoteStoreWrapping(false).remoteStoreRawValues(false)
.remoteStoreMarshaller(GenericJBossMarshaller.class)
.build();
}
protected void connectTargetCluster() {
// No op, target cluster is already connected to the source (static remote store added).
}
public void testSynchronization() throws Exception {
connectTargetCluster();
RemoteCache<Object, Object> sourceRemoteCache = sourceCluster.getRemoteCache(CACHE_NAME, transactionMode.equals(TRANSACTIONAL));
RemoteCache<Object, Object> targetRemoteCache = targetCluster.getRemoteCache(CACHE_NAME);
startTxIfNeeded(sourceRemoteCache);
for (int i = 0; i < ENTRIES; i++) {
sourceRemoteCache.put(i, new CustomObject("text", i), 20, TimeUnit.MINUTES, 30, TimeUnit.MINUTES);
}
commitTxIfNeeded(sourceRemoteCache);
assertEquals(ENTRIES, sourceRemoteCache.size());
// Verify data access from the target cluster
assertEquals(ENTRIES, targetRemoteCache.size());
assertEquals(new CustomObject("text", 2), targetRemoteCache.get(2));
// Do a Rolling Upgrade
RollingUpgradeManager upgradeManager = targetCluster.getRollingUpgradeManager(CACHE_NAME);
long count = upgradeManager.synchronizeData("hotrod");
assertEquals(ENTRIES, count);
// Disconnect remote store
upgradeManager.disconnectSource("hotrod");
// Check migrated data
assertEquals(sourceCluster.getEmbeddedCache(CACHE_NAME).size(), targetCluster.getEmbeddedCache(CACHE_NAME).size());
assertEquals(new CustomObject("text", 10), targetRemoteCache.get(10));
MetadataValue<Object> metadataValue = targetRemoteCache.getWithMetadata(ENTRIES - 1);
assertEquals(20 * 60, metadataValue.getLifespan());
assertEquals(30 * 60, metadataValue.getMaxIdle());
}
public void testSynchronizationBetweenEmbedded() throws Exception {
connectTargetCluster();
sourceCluster.cleanAllCaches();
targetCluster.cleanAllCaches();
Cache<Object, Object> sourceCache = sourceCluster.getEmbeddedCache(CACHE_NAME);
Cache<Object, Object> targetCache = targetCluster.getEmbeddedCache(CACHE_NAME);
startTxIfNeeded(sourceCache);
// Populate source cluster
for (int i = 0; i < ENTRIES; i++) {
sourceCache.put(i, new CustomObject("text", i), 20, TimeUnit.MINUTES, 30, TimeUnit.MINUTES);
}
commitTxIfNeeded(sourceCache);
assertEquals(ENTRIES, sourceCache.size());
// Verify data access from the target cluster
assertEquals(ENTRIES, targetCache.size());
assertEquals(new CustomObject("text", 2), targetCache.get(2));
// Do a Rolling Upgrade
RollingUpgradeManager upgradeManager = targetCluster.getRollingUpgradeManager(CACHE_NAME);
long count = upgradeManager.synchronizeData("hotrod");
assertEquals(ENTRIES, count);
// Disconnect remote store
upgradeManager.disconnectSource("hotrod");
// Check migrated data
assertEquals(sourceCluster.getEmbeddedCache(CACHE_NAME).size(), targetCluster.getEmbeddedCache(CACHE_NAME).size());
assertEquals(new CustomObject("text", 10), targetCache.get(10));
CacheEntry<Object, Object> entry = targetCache.getAdvancedCache().getCacheEntry(ENTRIES - 1);
assertEquals(20 * 60 * 1000, entry.getLifespan());
assertEquals(30 * 60 * 1000, entry.getMaxIdle());
}
@AfterMethod
public void tearDown() {
sourceCluster.destroy();
targetCluster.destroy();
}
private void startTxIfNeeded(Cache<Object, Object> cache) throws Exception {
Configuration config = cache.getCacheConfiguration();
if (config.transaction().transactionMode().isTransactional() && !config.transaction().autoCommit()) {
cache.getAdvancedCache().getTransactionManager().begin();
}
}
private void commitTxIfNeeded(Cache<Object, Object> cache) throws Exception {
Configuration config = cache.getCacheConfiguration();
if (config.transaction().transactionMode().isTransactional() && !config.transaction().autoCommit()) {
cache.getAdvancedCache().getTransactionManager().commit();
}
}
private void startTxIfNeeded(RemoteCache<Object, Object> remoteCache) throws Exception {
String name = remoteCache.getName();
Configuration config = sourceCluster.getEmbeddedCache(name).getCacheConfiguration();
if (config.transaction().transactionMode().isTransactional() && !config.transaction().autoCommit()) {
remoteCache.getTransactionManager().begin();
}
}
private void commitTxIfNeeded(RemoteCache<Object, Object> remoteCache) throws Exception {
String name = remoteCache.getName();
Configuration config = sourceCluster.getEmbeddedCache(name).getCacheConfiguration();
if (config.transaction().transactionMode().isTransactional() && !config.transaction().autoCommit()) {
remoteCache.getTransactionManager().commit();
}
}
}
| 8,723
| 40.345972
| 134
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeEncodingsTest.java
|
package org.infinispan.persistence.remote.upgrade;
import static java.util.stream.IntStream.range;
import static org.infinispan.test.AbstractCacheTest.getDefaultClusteredCacheConfig;
import static org.testng.Assert.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.StorageType;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* Test rolling upgrades with different key encodings in the server, e.g. StorageType.BINARY
*
* @since 11.0
*/
@Test(groups = "functional", testName = "upgrade.hotrod.HotRodUpgradeEncodingsTest")
public class HotRodUpgradeEncodingsTest extends AbstractInfinispanTest {
protected static final String CACHE_NAME = "encoded";
protected TestCluster sourceCluster, targetCluster;
protected StorageType storageType;
@Factory
public Object[] factory() {
return new Object[]{
new HotRodUpgradeEncodingsTest().withStorage(StorageType.HEAP),
new HotRodUpgradeEncodingsTest().withStorage(StorageType.OFF_HEAP)
};
}
@Override
protected String parameters() {
return "[" + storageType.toString() + "]";
}
public HotRodUpgradeEncodingsTest withStorage(StorageType storageType) {
this.storageType = storageType;
return this;
}
@BeforeClass
public void setup() {
ConfigurationBuilder configurationBuilder = getConfigurationBuilder();
sourceCluster = new TestCluster.Builder().setName("sourceCluster").setNumMembers(2)
.cache().name(CACHE_NAME)
.configuredWith(configurationBuilder)
.build();
targetCluster = configureTargetCluster();
}
protected ConfigurationBuilder getConfigurationBuilder() {
ConfigurationBuilder configurationBuilder = getDefaultClusteredCacheConfig(CacheMode.DIST_SYNC);
configurationBuilder.clustering().hash().numSegments(2);
configurationBuilder.memory().storage(storageType);
return configurationBuilder;
}
protected TestCluster configureTargetCluster() {
return new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(CACHE_NAME).remotePort(sourceCluster.getHotRodPort())
.configuredWith(getConfigurationBuilder()).build();
}
@AfterClass
public void tearDown() {
targetCluster.destroy();
sourceCluster.destroy();
}
void loadSourceCluster(int entries) {
RemoteCache<String, String> remoteCache = sourceCluster.getRemoteCache(CACHE_NAME);
range(0, entries).boxed().map(String::valueOf).forEach(k -> remoteCache.put(k, "value" + k));
}
protected void connectTargetCluster() {
// No op, target cluster is already connected to the source (static remote store added).
}
@Test
public void testMigrate() throws Exception {
connectTargetCluster();
int entries = 1000;
loadSourceCluster(entries);
RollingUpgradeManager rum = targetCluster.getRollingUpgradeManager(CACHE_NAME);
rum.synchronizeData("hotrod", 10, 2);
targetCluster.disconnectSource(CACHE_NAME);
assertEquals(targetCluster.getRemoteCache(CACHE_NAME).size(), entries);
}
}
| 3,522
| 32.552381
| 102
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/HotRodUpgradeMediaTypesTest.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.client.hotrod.ProtocolVersion.PROTOCOL_VERSION_25;
import static org.infinispan.client.hotrod.ProtocolVersion.PROTOCOL_VERSION_28;
import static org.infinispan.client.hotrod.ProtocolVersion.PROTOCOL_VERSION_31;
import static org.testng.AssertJUnit.assertEquals;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.upgrade.RollingUpgradeManager;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* Test for Hot Rod Rolling Upgrades using different storage types in caches
*
* @since 12.0
*/
@Test(testName = "upgrade.hotrod.HotRodUpgradeMediaTypesTest", groups = "functional")
public class HotRodUpgradeMediaTypesTest extends AbstractInfinispanTest {
protected TestCluster sourceCluster, targetCluster;
protected static final String CACHE_NAME = "theCache";
public static final int ENTRIES = 10;
private MediaType mediaType;
private ProtocolVersion version;
@Factory
public Object[] factory() {
return new Object[]{
new HotRodUpgradeMediaTypesTest().protocolVersion(PROTOCOL_VERSION_25),
new HotRodUpgradeMediaTypesTest().protocolVersion(PROTOCOL_VERSION_28),
new HotRodUpgradeMediaTypesTest().protocolVersion(PROTOCOL_VERSION_31),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.TEXT_PLAIN).protocolVersion(PROTOCOL_VERSION_25),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.TEXT_PLAIN).protocolVersion(PROTOCOL_VERSION_28),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.TEXT_PLAIN).protocolVersion(PROTOCOL_VERSION_31),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.APPLICATION_PROTOSTREAM).protocolVersion(PROTOCOL_VERSION_25),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.APPLICATION_PROTOSTREAM).protocolVersion(PROTOCOL_VERSION_28),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.APPLICATION_PROTOSTREAM).protocolVersion(PROTOCOL_VERSION_31),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.APPLICATION_SERIALIZED_OBJECT).protocolVersion(PROTOCOL_VERSION_25),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.APPLICATION_SERIALIZED_OBJECT).protocolVersion(PROTOCOL_VERSION_28),
new HotRodUpgradeMediaTypesTest().mediaType(MediaType.APPLICATION_SERIALIZED_OBJECT).protocolVersion(PROTOCOL_VERSION_31),
};
}
private HotRodUpgradeMediaTypesTest protocolVersion(ProtocolVersion version) {
this.version = version;
return this;
}
private HotRodUpgradeMediaTypesTest mediaType(MediaType mediaType) {
this.mediaType = mediaType;
return this;
}
@Override
protected String parameters() {
return String.format("[mediaType=%s,version=%s]", mediaType, version.toString().replace(".", "_"));
}
@BeforeMethod
public void setup() throws Exception {
ConfigurationBuilder config = new ConfigurationBuilder();
config.clustering().cacheMode(CacheMode.DIST_SYNC);
if (mediaType != null) {
config.encoding().mediaType(mediaType.toString());
}
sourceCluster = new TestCluster.Builder().setName("sourceCluster").setNumMembers(2)
.cache().name(CACHE_NAME).configuredWith(config)
.build();
targetCluster = new TestCluster.Builder().setName("targetCluster").setNumMembers(2)
.cache().name(CACHE_NAME).configuredWith(config)
.remoteProtocolVersion(version)
.remotePort(sourceCluster.getHotRodPort()).remoteStoreWrapping(true).remoteStoreRawValues(true)
.build();
}
public void testSynchronization() throws Exception {
RemoteCache<Object, Object> sourceRemoteCache = sourceCluster.getRemoteCache(CACHE_NAME, mediaType);
RemoteCache<Object, Object> targetRemoteCache = targetCluster.getRemoteCache(CACHE_NAME, mediaType);
for (int i = 0; i < ENTRIES; i++) {
sourceRemoteCache.put(key(i), value(i));
}
assertEquals(ENTRIES, sourceRemoteCache.size());
assertEquals(ENTRIES, targetRemoteCache.size());
assertEquals(value(5), targetRemoteCache.get(key(5)));
// Do a Rolling Upgrade
RollingUpgradeManager upgradeManager = targetCluster.getRollingUpgradeManager(CACHE_NAME);
long count = upgradeManager.synchronizeData("hotrod");
assertEquals(ENTRIES, count);
// Disconnect remote store
upgradeManager.disconnectSource("hotrod");
// Check migrated data
assertEquals(sourceCluster.getEmbeddedCache(CACHE_NAME).size(), targetCluster.getEmbeddedCache(CACHE_NAME).size());
assertEquals(value(7), targetRemoteCache.get(key(7)));
}
@AfterMethod
public void tearDown() {
sourceCluster.destroy();
targetCluster.destroy();
}
private Object key(int idx) {
return idx;
}
private Object value(int idx) {
return "Value_" + idx;
}
}
| 5,375
| 41.666667
| 134
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/IterationCallBack.java
|
package org.infinispan.persistence.remote.upgrade;
interface IterationCallBack {
void iterationReached(Object key);
}
| 122
| 19.5
| 50
|
java
|
null |
infinispan-main/persistence/remote/src/test/java/org/infinispan/persistence/remote/upgrade/CustomObject.java
|
package org.infinispan.persistence.remote.upgrade;
import java.io.Serializable;
import java.util.Objects;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
public class CustomObject implements Serializable {
@ProtoFactory
public CustomObject(String text, Integer number) {
this.text = text;
this.number = number;
}
@ProtoField(number = 1)
String text;
@ProtoField(number = 2)
Integer number;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
CustomObject that = (CustomObject) o;
if (!Objects.equals(text, that.text)) return false;
return Objects.equals(number, that.number);
}
@Override
public int hashCode() {
int result = text != null ? text.hashCode() : 0;
result = 31 * result + (number != null ? number.hashCode() : 0);
return result;
}
@Override
public String toString() {
return "CustomObject{" +
"text='" + text + '\'' +
", number=" + number +
'}';
}
}
| 1,172
| 22.938776
| 70
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/package-info.java
|
/**
* Hot Rod-based {@link org.infinispan.persistence.spi.AdvancedLoadWriteStore}.
*
* @api.public
*/
package org.infinispan.persistence.remote;
| 149
| 20.428571
| 79
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/ExternalizerIds.java
|
package org.infinispan.persistence.remote;
/**
* 1800 to 1899 range is reserved for this module
*
* @author gustavonalle
* @since 8.2
*/
public interface ExternalizerIds {
Integer MIGRATION_TASK = 1900;
Integer REMOVED_FILTER = 1901;
Integer DISCONNECT_REMOTE_STORE = 1902;
Integer ENTRY_WRITER = 1903;
Integer ADD_REMOTE_STORE = 1904;
Integer CHECK_REMOTE_STORE = 1905;
}
| 398
| 21.166667
| 49
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/LifecycleCallbacks.java
|
package org.infinispan.persistence.remote;
import java.util.Map;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.factories.annotations.InfinispanModule;
import org.infinispan.lifecycle.ModuleLifecycle;
import org.infinispan.persistence.remote.upgrade.AddSourceRemoteStoreTask;
import org.infinispan.persistence.remote.upgrade.CheckRemoteStoreTask;
import org.infinispan.persistence.remote.upgrade.DisconnectRemoteStoreTask;
import org.infinispan.persistence.remote.upgrade.MigrationTask;
import org.infinispan.persistence.remote.upgrade.RemovedFilter;
/**
* @author gustavonalle
* @since 8.2
*/
@InfinispanModule(name = "cachestore-remote", requiredModules = "core")
public class LifecycleCallbacks implements ModuleLifecycle {
@Override
public void cacheManagerStarting(GlobalComponentRegistry gcr, GlobalConfiguration globalCfg) {
Map<Integer, AdvancedExternalizer<?>> externalizerMap = globalCfg.serialization().advancedExternalizers();
externalizerMap.put(ExternalizerIds.MIGRATION_TASK, new MigrationTask.Externalizer());
externalizerMap.put(ExternalizerIds.REMOVED_FILTER, new RemovedFilter.Externalizer());
externalizerMap.put(ExternalizerIds.DISCONNECT_REMOTE_STORE, new DisconnectRemoteStoreTask.Externalizer());
externalizerMap.put(ExternalizerIds.ENTRY_WRITER, new MigrationTask.EntryWriterExternalizer());
externalizerMap.put(ExternalizerIds.ADD_REMOTE_STORE, new AddSourceRemoteStoreTask.Externalizer());
externalizerMap.put(ExternalizerIds.CHECK_REMOTE_STORE, new CheckRemoteStoreTask.Externalizer());
}
}
| 1,735
| 48.6
| 113
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/RemoteStore.java
|
package org.infinispan.persistence.remote;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import org.infinispan.client.hotrod.DataFormat;
import org.infinispan.client.hotrod.MetadataValue;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.ServerStatistics;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.configuration.ExhaustedAction;
import org.infinispan.client.hotrod.impl.HotRodURI;
import org.infinispan.client.hotrod.impl.InternalRemoteCache;
import org.infinispan.client.hotrod.impl.protocol.Codec27;
import org.infinispan.commons.configuration.ConfiguredBy;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.marshall.IdentityMarshaller;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.commons.util.EnumUtil;
import org.infinispan.commons.util.IntSet;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.configuration.cache.ClusteringConfiguration;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.container.impl.InternalEntryFactory;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.context.impl.FlagBitSets;
import org.infinispan.encoding.impl.StorageConfigurationManager;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.metadata.Metadata;
import org.infinispan.persistence.remote.configuration.AuthenticationConfiguration;
import org.infinispan.persistence.remote.configuration.ConnectionPoolConfiguration;
import org.infinispan.persistence.remote.configuration.RemoteServerConfiguration;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration;
import org.infinispan.persistence.remote.configuration.SslConfiguration;
import org.infinispan.persistence.remote.logging.Log;
import org.infinispan.persistence.spi.InitializationContext;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.MarshallableEntryFactory;
import org.infinispan.persistence.spi.MarshalledValue;
import org.infinispan.persistence.spi.NonBlockingStore;
import org.infinispan.util.concurrent.BlockingManager;
import org.infinispan.util.logging.LogFactory;
import org.reactivestreams.Publisher;
import io.reactivex.rxjava3.core.Completable;
import io.reactivex.rxjava3.core.Flowable;
/**
* Cache store that delegates the call to a infinispan cluster. Communication between this cache store and the remote
* cluster is achieved through the java HotRod client: this assures fault tolerance and smart dispatching of calls to
* the nodes that have the highest chance of containing the given key. This cache store supports both preloading
* and <b>fetchPersistentState</b>.
* <p/>
* Purging elements is not possible, as HotRod does not support the fetching of all remote keys (this would be a
* very costly operation as well). Purging takes place at the remote end (infinispan cluster).
* <p/>
*
* @author Mircea.Markus@jboss.com
* @see org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration
* @see <a href="http://community.jboss.org/wiki/JavaHotRodclient">Hotrod Java Client</a>
* @since 4.1
*/
@ConfiguredBy(RemoteStoreConfiguration.class)
public class RemoteStore<K, V> implements NonBlockingStore<K, V> {
private static final Log log = LogFactory.getLog(RemoteStore.class, Log.class);
private RemoteStoreConfiguration configuration;
private RemoteCacheManager remoteCacheManager;
private InternalRemoteCache<Object, Object> remoteCache;
private InternalEntryFactory iceFactory;
private static final String LIFESPAN = "lifespan";
private static final String MAXIDLE = "maxidle";
protected InitializationContext ctx;
private MarshallableEntryFactory<K, V> entryFactory;
private BlockingManager blockingManager;
private int segmentCount;
private boolean supportsSegmentation;
@Override
public CompletionStage<Void> start(InitializationContext ctx) {
this.ctx = ctx;
this.configuration = ctx.getConfiguration();
this.entryFactory = ctx.getMarshallableEntryFactory();
this.blockingManager = ctx.getBlockingManager();
Configuration cacheConfiguration = ctx.getCache().getCacheConfiguration();
ClusteringConfiguration clusterConfiguration = cacheConfiguration.clustering();
this.segmentCount = clusterConfiguration.hash().numSegments();
final Marshaller marshaller;
if (configuration.marshaller() != null) {
marshaller = Util.getInstance(configuration.marshaller(), ctx.getCache().getAdvancedCache().getClassLoader());
} else {
// If rawValues are required, then it's necessary to utilise the user marshaller directly to prevent objects being wrapped with a MarshallableUserObject
marshaller = configuration.rawValues() ? ctx.getPersistenceMarshaller().getUserMarshaller() : ctx.getPersistenceMarshaller();
}
if (clusterConfiguration.cacheMode().isClustered() && !configuration.shared()) {
throw log.clusteredRequiresBeingShared();
}
if (configuration.rawValues() && iceFactory == null) {
iceFactory = ctx.getCache().getAdvancedCache().getComponentRegistry().getComponent(InternalEntryFactory.class);
}
ConfigurationBuilder builder = buildRemoteConfiguration(configuration, marshaller);
return blockingManager.supplyBlocking(() -> {
remoteCacheManager = new RemoteCacheManager(builder.build());
if (configuration.remoteCacheName().isEmpty())
remoteCache = (InternalRemoteCache<Object, Object>) remoteCacheManager.getCache();
else
remoteCache = (InternalRemoteCache<Object, Object>) remoteCacheManager.getCache(configuration.remoteCacheName());
return remoteCache.ping();
}, "RemoteStore-start")
.thenCompose(Function.identity())
.thenAccept(pingResponse -> {
String cacheName = ctx.getCache().getName();
MediaType serverKeyStorageType = pingResponse.getKeyMediaType();
MediaType serverValueStorageType = pingResponse.getValueMediaType();
DataFormat.Builder dataFormatBuilder = DataFormat.builder().from(remoteCache.getDataFormat());
Integer numSegments = remoteCache.getCacheTopologyInfo().getNumSegments();
boolean segmentsMatch;
if (numSegments == null) {
log.debugf("Remote Store for cache %s cannot support segmentation as the number of segments was not found from the remote cache", cacheName);
segmentsMatch = false;
} else {
segmentsMatch = numSegments == this.segmentCount;
if (segmentsMatch) {
log.debugf("Remote Store for cache %s can support segmentation as the number of segments matched the remote cache", cacheName);
} else {
log.debugf("Remote Store for cache %s cannot support segmentation as the number of segments %d do not match the remote cache %d",
cacheName, this.segmentCount, numSegments);
}
}
if (!segmentsMatch && configuration.segmented()) {
throw log.segmentationRequiresEqualSegments(this.segmentCount, numSegments);
}
StorageConfigurationManager storageConfigurationManager = ctx.getCache().getAdvancedCache().getComponentRegistry()
.getComponent(StorageConfigurationManager.class);
MediaType localKeyStorageType = storageConfigurationManager.getKeyStorageMediaType();
// When it isn't raw values we store as a Marshalled entry, so we have object storage for the value
MediaType localValueStorageType = configuration.rawValues() ?
storageConfigurationManager.getValueStorageMediaType() : MediaType.APPLICATION_OBJECT;
// Older servers don't provide media type information
if ((serverKeyStorageType == null || serverKeyStorageType.match(MediaType.APPLICATION_UNKNOWN))
&& localKeyStorageType.isBinary()) {
dataFormatBuilder.keyMarshaller(IdentityMarshaller.INSTANCE);
}
if ((serverValueStorageType == null || serverValueStorageType.match(MediaType.APPLICATION_UNKNOWN))
&& localValueStorageType.isBinary()) {
dataFormatBuilder.valueMarshaller(IdentityMarshaller.INSTANCE);
}
supportsSegmentation = localKeyStorageType.equals(serverKeyStorageType);
if (supportsSegmentation) {
dataFormatBuilder.keyType(localKeyStorageType.isBinary() ? localKeyStorageType : marshaller.mediaType());
dataFormatBuilder.keyMarshaller(localKeyStorageType.isBinary() ? IdentityMarshaller.INSTANCE : marshaller);
} else if (configuration.segmented()) {
throw log.segmentationRequiresEqualMediaTypes(localKeyStorageType, serverKeyStorageType);
}
if (localValueStorageType.equals(serverValueStorageType)) {
dataFormatBuilder.valueType(localValueStorageType.isBinary() ? localValueStorageType : marshaller.mediaType());
dataFormatBuilder.valueMarshaller(localValueStorageType.isBinary() ? IdentityMarshaller.INSTANCE : marshaller);
}
DataFormat dataFormat = dataFormatBuilder.build();
if (log.isTraceEnabled()) {
log.tracef("Data format for RemoteStore on cache %s is %s", cacheName, dataFormat);
}
remoteCache = remoteCache.withDataFormat(dataFormat);
});
}
@Override
public Set<Characteristic> characteristics() {
Set<Characteristic> characteristics = EnumSet.of(Characteristic.BULK_READ, Characteristic.EXPIRATION,
Characteristic.SHAREABLE);
if (supportsSegmentation) {
characteristics.add(Characteristic.SEGMENTABLE);
}
return characteristics;
}
@Override
public CompletionStage<Void> stop() {
return blockingManager.runBlocking(() -> {
// when it failed to start
if (remoteCacheManager != null) {
remoteCacheManager.stop();
}
}, "RemoteStore-stop");
}
@Override
public CompletionStage<Boolean> isAvailable() {
if (remoteCache != null) {
return remoteCache.ping()
.handle((v, t) -> t == null && v.isSuccess());
} else {
return CompletableFutures.completedFalse();
}
}
@Override
public CompletionStage<MarshallableEntry<K, V>> load(int segment, Object key) {
if (configuration.rawValues()) {
Object unwrappedKey = unwrap(key);
return remoteCache.getWithMetadataAsync(unwrappedKey).thenApply(metadataValue -> {
if (metadataValue == null) {
return null;
}
Metadata metadata = new EmbeddedMetadata.Builder()
.version(new NumericVersion(metadataValue.getVersion()))
.lifespan(metadataValue.getLifespan(), TimeUnit.SECONDS)
.maxIdle(metadataValue.getMaxIdle(), TimeUnit.SECONDS).build();
long created = metadataValue.getCreated();
long lastUsed = metadataValue.getLastUsed();
Object realValue = wrap(metadataValue.getValue());
return entryFactory.create(key, realValue, metadata, null, created, lastUsed);
});
} else {
Object unwrappedKey = unwrap(key);
return remoteCache.getAsync(unwrappedKey)
.thenApply(value -> {
if(value == null) {
return null;
}
if(value instanceof MarshalledValue) {
return entryFactory.create(key, (MarshalledValue) value);
}
return entryFactory.create(key, value);
});
}
}
@Override
public CompletionStage<Boolean> containsKey(int segment, Object key) {
key = unwrap(key);
return remoteCache.containsKeyAsync(key);
}
@Override
public Flowable<K> publishKeys(IntSet segments, Predicate<? super K> filter) {
// We assume our segments don't map to the remote node when segmentation is disabled
IntSet segmentsToUse = configuration.segmented() ? segments : null;
Flowable<K> keyFlowable = Flowable.fromPublisher(remoteCache.publishEntries(Codec27.EMPTY_VALUE_CONVERTER,
null, segmentsToUse, 512))
.map(Map.Entry::getKey)
.map(RemoteStore::wrap);
if (filter != null) {
keyFlowable = keyFlowable.filter(filter::test);
}
return keyFlowable;
}
@Override
public Publisher<MarshallableEntry<K, V>> publishEntries(IntSet segments, Predicate<? super K> filter, boolean includeValues) {
// We assume our segments don't map to the remote node when segmentation is disabled
IntSet segmentsToUse = configuration.segmented() ? segments : null;
if (configuration.rawValues()) {
Flowable<Map.Entry<Object, MetadataValue<Object>>> entryFlowable = Flowable.fromPublisher(remoteCache.publishEntriesWithMetadata(segmentsToUse, 512));
if (filter != null) {
entryFlowable = entryFlowable.filter(e -> filter.test(wrap(e.getKey())));
}
return entryFlowable.map(e -> {
MetadataValue<Object> value = e.getValue();
Metadata metadata = new EmbeddedMetadata.Builder()
.version(new NumericVersion(value.getVersion()))
.lifespan(value.getLifespan(), TimeUnit.SECONDS)
.maxIdle(value.getMaxIdle(), TimeUnit.SECONDS).build();
long created = value.getCreated();
long lastUsed = value.getLastUsed();
Object realValue = value.getValue();
return entryFactory.create(wrap(e.getKey()), wrap(realValue), metadata, null, created, lastUsed);
});
} else {
Flowable<Map.Entry<Object, Object>> entryFlowable = Flowable.fromPublisher(
remoteCache.publishEntries(null, null, segmentsToUse, 512));
if (filter != null) {
entryFlowable = entryFlowable.filter(e -> filter.test(wrap(e.getKey())));
}
// Technically we will send the metadata and value to the user, no matter what.
return entryFlowable.map(e -> e.getValue() == null ? null : entryFactory.create(wrap(e.getKey()), (MarshalledValue) e.getValue()));
}
}
private static <T> T wrap(Object obj) {
if (obj instanceof byte[]) {
obj = new WrappedByteArray((byte[]) obj);
}
return (T) obj;
}
private static <T> T unwrap(Object obj) {
if (obj instanceof WrappedByteArray) {
return (T) ((WrappedByteArray) obj).getBytes();
}
return (T) obj;
}
@Override
public CompletionStage<Long> size(IntSet segments) {
if (segmentCount == segments.size()) {
return remoteCache.sizeAsync();
}
return publishKeys(segments, null).count().toCompletionStage();
}
@Override
public CompletionStage<Long> approximateSize(IntSet segments) {
// NB. When the server has accurate-size="true", the stats operation computes the accurate size,
// and that makes the operation O(n) instead of O(1).
// Ideally we should skip the stats operation in that case.
return remoteCache.serverStatisticsAsync()
.thenApply(stats -> getApproximateSizeStatistic(stats, segments.size()));
}
private long getApproximateSizeStatistic(ServerStatistics serverStatistics, long segments) {
long serverSize = serverStatistics.getIntStatistic(ServerStatistics.APPROXIMATE_ENTRIES_UNIQUE);
// We assume that entries are uniformly distributed across segments to compute an estimate
return serverSize * segments / segmentCount;
}
@Override
public Publisher<MarshallableEntry<K, V>> purgeExpired() {
// Nothing to do here - expiration is controlled by the server
return Flowable.empty();
}
@Override
public CompletionStage<Void> write(int segment, MarshallableEntry<? extends K, ? extends V> entry) {
if (log.isTraceEnabled()) {
log.tracef("Adding entry: %s", entry);
}
Metadata metadata = entry.getMetadata();
long lifespan = metadata != null ? toSeconds(metadata.lifespan(), entry.getKey(), LIFESPAN) : -1;
long maxIdle = metadata != null ? toSeconds(metadata.maxIdle(), entry.getKey(), MAXIDLE) : -1;
Object key = getKey(entry);
Object value = getValue(entry);
return remoteCache.putAsync(key, value, lifespan, TimeUnit.SECONDS, maxIdle, TimeUnit.SECONDS)
.thenApply(CompletableFutures.toNullFunction());
}
private Object getKey(MarshallableEntry entry) {
return unwrap(entry.getKey());
}
private Object getValue(MarshallableEntry entry) {
if (configuration.rawValues()) {
return unwrap(entry.getValue());
}
return entry.getMarshalledValue();
}
@Override
public CompletionStage<Void> batch(int publisherCount, Publisher<SegmentedPublisher<Object>> removePublisher,
Publisher<SegmentedPublisher<MarshallableEntry<K, V>>> writePublisher) {
Completable removeCompletable = Flowable.fromPublisher(removePublisher)
.flatMap(Flowable::fromPublisher, publisherCount)
.map(RemoteStore::unwrap)
.flatMapCompletable(key -> Completable.fromCompletionStage(remoteCache.removeAsync(key)), false, 10);
int maxBatchSize = configuration.maxBatchSize();
Completable putCompletable = Flowable.fromPublisher(writePublisher)
.flatMap(Flowable::fromPublisher, publisherCount)
.groupBy(MarshallableEntry::getMetadata)
.flatMapCompletable(meFlowable -> meFlowable.buffer(maxBatchSize)
.flatMapCompletable(meList -> {
Map<Object, Object> map = meList.stream().collect(Collectors.toMap(this::getKey, this::getValue));
Metadata metadata = meFlowable.getKey();
long lifespan = metadata != null ? toSeconds(metadata.lifespan(), "batch", LIFESPAN) : -1;
long maxIdle = metadata != null ? toSeconds(metadata.maxIdle(), "batch", MAXIDLE) : -1;
return Completable.fromCompletionStage(remoteCache.putAllAsync(map, lifespan, TimeUnit.SECONDS,
maxIdle, TimeUnit.SECONDS));
}));
return removeCompletable.mergeWith(putCompletable)
.toCompletionStage(null);
}
@Override
public CompletionStage<Void> clear() {
if (remoteCache != null) {
return remoteCache.clearAsync();
} else {
return CompletableFutures.completedNull();
}
}
@Override
public CompletionStage<Boolean> delete(int segment, Object key) {
key = unwrap(key);
return remoteCache.removeAsync(key)
.thenApply(v -> null);
}
private long toSeconds(long millis, Object key, String desc) {
if (millis > 0 && millis < 1000) {
if (log.isTraceEnabled()) {
log.tracef("Adjusting %s time for key %s from %d millis to 1 sec, as milliseconds are not supported by HotRod",
desc, key, millis);
}
return 1;
}
return TimeUnit.MILLISECONDS.toSeconds(millis);
}
public void setInternalCacheEntryFactory(InternalEntryFactory iceFactory) {
if (this.iceFactory != null) {
throw new IllegalStateException();
}
this.iceFactory = iceFactory;
}
public RemoteCache<Object, Object> getRemoteCache() {
return remoteCache;
}
private ConfigurationBuilder buildRemoteConfiguration(RemoteStoreConfiguration configuration, Marshaller marshaller) {
ConfigurationBuilder builder = (configuration.uri() != null
&& !configuration.uri().isEmpty())
? HotRodURI.create(configuration.uri()).toConfigurationBuilder()
: new ConfigurationBuilder();
List<RemoteServerConfiguration> servers = configuration.servers();
for (RemoteServerConfiguration s : servers) {
builder.addServer()
.host(s.host())
.port(s.port());
}
ConnectionPoolConfiguration poolConfiguration = configuration.connectionPool();
Long connectionTimeout = configuration.connectionTimeout();
Long socketTimeout = configuration.socketTimeout();
builder.classLoader(configuration.getClass().getClassLoader())
.balancingStrategy(configuration.balancingStrategy())
.connectionPool()
.exhaustedAction(ExhaustedAction.valueOf(poolConfiguration.exhaustedAction().toString()))
.maxActive(poolConfiguration.maxActive())
.minIdle(poolConfiguration.minIdle())
.minEvictableIdleTime(poolConfiguration.minEvictableIdleTime())
.connectionTimeout(connectionTimeout.intValue())
.forceReturnValues(configuration.forceReturnValues())
.keySizeEstimate(configuration.keySizeEstimate())
.marshaller(marshaller)
.asyncExecutorFactory().factoryClass(configuration.asyncExecutorFactory().factory().getClass())
.asyncExecutorFactory().withExecutorProperties(configuration.asyncExecutorFactory().properties())
.socketTimeout(socketTimeout.intValue())
.tcpNoDelay(configuration.tcpNoDelay())
.valueSizeEstimate(configuration.valueSizeEstimate())
.version(configuration.protocol() == null ? ProtocolVersion.DEFAULT_PROTOCOL_VERSION : configuration.protocol());
SslConfiguration ssl = configuration.security().ssl();
if (ssl.enabled()) {
builder.security().ssl()
.enable()
.keyStoreType(ssl.keyStoreType())
.keyAlias(ssl.keyAlias())
.keyStoreFileName(ssl.keyStoreFileName())
.keyStorePassword(ssl.keyStorePassword())
.keyStoreCertificatePassword(ssl.keyStoreCertificatePassword())
.trustStoreFileName(ssl.trustStoreFileName())
.trustStorePassword(ssl.trustStorePassword())
.trustStoreType(ssl.trustStoreType())
.protocol(ssl.protocol())
.sniHostName(ssl.sniHostName());
}
AuthenticationConfiguration auth = configuration.security().authentication();
if (auth.enabled()) {
builder.security().authentication()
.enable()
.callbackHandler(auth.callbackHandler())
.clientSubject(auth.clientSubject())
.saslMechanism(auth.saslMechanism())
.serverName(auth.serverName())
.saslProperties(auth.saslProperties())
.username(auth.username())
.password(auth.password())
.realm(auth.realm())
;
}
Properties propertiesToUse;
Properties actualProperties = configuration.properties();
if (!actualProperties.contains("blocking")) {
// Need to make a copy to not change the actual configuration properties
propertiesToUse = new Properties(actualProperties);
// Make sure threads are marked as non blocking if user didn't specify
propertiesToUse.put("blocking", "false");
} else {
propertiesToUse = actualProperties;
}
builder.withProperties(propertiesToUse);
return builder;
}
public RemoteStoreConfiguration getConfiguration() {
return configuration;
}
@Override
public boolean ignoreCommandWithFlags(long commandFlags) {
return EnumUtil.containsAny(FlagBitSets.ROLLING_UPGRADE, commandFlags);
}
@Override
public CompletionStage<Void> addSegments(IntSet segments) {
// Here for documentation purposes. This method should never be invoked as we only support segmented when shared
return NonBlockingStore.super.addSegments(segments);
}
@Override
public CompletionStage<Void> removeSegments(IntSet segments) {
// Here for documentation purposes. This method should never be invoked as we only support segmented when shared
return NonBlockingStore.super.removeSegments(segments);
}
}
| 25,152
| 45.322284
| 161
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/TrustStoreConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
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.Util;
public class TrustStoreConfiguration extends ConfigurationElement<TrustStoreConfiguration> {
static final AttributeDefinition<String> TRUSTSTORE_FILENAME = AttributeDefinition.builder(Attribute.FILENAME, null, String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> TRUSTSTORE_TYPE = AttributeDefinition.builder(Attribute.TYPE, "JKS", String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> TRUSTSTORE_PASSWORD = AttributeDefinition.builder(Attribute.PASSWORD, null, String.class).immutable().autoPersist(false).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(TrustStoreConfiguration.class, TRUSTSTORE_FILENAME, TRUSTSTORE_TYPE, TRUSTSTORE_PASSWORD);
}
TrustStoreConfiguration(AttributeSet attributes) {
super(Element.TRUSTSTORE, attributes);
}
public String trustStoreFileName() {
return attributes.attribute(TRUSTSTORE_FILENAME).get();
}
public String trustStoreType() {
return attributes.attribute(TRUSTSTORE_TYPE).get();
}
public char[] trustStorePassword() {
return Util.toCharArray(attributes.attribute(TRUSTSTORE_PASSWORD).get());
}
}
| 1,549
| 44.588235
| 173
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/package-info.java
|
/**
* Configuration for {@link org.infinispan.persistence.remote.RemoteStore}.
*
* @api.public
*/
package org.infinispan.persistence.remote.configuration;
| 159
| 21.857143
| 75
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/SecurityConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* SecurityConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 9.1
*/
public class SecurityConfigurationBuilder extends AbstractRemoteStoreConfigurationChildBuilder implements
Builder<SecurityConfiguration> {
private final AuthenticationConfigurationBuilder authentication = new AuthenticationConfigurationBuilder(this);
private final SslConfigurationBuilder ssl = new SslConfigurationBuilder(this);
SecurityConfigurationBuilder(RemoteStoreConfigurationBuilder builder) {
super(builder, null);
}
public AuthenticationConfigurationBuilder authentication() {
return authentication;
}
public SslConfigurationBuilder ssl() {
return ssl;
}
@Override
public SecurityConfiguration create() {
return new SecurityConfiguration(authentication.create(), ssl.create());
}
@Override
public Builder<?> read(SecurityConfiguration template, Combine combine) {
authentication.read(template.authentication(), combine);
ssl.read(template.ssl(), combine);
return this;
}
public AttributeSet attributes() {
return attributes;
}
@Override
public void validate() {
authentication.validate();
ssl.validate();
}
@Override
public String toString() {
return "SecurityConfigurationBuilder{" +
"authentication=" + authentication +
", ssl=" + ssl +
'}';
}
}
| 1,660
| 26.229508
| 114
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/SslConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import javax.net.ssl.SSLContext;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
/**
* SslConfiguration.
*
* @author Tristan Tarrant
* @since 9.1
*/
public class SslConfiguration extends ConfigurationElement<SslConfiguration> {
static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder("enabled", false, Boolean.class).immutable().autoPersist(false).build();
static final AttributeDefinition<SSLContext> SSL_CONTEXT = AttributeDefinition.builder("sslContext", null, SSLContext.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> SNI_HOSTNAME = AttributeDefinition.builder("sniHostname", null, String.class).immutable().build();
static final AttributeDefinition<String> PROTOCOL = AttributeDefinition.builder("protocol", null, String.class).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(SslConfiguration.class, ENABLED, SNI_HOSTNAME, PROTOCOL);
}
private final KeyStoreConfiguration keyStoreConfiguration;
private final TrustStoreConfiguration trustStoreConfiguration;
SslConfiguration(AttributeSet attributes, KeyStoreConfiguration keyStoreConfiguration, TrustStoreConfiguration trustStoreConfiguration) {
super(Element.ENCRYPTION, attributes, keyStoreConfiguration, trustStoreConfiguration);
this.keyStoreConfiguration = keyStoreConfiguration;
this.trustStoreConfiguration = trustStoreConfiguration;
}
public KeyStoreConfiguration keyStoreConfiguration() {
return keyStoreConfiguration;
}
public TrustStoreConfiguration trustStoreConfiguration() {
return trustStoreConfiguration;
}
public boolean enabled() {
return attributes.attribute(ENABLED).get();
}
public String keyStoreFileName() {
return keyStoreConfiguration.keyStoreFileName();
}
public String keyStoreType() {
return keyStoreConfiguration.keyStoreType();
}
public char[] keyStorePassword() {
return keyStoreConfiguration.keyStorePassword();
}
public char[] keyStoreCertificatePassword() {
return keyStoreConfiguration.keyStoreCertificatePassword();
}
public String keyAlias() {
return keyStoreConfiguration.keyAlias();
}
public SSLContext sslContext() {
return attributes.attribute(SSL_CONTEXT).get();
}
public String trustStoreFileName() {
return trustStoreConfiguration.trustStoreFileName();
}
public String trustStoreType() {
return trustStoreConfiguration.trustStoreType();
}
public char[] trustStorePassword() {
return trustStoreConfiguration.trustStorePassword();
}
public String sniHostName() {
return attributes.attribute(SNI_HOSTNAME).get();
}
public String protocol() {
return attributes.attribute(PROTOCOL).get();
}
}
| 3,074
| 33.166667
| 167
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/SslConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.SslConfiguration.ENABLED;
import static org.infinispan.persistence.remote.configuration.SslConfiguration.PROTOCOL;
import static org.infinispan.persistence.remote.configuration.SslConfiguration.SNI_HOSTNAME;
import static org.infinispan.persistence.remote.configuration.SslConfiguration.SSL_CONTEXT;
import java.util.List;
import javax.net.ssl.SSLContext;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
*
* SSLConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 9.1
*/
public class SslConfigurationBuilder extends AbstractSecurityConfigurationChildBuilder implements Builder<SslConfiguration> {
private KeyStoreConfigurationBuilder keyStoreConfigurationBuilder;
private TrustStoreConfigurationBuilder trustStoreConfigurationBuilder;
SslConfigurationBuilder(SecurityConfigurationBuilder builder) {
super(builder, SslConfiguration.attributeDefinitionSet());
this.keyStoreConfigurationBuilder = new KeyStoreConfigurationBuilder(builder);
this.trustStoreConfigurationBuilder = new TrustStoreConfigurationBuilder(builder);
}
public AttributeSet attributes() {
return attributes;
}
/**
* Disables the SSL support
*/
public SslConfigurationBuilder disable() {
this.attributes.attribute(ENABLED).set(false);
return this;
}
/**
* Enables the SSL support
*/
public SslConfigurationBuilder enable() {
this.attributes.attribute(ENABLED).set(true);
return this;
}
/**
* Enables or disables the SSL support
*/
public SslConfigurationBuilder enabled(boolean enabled) {
this.attributes.attribute(ENABLED).set(enabled);
return this;
}
/**
* Specifies the filename of a keystore to use to create the {@link SSLContext} You also need to
* specify a {@link #keyStorePassword(char[])}. Alternatively specify an initialized {@link #sslContext(SSLContext)}
*/
public SslConfigurationBuilder keyStoreFileName(String keyStoreFileName) {
keyStoreConfigurationBuilder.keyStoreFileName(keyStoreFileName);
return this;
}
/**
* Specifies the type of the keystore, such as JKS or JCEKS. Defaults to JKS
*/
public SslConfigurationBuilder keyStoreType(String keyStoreType) {
keyStoreConfigurationBuilder.keyStoreType(keyStoreType);
return this;
}
/**
* Specifies the password needed to open the keystore You also need to specify a
* {@link #keyStoreFileName(String)}. Alternatively specify an initialized {@link #sslContext(SSLContext)}
*/
public SslConfigurationBuilder keyStorePassword(char[] keyStorePassword) {
keyStoreConfigurationBuilder.keyStorePassword(keyStorePassword);
return this;
}
/**
* Specifies the password needed to access private key associated with certificate stored in specified
* {@link #keyStoreFileName(String)}. If password is not specified, password provided in
* {@link #keyStorePassword(char[])} will be used.
*/
public SslConfigurationBuilder keyStoreCertificatePassword(char[] keyStoreCertificatePassword) {
keyStoreConfigurationBuilder.keyStoreCertificatePassword(keyStoreCertificatePassword);
return this;
}
public SslConfigurationBuilder keyAlias(String keyAlias) {
keyStoreConfigurationBuilder.keyAlias(keyAlias);
return this;
}
public SslConfigurationBuilder sslContext(SSLContext sslContext) {
this.attributes.attribute(SSL_CONTEXT).set(sslContext);
return this;
}
/**
* Specifies the filename of a truststore to use to create the {@link SSLContext} You also need
* to specify a {@link #trustStorePassword(char[])}. Alternatively specify an initialized {@link #sslContext(SSLContext)}
*/
public SslConfigurationBuilder trustStoreFileName(String trustStoreFileName) {
trustStoreConfigurationBuilder.trustStoreFileName(trustStoreFileName);
return this;
}
/**
* Specifies the type of the truststore, such as JKS or JCEKS. Defaults to JKS
*/
public SslConfigurationBuilder trustStoreType(String trustStoreType) {
trustStoreConfigurationBuilder.trustStoreType(trustStoreType);
return this;
}
/**
* Specifies the password needed to open the truststore You also need to specify a
* {@link #trustStoreFileName(String)}. Alternatively specify an initialized {@link #sslContext(SSLContext)}
*/
public SslConfigurationBuilder trustStorePassword(char[] trustStorePassword) {
trustStoreConfigurationBuilder.trustStorePassword(trustStorePassword);
return this;
}
/**
* Specifies the TLS SNI hostname for the connection
* @see javax.net.ssl.SSLParameters#setServerNames(List)
*/
public SslConfigurationBuilder sniHostName(String sniHostName) {
this.attributes.attribute(SNI_HOSTNAME).set(sniHostName);
return this;
}
/**
* Configures the secure socket protocol.
*
* @see SSLContext#getInstance(String)
* @param protocol The standard name of the requested protocol, e.g TLSv1.2
*/
public SslConfigurationBuilder protocol(String protocol) {
this.attributes.attribute(PROTOCOL).set(protocol);
return this;
}
@Override
public void validate() {
// validation will be performed by the RemoteCacheManager configuration builder
}
@Override
public SslConfiguration create() {
return new SslConfiguration(attributes.protect(), keyStoreConfigurationBuilder.create(), trustStoreConfigurationBuilder.create());
}
@Override
public SslConfigurationBuilder read(SslConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.keyStoreConfigurationBuilder.read(template.keyStoreConfiguration(), combine);
this.trustStoreConfigurationBuilder.read(template.trustStoreConfiguration(), combine);
return this;
}
}
| 6,140
| 34.912281
| 136
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/Element.java
|
package org.infinispan.persistence.remote.configuration;
import java.util.HashMap;
import java.util.Map;
/**
* An enumeration of all the recognized XML element local names for the
* {@link org.infinispan.persistence.remote.RemoteStore}
*
* @author Tristan Tarrant
* @since 5.2
*/
public enum Element {
// must be first
UNKNOWN(null),
ASYNC_TRANSPORT_EXECUTOR("async-executor"),
AUTHENTICATION("authentication"),
AUTH_PLAIN("plain"),
AUTH_DIGEST("digest"),
AUTH_EXTERNAL("external"),
CACHE("cache"),
CONNECTION_POOL("connection-pool"),
ENCRYPTION("encryption"),
KEYSTORE("keystore"),
PROPERTIES("properties"),
REMOTE_STORE("remote-store"),
SECURITY("security"),
SERVERS("servers"),
REMOTE_SERVER("remote-server"),
TRUSTSTORE("truststore"),
;
private final String name;
Element(final String name) {
this.name = name;
}
/**
* Get the local name of this element.
*
* @return the local name
*/
public String getLocalName() {
return name;
}
private static final Map<String, Element> MAP;
static {
final Map<String, Element> map = new HashMap<String, Element>(8);
for (Element element : values()) {
final String name = element.getLocalName();
if (name != null) {
map.put(name, element);
}
}
MAP = map;
}
public static Element forName(final String localName) {
final Element element = MAP.get(localName);
return element == null ? UNKNOWN : element;
}
@Override
public String toString() {
return name;
}
}
| 1,619
| 21.191781
| 71
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/AbstractSecurityConfigurationChildBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* AbstractSecurityConfigurationChildBuilder.
*
* @author Tristan Tarrant
* @since 9.1
*/
public class AbstractSecurityConfigurationChildBuilder extends AbstractRemoteStoreConfigurationChildBuilder {
final SecurityConfigurationBuilder builder;
AbstractSecurityConfigurationChildBuilder(SecurityConfigurationBuilder builder, AttributeSet attributes) {
super(builder.getRemoteStoreBuilder(), attributes);
this.builder = builder;
}
public AuthenticationConfigurationBuilder authentication() {
return builder.authentication();
}
public SslConfigurationBuilder ssl() {
return builder.ssl();
}
}
| 774
| 27.703704
| 109
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/KeyStoreConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.KeyStoreConfiguration.KEYSTORE_CERTIFICATE_PASSWORD;
import static org.infinispan.persistence.remote.configuration.KeyStoreConfiguration.KEYSTORE_FILENAME;
import static org.infinispan.persistence.remote.configuration.KeyStoreConfiguration.KEYSTORE_PASSWORD;
import static org.infinispan.persistence.remote.configuration.KeyStoreConfiguration.KEYSTORE_TYPE;
import static org.infinispan.persistence.remote.configuration.KeyStoreConfiguration.KEY_ALIAS;
import org.infinispan.client.hotrod.logging.Log;
import org.infinispan.client.hotrod.logging.LogFactory;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class KeyStoreConfigurationBuilder extends AbstractSecurityConfigurationChildBuilder implements Builder<KeyStoreConfiguration> {
private static final Log log = LogFactory.getLog(KeyStoreConfigurationBuilder.class);
protected KeyStoreConfigurationBuilder(SecurityConfigurationBuilder builder) {
super(builder, KeyStoreConfiguration.attributeDefinitionSet());
}
public AttributeSet attributes() {
return attributes;
}
public KeyStoreConfigurationBuilder keyStoreFileName(String keyStoreFileName) {
this.attributes.attribute(KEYSTORE_FILENAME).set(keyStoreFileName);
return this;
}
public KeyStoreConfigurationBuilder keyStoreType(String keyStoreType) {
this.attributes.attribute(KEYSTORE_TYPE).set(keyStoreType);
return this;
}
public KeyStoreConfigurationBuilder keyStorePassword(char[] keyStorePassword) {
this.attributes.attribute(KEYSTORE_PASSWORD).set(new String(keyStorePassword));
return this;
}
public KeyStoreConfigurationBuilder keyStoreCertificatePassword(char[] keyStoreCertificatePassword) {
this.attributes.attribute(KEYSTORE_CERTIFICATE_PASSWORD).set(new String(keyStoreCertificatePassword));
return this;
}
public KeyStoreConfigurationBuilder keyAlias(String keyAlias) {
this.attributes.attribute(KEY_ALIAS).set(keyAlias);
return this;
}
@Override
public KeyStoreConfiguration create() {
return new KeyStoreConfiguration(attributes.protect());
}
@Override
public KeyStoreConfigurationBuilder read(KeyStoreConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
}
| 2,580
| 38.707692
| 135
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/RemoteStoreConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import java.util.List;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.impl.ConfigurationProperties;
import org.infinispan.client.hotrod.impl.transport.tcp.RoundRobinBalancingStrategy;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.ConfigurationFor;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.cache.AbstractStoreConfiguration;
import org.infinispan.configuration.cache.AsyncStoreConfiguration;
import org.infinispan.configuration.serializing.SerializedWith;
import org.infinispan.persistence.remote.RemoteStore;
@BuiltBy(RemoteStoreConfigurationBuilder.class)
@ConfigurationFor(RemoteStore.class)
@SerializedWith(RemoteStoreConfigurationSerializer.class)
public class RemoteStoreConfiguration extends AbstractStoreConfiguration<RemoteStoreConfiguration> {
static final AttributeDefinition<String> BALANCING_STRATEGY = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.BALANCING_STRATEGY, RoundRobinBalancingStrategy.class.getName()).immutable().build();
static final AttributeDefinition<Long> CONNECTION_TIMEOUT = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.CONNECT_TIMEOUT, (long) ConfigurationProperties.DEFAULT_CONNECT_TIMEOUT).build();
static final AttributeDefinition<Boolean> FORCE_RETURN_VALUES = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.FORCE_RETURN_VALUES, false).immutable().build();
static final AttributeDefinition<Boolean> HOTROD_WRAPPING = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.HOTROD_WRAPPING, false).immutable().build();
static final AttributeDefinition<Boolean> RAW_VALUES = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.RAW_VALUES, false).immutable().build();
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
static final AttributeDefinition<Integer> KEY_SIZE_ESTIMATE = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.KEY_SIZE_ESTIMATE, ConfigurationProperties.DEFAULT_KEY_SIZE).immutable().build();
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
static final AttributeDefinition<Integer> VALUE_SIZE_ESTIMATE = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.VALUE_SIZE_ESTIMATE, ConfigurationProperties.DEFAULT_VALUE_SIZE).immutable().build();
static final AttributeDefinition<String> MARSHALLER = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.MARSHALLER, null, String.class).immutable().build();
static final AttributeDefinition<ProtocolVersion> PROTOCOL_VERSION = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.PROTOCOL_VERSION, ProtocolVersion.DEFAULT_PROTOCOL_VERSION)
.immutable().build();
static final AttributeDefinition<String> REMOTE_CACHE_NAME = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.REMOTE_CACHE_NAME, "").immutable().build();
static final AttributeDefinition<String> URI = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.URI, null, String.class).immutable()
.build();
static final AttributeDefinition<Long> SOCKET_TIMEOUT = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.SOCKET_TIMEOUT, (long) ConfigurationProperties.DEFAULT_SO_TIMEOUT).build();
static final AttributeDefinition<Boolean> TCP_NO_DELAY = AttributeDefinition.builder(org.infinispan.persistence.remote.configuration.Attribute.TCP_NO_DELAY, true).build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RemoteStoreConfiguration.class, AbstractStoreConfiguration.attributeDefinitionSet(), BALANCING_STRATEGY, CONNECTION_TIMEOUT, FORCE_RETURN_VALUES,
HOTROD_WRAPPING, RAW_VALUES, KEY_SIZE_ESTIMATE, MARSHALLER, PROTOCOL_VERSION, REMOTE_CACHE_NAME, SOCKET_TIMEOUT, TCP_NO_DELAY, VALUE_SIZE_ESTIMATE, URI);
}
private final Attribute<String> balancingStrategy;
private final Attribute<Long> connectionTimeout;
private final Attribute<Boolean> forceReturnValues;
private final Attribute<Boolean> hotRodWrapping;
private final Attribute<Boolean> rawValues;
private final Attribute<Integer> keySizeEstimate;
private final Attribute<Integer> valueSizeEstimate;
private final Attribute<String> marshaller;
private final Attribute<ProtocolVersion> protocolVersion;
private final Attribute<String> remoteCacheName;
private final Attribute<String> uri;
private final Attribute<Long> socketTimeout;
private final Attribute<Boolean> tcpNoDelay;
private final ConnectionPoolConfiguration connectionPool;
private final ExecutorFactoryConfiguration asyncExecutorFactory;
private final SecurityConfiguration security;
private List<RemoteServerConfiguration> servers;
public RemoteStoreConfiguration(AttributeSet attributes, AsyncStoreConfiguration async,
ExecutorFactoryConfiguration asyncExecutorFactory, ConnectionPoolConfiguration connectionPool,
SecurityConfiguration security, List<RemoteServerConfiguration> servers) {
super(Element.REMOTE_STORE, attributes, async);
balancingStrategy = attributes.attribute(BALANCING_STRATEGY);
connectionTimeout = attributes.attribute(CONNECTION_TIMEOUT);
forceReturnValues = attributes.attribute(FORCE_RETURN_VALUES);
hotRodWrapping = attributes.attribute(HOTROD_WRAPPING);
rawValues = attributes.attribute(RAW_VALUES);
keySizeEstimate = attributes.attribute(KEY_SIZE_ESTIMATE);
valueSizeEstimate = attributes.attribute(VALUE_SIZE_ESTIMATE);
marshaller = attributes.attribute(MARSHALLER);
protocolVersion = attributes.attribute(PROTOCOL_VERSION);
remoteCacheName = attributes.attribute(REMOTE_CACHE_NAME);
uri = attributes.attribute(URI);
socketTimeout = attributes.attribute(SOCKET_TIMEOUT);
tcpNoDelay = attributes.attribute(TCP_NO_DELAY);
this.asyncExecutorFactory = asyncExecutorFactory;
this.connectionPool = connectionPool;
this.security = security;
this.servers = servers;
}
public String uri() {
return uri.get();
}
public ExecutorFactoryConfiguration asyncExecutorFactory() {
return asyncExecutorFactory;
}
public String balancingStrategy() {
return balancingStrategy.get();
}
public ConnectionPoolConfiguration connectionPool() {
return connectionPool;
}
public long connectionTimeout() {
return connectionTimeout.get();
}
public boolean forceReturnValues() {
return forceReturnValues.get();
}
/**
* @deprecated since 12.0 - Automatic media type detection in remote store makes this option redundant
*/
@Deprecated
public boolean hotRodWrapping() {
return hotRodWrapping.get();
}
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
public int keySizeEstimate() {
return keySizeEstimate.get();
}
public String marshaller() {
return marshaller.get();
}
public ProtocolVersion protocol() {
return protocolVersion.get();
}
/**
* @deprecated since 12.0 - This option can still be needed when retrieving from a preexisting remote cache
*/
@Deprecated
public boolean rawValues() {
return rawValues.get();
}
public String remoteCacheName() {
return remoteCacheName.get();
}
public List<RemoteServerConfiguration> servers() {
return servers;
}
public long socketTimeout() {
return socketTimeout.get();
}
public boolean tcpNoDelay() {
return tcpNoDelay.get();
}
/**
* @deprecated since 10.0. This method always returns null
*/
@Deprecated
public String transportFactory() {
return null;
}
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
public int valueSizeEstimate() {
return valueSizeEstimate.get();
}
public SecurityConfiguration security() {
return security;
}
}
| 8,663
| 45.580645
| 238
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/AuthenticationConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.AuthenticationConfiguration.CALLBACK_HANDLER;
import static org.infinispan.persistence.remote.configuration.AuthenticationConfiguration.CLIENT_SUBJECT;
import static org.infinispan.persistence.remote.configuration.AuthenticationConfiguration.ENABLED;
import static org.infinispan.persistence.remote.configuration.AuthenticationConfiguration.SASL_PROPERTIES;
import static org.infinispan.persistence.remote.configuration.AuthenticationConfiguration.SERVER_NAME;
import java.util.Map;
import javax.security.auth.Subject;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* AuthenticationConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 9.1
*/
public class AuthenticationConfigurationBuilder extends AbstractSecurityConfigurationChildBuilder implements Builder<AuthenticationConfiguration> {
private MechanismConfigurationBuilder mechanismConfigurationBuilder;
public AuthenticationConfigurationBuilder(SecurityConfigurationBuilder builder) {
super(builder, AuthenticationConfiguration.attributeDefinitionSet());
this.mechanismConfigurationBuilder = new MechanismConfigurationBuilder(builder);
}
public AttributeSet attributes() {
return attributes;
}
/**
* Specifies a {@link CallbackHandler} to be used during the authentication handshake.
* The {@link Callback}s that need to be handled are specific to the chosen SASL mechanism.
*/
public AuthenticationConfigurationBuilder callbackHandler(CallbackHandler callbackHandler) {
this.attributes.attribute(CALLBACK_HANDLER).set(callbackHandler);
return this;
}
/**
* Configures whether authentication should be enabled or not
*/
public AuthenticationConfigurationBuilder enabled(boolean enabled) {
this.attributes.attribute(ENABLED).set(enabled);
return this;
}
/**
* Enables authentication
*/
public AuthenticationConfigurationBuilder enable() {
return enabled(true);
}
/**
* Disables authentication
*/
public AuthenticationConfigurationBuilder disable() {
return enabled(false);
}
/**
* Selects the SASL mechanism to use for the connection to the server
*/
public AuthenticationConfigurationBuilder saslMechanism(String saslMechanism) {
mechanismConfigurationBuilder.saslMechanism(saslMechanism);
return this;
}
/**
* Sets the SASL properties
*/
public AuthenticationConfigurationBuilder saslProperties(Map<String, String> saslProperties) {
this.attributes.attribute(SASL_PROPERTIES).set(saslProperties);
return this;
}
/**
* Sets the name of the server as expected by the SASL protocol
*/
public AuthenticationConfigurationBuilder serverName(String serverName) {
this.attributes.attribute(SERVER_NAME).set(serverName);
return this;
}
/**
* Sets the client subject, necessary for those SASL mechanisms which require it to access client credentials (i.e. GSSAPI)
*/
public AuthenticationConfigurationBuilder clientSubject(Subject clientSubject) {
this.attributes.attribute(CLIENT_SUBJECT).set(clientSubject);
return this;
}
/**
* Specifies the username to be used for authentication. This will use a simple CallbackHandler.
* This is mutually exclusive with explicitly providing the CallbackHandler
*/
public AuthenticationConfigurationBuilder username(String username) {
this.mechanismConfigurationBuilder.username(username);
return this;
}
/**
* Specifies the password to be used for authentication. A username is also required
*/
public AuthenticationConfigurationBuilder password(String password) {
this.mechanismConfigurationBuilder.password(password);
return this;
}
/**
* Specifies the password to be used for authentication. A username is also required
*/
public AuthenticationConfigurationBuilder password(char[] password) {
this.password(new String(password));
return this;
}
/**
* Specifies the realm to be used for authentication. Username and password also need to be supplied.
*/
public AuthenticationConfigurationBuilder realm(String realm) {
this.mechanismConfigurationBuilder.realm(realm);
return this;
}
@Override
public AuthenticationConfiguration create() {
return new AuthenticationConfiguration(attributes.protect(), mechanismConfigurationBuilder.create());
}
@Override
public Builder<?> read(AuthenticationConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.mechanismConfigurationBuilder.read(template.mechanismConfiguration(), combine);
return this;
}
@Override
public void validate() {
// Delegate validation to the RemoteCacheManager configuration
}
}
| 5,193
| 33.626667
| 147
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/RemoteServerConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
public class RemoteServerConfiguration extends ConfigurationElement<RemoteServerConfiguration> {
static final AttributeDefinition<String> HOST = AttributeDefinition.builder(Attribute.HOST, null, String.class).immutable().build();
static final AttributeDefinition<Integer> PORT = AttributeDefinition.builder(Attribute.PORT, 11222).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RemoteServerConfiguration.class, HOST, PORT);
}
RemoteServerConfiguration(AttributeSet attributes) {
super(Element.REMOTE_SERVER, attributes);
}
public String host() {
return attributes.attribute(HOST).get();
}
public int port() {
return attributes.attribute(PORT).get();
}
}
| 1,038
| 36.107143
| 135
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/SecurityConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
/**
* SecurityConfiguration.
*
* @author Tristan Tarrant
* @since 9.1
*/
public class SecurityConfiguration extends ConfigurationElement<SecurityConfiguration> {
private final AuthenticationConfiguration authentication;
private final SslConfiguration ssl;
SecurityConfiguration(AuthenticationConfiguration authentication, SslConfiguration ssl) {
super(Element.SECURITY, AttributeSet.EMPTY, authentication, ssl);
this.authentication = authentication;
this.ssl = ssl;
}
public AuthenticationConfiguration authentication() {
return authentication;
}
public SslConfiguration ssl() {
return ssl;
}
}
| 863
| 26.870968
| 92
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/RemoteStoreConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.configuration.cache.AbstractStoreConfiguration.SEGMENTED;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.BALANCING_STRATEGY;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.CONNECTION_TIMEOUT;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.FORCE_RETURN_VALUES;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.HOTROD_WRAPPING;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.KEY_SIZE_ESTIMATE;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.MARSHALLER;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.PROTOCOL_VERSION;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.RAW_VALUES;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.REMOTE_CACHE_NAME;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.SOCKET_TIMEOUT;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.TCP_NO_DELAY;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.URI;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration.VALUE_SIZE_ESTIMATE;
import static org.infinispan.persistence.remote.logging.Log.CONFIG;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.impl.transport.netty.ChannelFactory;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.configuration.cache.AbstractStoreConfigurationBuilder;
import org.infinispan.configuration.cache.PersistenceConfigurationBuilder;
/**
* RemoteStoreConfigurationBuilder. Configures a
* {@link org.infinispan.persistence.remote.RemoteStore}
*
* @author Tristan Tarrant
* @since 5.2
*/
public class RemoteStoreConfigurationBuilder extends AbstractStoreConfigurationBuilder<RemoteStoreConfiguration, RemoteStoreConfigurationBuilder> implements
RemoteStoreConfigurationChildBuilder<RemoteStoreConfigurationBuilder> {
private final ExecutorFactoryConfigurationBuilder asyncExecutorFactory;
private final ConnectionPoolConfigurationBuilder connectionPool;
private final SecurityConfigurationBuilder security;
private List<RemoteServerConfigurationBuilder> servers = new ArrayList<RemoteServerConfigurationBuilder>();
public RemoteStoreConfigurationBuilder(PersistenceConfigurationBuilder builder) {
super(builder, RemoteStoreConfiguration.attributeDefinitionSet());
asyncExecutorFactory = new ExecutorFactoryConfigurationBuilder(this);
connectionPool = new ConnectionPoolConfigurationBuilder(this);
security = new SecurityConfigurationBuilder(this);
}
@Override
public RemoteStoreConfigurationBuilder self() {
return this;
}
@Override
public AttributeSet attributes() {
return attributes;
}
public ExecutorFactoryConfigurationBuilder asyncExecutorFactory() {
return asyncExecutorFactory;
}
@Override
public RemoteStoreConfigurationBuilder balancingStrategy(String balancingStrategy) {
attributes.attribute(BALANCING_STRATEGY).set(balancingStrategy);
return this;
}
@Override
public ConnectionPoolConfigurationBuilder connectionPool() {
return connectionPool;
}
@Override
public RemoteStoreConfigurationBuilder connectionTimeout(long connectionTimeout) {
attributes.attribute(CONNECTION_TIMEOUT).set(connectionTimeout);
return this;
}
@Override
public RemoteStoreConfigurationBuilder forceReturnValues(boolean forceReturnValues) {
attributes.attribute(FORCE_RETURN_VALUES).set(forceReturnValues);
return this;
}
@Deprecated
@Override
public RemoteStoreConfigurationBuilder hotRodWrapping(boolean hotRodWrapping) {
attributes.attribute(HOTROD_WRAPPING).set(hotRodWrapping);
this.rawValues(true);
return this;
}
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
@Override
public RemoteStoreConfigurationBuilder keySizeEstimate(int keySizeEstimate) {
attributes.attribute(KEY_SIZE_ESTIMATE).set(keySizeEstimate);
return this;
}
@Override
public RemoteStoreConfigurationBuilder marshaller(String marshaller) {
attributes.attribute(MARSHALLER).set(marshaller);
return this;
}
@Override
public RemoteStoreConfigurationBuilder marshaller(Class<? extends Marshaller> marshaller) {
marshaller(marshaller.getName());
return this;
}
@Override
public RemoteStoreConfigurationBuilder protocolVersion(ProtocolVersion protocolVersion) {
attributes.attribute(PROTOCOL_VERSION).set(protocolVersion);
return this;
}
@Deprecated
@Override
public RemoteStoreConfigurationBuilder rawValues(boolean rawValues) {
attributes.attribute(RAW_VALUES).set(rawValues);
return this;
}
@Override
public RemoteStoreConfigurationBuilder remoteCacheName(String remoteCacheName) {
attributes.attribute(REMOTE_CACHE_NAME).set(remoteCacheName);
return this;
}
public RemoteStoreConfigurationBuilder uri(String uri) {
attributes.attribute(URI).set(uri);
return this;
}
@Override
public SecurityConfigurationBuilder remoteSecurity() {
return this.security;
}
@Override
public RemoteStoreConfigurationBuilder socketTimeout(long socketTimeout) {
attributes.attribute(SOCKET_TIMEOUT).set(socketTimeout);
return this;
}
@Override
public RemoteStoreConfigurationBuilder tcpNoDelay(boolean tcpNoDelay) {
attributes.attribute(TCP_NO_DELAY).set(tcpNoDelay);
return this;
}
@Override
public RemoteStoreConfigurationBuilder transportFactory(String transportFactory) {
return this;
}
@Override
public RemoteStoreConfigurationBuilder transportFactory(Class<? extends ChannelFactory> transportFactory) {
transportFactory(transportFactory.getName());
return this;
}
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
public RemoteStoreConfigurationBuilder valueSizeEstimate(int valueSizeEstimate) {
attributes.attribute(VALUE_SIZE_ESTIMATE).set(valueSizeEstimate);
return this;
}
@Override
public RemoteServerConfigurationBuilder addServer() {
RemoteServerConfigurationBuilder builder = new RemoteServerConfigurationBuilder(this);
this.servers.add(builder);
return builder;
}
@Override
public RemoteStoreConfiguration create() {
List<RemoteServerConfiguration> remoteServers = new ArrayList<RemoteServerConfiguration>();
for (RemoteServerConfigurationBuilder server : servers) {
remoteServers.add(server.create());
}
return new RemoteStoreConfiguration(attributes.protect(), async.create(),
asyncExecutorFactory.create(), connectionPool.create(), security.create(), remoteServers);
}
@Override
public RemoteStoreConfigurationBuilder read(RemoteStoreConfiguration template, Combine combine) {
super.read(template, combine);
this.asyncExecutorFactory.read(template.asyncExecutorFactory(), combine);
this.connectionPool.read(template.connectionPool(), combine);
for (RemoteServerConfiguration server : template.servers()) {
this.addServer().host(server.host()).port(server.port());
}
this.security.read(template.security(), combine);
return this;
}
@Override
public RemoteStoreConfigurationBuilder withProperties(Properties props) {
String version = (String) props.remove(RemoteStoreConfiguration.PROTOCOL_VERSION.name());
if (version != null) {
this.protocolVersion(ProtocolVersion.parseVersion(version));
}
return super.withProperties(props);
}
@Override
public void validate() {
this.connectionPool.validate();
this.asyncExecutorFactory.validate();
for (RemoteServerConfigurationBuilder server : servers) {
server.validate();
}
if (attributes.attribute(HOTROD_WRAPPING).get() && attributes.attribute(MARSHALLER).get() != null) {
throw CONFIG.cannotEnableHotRodWrapping();
}
if (attributes.attribute(SEGMENTED).get() && builder.clustering().hash().groups().isEnabled()) {
throw CONFIG.segmentationNotSupportedWithGroups();
}
ProtocolVersion version = attributes.attribute(PROTOCOL_VERSION).get();
ProtocolVersion minimumVersion = ProtocolVersion.PROTOCOL_VERSION_23;
if (attributes.attribute(SEGMENTED).get() && version.compareTo(minimumVersion) < 0) {
throw CONFIG.segmentationNotSupportedInThisVersion(minimumVersion);
}
}
}
| 9,218
| 36.938272
| 156
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/RemoteStoreConfigurationChildBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.impl.transport.netty.ChannelFactory;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.configuration.cache.StoreConfigurationChildBuilder;
import org.infinispan.container.entries.InternalCacheEntry;
public interface RemoteStoreConfigurationChildBuilder<S> extends StoreConfigurationChildBuilder<S> {
/**
* Adds a new remote server
*/
RemoteServerConfigurationBuilder addServer();
/**
* Configuration for the executor service used for asynchronous work on the Transport, including
* asynchronous marshalling and Cache 'async operations' such as Cache.putAsync().
*/
ExecutorFactoryConfigurationBuilder asyncExecutorFactory();
/**
* For replicated (vs distributed) Hot Rod server clusters, the client balances requests to the
* servers according to this strategy.
*/
RemoteStoreConfigurationBuilder balancingStrategy(String balancingStrategy);
/**
* Configures the connection pool
*/
ConnectionPoolConfigurationBuilder connectionPool();
/**
* This property defines the maximum socket connect timeout before giving up connecting to the
* server.
*/
RemoteStoreConfigurationBuilder connectionTimeout(long connectionTimeout);
/**
* Whether or not to implicitly FORCE_RETURN_VALUE for all calls.
*/
RemoteStoreConfigurationBuilder forceReturnValues(boolean forceReturnValues);
/**
* Configures this RemoteStore so that it enables all settings needed to create entries to be served
* by a HotRod endpoint, for example when performing rolling upgrades.
*/
RemoteStoreConfigurationBuilder hotRodWrapping(boolean hotRodWrapping);
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
RemoteStoreConfigurationBuilder keySizeEstimate(int keySizeEstimate);
/**
* Allows you to specify a custom {@link org.infinispan.commons.marshall.Marshaller} implementation to
* serialize and deserialize user objects.
*/
RemoteStoreConfigurationBuilder marshaller(String marshaller);
/**
* Allows you to specify a custom {@link org.infinispan.commons.marshall.Marshaller} implementation to
* serialize and deserialize user objects.
*/
RemoteStoreConfigurationBuilder marshaller(Class<? extends Marshaller> marshaller);
/**
* This property defines the protocol version that this client should use. Defaults to {@link ProtocolVersion#DEFAULT_PROTOCOL_VERSION}
*/
RemoteStoreConfigurationBuilder protocolVersion(ProtocolVersion protocolVersion);
/**
* Normally the {@link org.infinispan.persistence.remote.RemoteStore} stores values wrapped in {@link InternalCacheEntry}. Setting
* this property to true causes the raw values to be stored instead for interoperability with direct
* access by {@link RemoteCacheManager}s
*/
RemoteStoreConfigurationBuilder rawValues(boolean rawValues);
/**
* The name of the remote cache in the remote infinispan cluster, to which to connect to. If
* unspecified, the default cache will be used
*/
RemoteStoreConfigurationBuilder remoteCacheName(String remoteCacheName);
/**
* Configures connection security
*/
SecurityConfigurationBuilder remoteSecurity();
/**
* This property defines the maximum socket read timeout in milliseconds before giving up waiting
* for bytes from the server. Defaults to 60000 (1 minute)
*/
RemoteStoreConfigurationBuilder socketTimeout(long socketTimeout);
/**
* Affects TCP NODELAY on the TCP stack. Defaults to enabled
*/
RemoteStoreConfigurationBuilder tcpNoDelay(boolean tcpNoDelay);
/**
* Controls which transport to use. Currently only the TcpTransport is supported.
*
* @deprecated since 10.0. This method has no effect
*/
@Deprecated
RemoteStoreConfigurationBuilder transportFactory(String transportFactory);
/**
* Controls which transport to use. Currently only the TcpTransport is supported.
*
* @deprecated since 10.0. This method has no effect
*/
@Deprecated
RemoteStoreConfigurationBuilder transportFactory(Class<? extends ChannelFactory> transportFactory);
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
RemoteStoreConfigurationBuilder valueSizeEstimate(int valueSizeEstimate);
}
| 4,579
| 35.349206
| 138
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/RemoteServerConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.RemoteServerConfiguration.HOST;
import static org.infinispan.persistence.remote.configuration.RemoteServerConfiguration.PORT;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class RemoteServerConfigurationBuilder extends AbstractRemoteStoreConfigurationChildBuilder<RemoteStoreConfigurationBuilder> implements
Builder<RemoteServerConfiguration> {
RemoteServerConfigurationBuilder(RemoteStoreConfigurationBuilder builder) {
super(builder, RemoteServerConfiguration.attributeDefinitionSet());
}
public AttributeSet attributes() {
return attributes;
}
public RemoteServerConfigurationBuilder host(String host) {
this.attributes.attribute(HOST).set(host);
return this;
}
public RemoteServerConfigurationBuilder port(int port) {
this.attributes.attribute(PORT).set(port);
return this;
}
@Override
public RemoteServerConfiguration create() {
return new RemoteServerConfiguration(attributes.protect());
}
@Override
public RemoteServerConfigurationBuilder read(RemoteServerConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 1,438
| 33.261905
| 142
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/RemoteStoreConfigurationParser.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationParser.NAMESPACE;
import static org.infinispan.persistence.remote.logging.Log.CONFIG;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.PersistenceConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ConfigurationParser;
import org.infinispan.configuration.parsing.Namespace;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.configuration.parsing.Parser;
import org.kohsuke.MetaInfServices;
/**
* Remote cache store parser.
*
* @author Galder Zamarreño
* @since 9.0
*/
@MetaInfServices
@Namespace(root = "remote-store")
@Namespace(uri = NAMESPACE + "*", root = "remote-store")
public class RemoteStoreConfigurationParser implements ConfigurationParser {
static final String NAMESPACE = Parser.NAMESPACE + "store:remote:";
public RemoteStoreConfigurationParser() {
}
@Override
public void readElement(final ConfigurationReader reader, final ConfigurationBuilderHolder holder) {
ConfigurationBuilder builder = holder.getCurrentConfigurationBuilder();
Element element = Element.forName(reader.getLocalName());
switch (element) {
case REMOTE_STORE: {
parseRemoteStore(reader, builder.persistence(), holder.getClassLoader());
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseRemoteStore(final ConfigurationReader reader, PersistenceConfigurationBuilder persistenceBuilder,
ClassLoader classLoader) {
RemoteStoreConfigurationBuilder builder = new RemoteStoreConfigurationBuilder(persistenceBuilder);
parseRemoteStoreAttributes(reader, builder);
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case ASYNC_TRANSPORT_EXECUTOR: {
parseAsyncTransportExecutor(reader, builder.asyncExecutorFactory(), classLoader);
break;
}
case CONNECTION_POOL: {
parseConnectionPool(reader, builder.connectionPool());
break;
}
case REMOTE_SERVER: {
if (reader.getAttributeCount() > 0) {
parseServer(reader, builder.addServer());
} else {
while (reader.inTag(Element.REMOTE_SERVER)) {
parseServer(reader, builder.addServer());
}
}
break;
}
case SECURITY: {
parseSecurity(reader, builder.remoteSecurity());
break;
}
default: {
Parser.parseStoreElement(reader, builder);
break;
}
}
}
persistenceBuilder.addStore(builder);
}
private void parseSecurity(ConfigurationReader reader, SecurityConfigurationBuilder security) {
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case AUTHENTICATION: {
parseAuthentication(reader, security.authentication());
break;
}
case ENCRYPTION: {
parseEncryption(reader, security.ssl());
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseAuthentication(ConfigurationReader reader, AuthenticationConfigurationBuilder authentication) {
authentication.enable();
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case SERVER_NAME: {
authentication.serverName(value);
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
boolean hasMech = false;
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case AUTH_PLAIN: {
if (hasMech)
throw ParseUtils.unexpectedElement(reader);
parseAuthenticationPlain(reader, authentication);
hasMech = true;
break;
}
case AUTH_DIGEST: {
if (hasMech)
throw ParseUtils.unexpectedElement(reader);
parseAuthenticationDigest(reader, authentication);
hasMech = true;
break;
}
case AUTH_EXTERNAL: {
if (hasMech)
throw ParseUtils.unexpectedElement(reader);
parseAuthenticationExternal(reader, authentication);
hasMech = true;
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseAuthenticationPlain(ConfigurationReader reader, AuthenticationConfigurationBuilder authentication) {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.USERNAME.getLocalName(), Attribute.PASSWORD.getLocalName());
authentication.saslMechanism("PLAIN").username(attributes[0]).password(attributes[1]);
ParseUtils.requireNoContent(reader);
}
private void parseAuthenticationDigest(ConfigurationReader reader, AuthenticationConfigurationBuilder authentication) {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.USERNAME.getLocalName(), Attribute.PASSWORD.getLocalName(), Attribute.REALM.getLocalName());
authentication.saslMechanism("DIGEST-MD5").username(attributes[0]).password(attributes[1]).realm(attributes[2]);
ParseUtils.requireNoContent(reader);
}
private void parseAuthenticationExternal(ConfigurationReader reader, AuthenticationConfigurationBuilder authentication) {
ParseUtils.requireNoAttributes(reader);
authentication.saslMechanism("EXTERNAL");
ParseUtils.requireNoContent(reader);
}
private void parseEncryption(ConfigurationReader reader, SslConfigurationBuilder ssl) {
ssl.enable();
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case PROTOCOL: {
ssl.protocol(value);
break;
}
case SNI_HOSTNAME: {
ssl.sniHostName(value);
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case KEYSTORE: {
parseKeystore(reader, ssl);
break;
}
case TRUSTSTORE: {
parseTruststore(reader, ssl);
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private void parseKeystore(ConfigurationReader reader, SslConfigurationBuilder ssl) {
String[] attributes = ParseUtils.requireAttributes(reader, true,
Attribute.FILENAME.getLocalName(),
Attribute.PASSWORD.getLocalName());
ssl.keyStoreFileName(attributes[0]);
ssl.keyStorePassword(attributes[1].toCharArray());
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case FILENAME:
case PASSWORD:
// already processed
break;
case CERTIFICATE_PASSWORD: {
ssl.keyStoreCertificatePassword(value.toCharArray());
break;
}
case KEY_ALIAS: {
ssl.keyAlias(value);
break;
}
case TYPE: {
ssl.keyStoreType(value);
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
private void parseTruststore(ConfigurationReader reader, SslConfigurationBuilder ssl) {
String[] attributes = ParseUtils.requireAttributes(reader, true,
Attribute.FILENAME.getLocalName(),
Attribute.TYPE.getLocalName());
ssl.trustStoreFileName(attributes[0]);
ssl.trustStorePassword(attributes[1].toCharArray());
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case FILENAME:
case PASSWORD:
ssl.trustStorePassword(value.toCharArray());
break;
case TYPE: {
ssl.trustStoreType(value);
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
private void parseAsyncTransportExecutor(final ConfigurationReader reader,
final ExecutorFactoryConfigurationBuilder builder, ClassLoader classLoader) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case FACTORY: {
builder.factory(Util.getInstance(value, classLoader));
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
builder.withExecutorProperties(Parser.parseProperties(reader, Element.ASYNC_TRANSPORT_EXECUTOR));
}
private void parseConnectionPool(ConfigurationReader reader, ConnectionPoolConfigurationBuilder builder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case EXHAUSTED_ACTION: {
builder.exhaustedAction(ExhaustedAction.valueOf(value));
break;
}
case MAX_ACTIVE: {
builder.maxActive(Integer.parseInt(value));
break;
}
case MAX_PENDING_REQUESTS: {
builder.maxPendingRequests(Integer.parseInt(value));
break;
}
case MIN_EVICTABLE_IDLE_TIME: {
builder.minEvictableIdleTime(Long.parseLong(value));
break;
}
case MIN_IDLE: {
builder.minIdle(Integer.parseInt(value));
break;
}
case MAX_WAIT: {
builder.maxWait(Integer.parseInt(value));
break;
}
case MAX_IDLE:
case MAX_TOTAL:
case TEST_WHILE_IDLE:
case TIME_BETWEEN_EVICTION_RUNS: {
if (reader.getSchema().since(10, 0)) {
throw ParseUtils.attributeRemoved(reader, i);
} else {
ParseUtils.ignoreAttribute(reader, i);
}
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
}
private void parseServer(ConfigurationReader reader, RemoteServerConfigurationBuilder builder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case HOST:
builder.host(value);
break;
case PORT:
builder.port(Integer.parseInt(value));
break;
case OUTBOUND_SOCKET_BINDING:
CONFIG.ignoreXmlAttribute(attribute);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseRemoteStoreAttributes(ConfigurationReader reader, RemoteStoreConfigurationBuilder builder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
String attrName = reader.getAttributeName(i);
Attribute attribute = Attribute.forName(attrName);
switch (attribute) {
case BALANCING_STRATEGY: {
builder.balancingStrategy(value);
break;
}
case CONNECT_TIMEOUT: {
builder.connectionTimeout(Long.parseLong(value));
break;
}
case FORCE_RETURN_VALUES: {
builder.forceReturnValues(Boolean.parseBoolean(value));
break;
}
case HOTROD_WRAPPING: {
builder.hotRodWrapping(Boolean.parseBoolean(value));
break;
}
case KEY_SIZE_ESTIMATE: {
builder.keySizeEstimate(Integer.parseInt(value));
break;
}
case MARSHALLER: {
builder.marshaller(value);
break;
}
case PING_ON_STARTUP: {
if (!reader.getSchema().since(9, 1)) {
throw ParseUtils.attributeRemoved(reader, i);
} else {
ParseUtils.ignoreAttribute(reader, i);
}
break;
}
case PROTOCOL_VERSION: {
builder.protocolVersion(ProtocolVersion.parseVersion(value));
break;
}
case RAW_VALUES: {
builder.rawValues(Boolean.parseBoolean(value));
break;
}
case REMOTE_CACHE_NAME: {
builder.remoteCacheName(value);
break;
}
case SOCKET_TIMEOUT: {
builder.socketTimeout(Long.parseLong(value));
break;
}
case TCP_NO_DELAY: {
builder.tcpNoDelay(Boolean.parseBoolean(value));
break;
}
case TRANSPORT_FACTORY: {
builder.transportFactory(value);
break;
}
case VALUE_SIZE_ESTIMATE: {
builder.valueSizeEstimate(Integer.parseInt(value));
break;
}
case URI: {
builder.uri(value);
break;
}
default: {
Parser.parseStoreAttribute(reader, i, builder);
break;
}
}
}
}
@Override
public Namespace[] getNamespaces() {
return ParseUtils.getNamespaceAnnotations(getClass());
}
}
| 16,463
| 35.505543
| 167
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/AuthenticationConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import java.util.HashMap;
import java.util.Map;
import javax.security.auth.Subject;
import javax.security.auth.callback.CallbackHandler;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
/**
* AuthenticationConfiguration.
*
* @author Tristan Tarrant
* @since 9.1
*/
public class AuthenticationConfiguration extends ConfigurationElement<AuthenticationConfiguration> {
static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder(Attribute.ENABLED, false, Boolean.class).immutable().autoPersist(false).build();
static final AttributeDefinition<CallbackHandler> CALLBACK_HANDLER = AttributeDefinition.builder("callback-handler", null, CallbackHandler.class).immutable().autoPersist(false).build();
static final AttributeDefinition<Subject> CLIENT_SUBJECT = AttributeDefinition.builder("client-subject", null, Subject.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> SERVER_NAME = AttributeDefinition.builder(Attribute.SERVER_NAME, null, String.class).immutable().build();
static final AttributeDefinition<Map> SASL_PROPERTIES = AttributeDefinition.builder(Element.PROPERTIES, null, Map.class).initializer(HashMap::new).autoPersist(false).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(AuthenticationConfiguration.class, ENABLED, CALLBACK_HANDLER, CLIENT_SUBJECT, SERVER_NAME, SASL_PROPERTIES);
}
private final MechanismConfiguration mechanismConfiguration;
public AuthenticationConfiguration(AttributeSet attributes, MechanismConfiguration mechanismConfiguration) {
super(Element.AUTHENTICATION, attributes);
this.mechanismConfiguration = mechanismConfiguration;
}
MechanismConfiguration mechanismConfiguration() {
return mechanismConfiguration;
}
public CallbackHandler callbackHandler() {
return attributes.attribute(CALLBACK_HANDLER).get();
}
public boolean enabled() {
return attributes.attribute(ENABLED).get();
}
public String username() {
return mechanismConfiguration.username();
}
public char[] password() {
return mechanismConfiguration.password();
}
public String realm() {
return mechanismConfiguration.realm();
}
public String saslMechanism() {
return mechanismConfiguration.saslMechanism();
}
public Map<String, String> saslProperties() {
return attributes.attribute(SASL_PROPERTIES).get();
}
public String serverName() {
return attributes.attribute(SERVER_NAME).get();
}
public Subject clientSubject() {
return attributes.attribute(CLIENT_SUBJECT).get();
}
}
| 2,893
| 36.584416
| 189
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/AbstractRemoteStoreConfigurationChildBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.impl.transport.netty.ChannelFactory;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.configuration.cache.AbstractStoreConfigurationChildBuilder;
import org.infinispan.configuration.global.GlobalConfiguration;
/**
* AbstractRemoteStoreConfigurationChildBuilder.
*
* @author Tristan Tarrant
* @since 5.2
*/
public abstract class AbstractRemoteStoreConfigurationChildBuilder<S> extends AbstractStoreConfigurationChildBuilder<S> implements RemoteStoreConfigurationChildBuilder<S> {
protected final RemoteStoreConfigurationBuilder builder;
protected final AttributeSet attributes;
protected AbstractRemoteStoreConfigurationChildBuilder(RemoteStoreConfigurationBuilder builder, AttributeSet attributes) {
super(builder);
this.attributes = attributes;
this.builder = builder;
}
@Override
public RemoteServerConfigurationBuilder addServer() {
return builder.addServer();
}
@Override
public ExecutorFactoryConfigurationBuilder asyncExecutorFactory() {
return builder.asyncExecutorFactory();
}
@Override
public RemoteStoreConfigurationBuilder balancingStrategy(String balancingStrategy) {
return builder.balancingStrategy(balancingStrategy);
}
@Override
public ConnectionPoolConfigurationBuilder connectionPool() {
return builder.connectionPool();
}
@Override
public RemoteStoreConfigurationBuilder connectionTimeout(long connectionTimeout) {
return builder.connectionTimeout(connectionTimeout);
}
@Override
public RemoteStoreConfigurationBuilder forceReturnValues(boolean forceReturnValues) {
return builder.forceReturnValues(forceReturnValues);
}
@Override
public RemoteStoreConfigurationBuilder hotRodWrapping(boolean hotRodWrapping) {
return builder.hotRodWrapping(hotRodWrapping);
}
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
@Override
public RemoteStoreConfigurationBuilder keySizeEstimate(int keySizeEstimate) {
return builder.keySizeEstimate(keySizeEstimate);
}
@Override
public RemoteStoreConfigurationBuilder marshaller(String marshaller) {
return builder.marshaller(marshaller);
}
@Override
public RemoteStoreConfigurationBuilder marshaller(Class<? extends Marshaller> marshaller) {
return builder.marshaller(marshaller);
}
@Override
public RemoteStoreConfigurationBuilder protocolVersion(ProtocolVersion protocolVersion) {
return builder.protocolVersion(protocolVersion);
}
@Override
public RemoteStoreConfigurationBuilder rawValues(boolean rawValues) {
return builder.rawValues(rawValues);
}
@Override
public RemoteStoreConfigurationBuilder remoteCacheName(String remoteCacheName) {
return builder.remoteCacheName(remoteCacheName);
}
@Override
public SecurityConfigurationBuilder remoteSecurity() {
return builder.remoteSecurity();
}
@Override
public RemoteStoreConfigurationBuilder socketTimeout(long socketTimeout) {
return builder.socketTimeout(socketTimeout);
}
@Override
public RemoteStoreConfigurationBuilder tcpNoDelay(boolean tcpNoDelay) {
return builder.tcpNoDelay(tcpNoDelay);
}
@Override
public RemoteStoreConfigurationBuilder transportFactory(String transportFactory) {
return builder.transportFactory(transportFactory);
}
@Override
public RemoteStoreConfigurationBuilder transportFactory(Class<? extends ChannelFactory> transportFactory) {
return builder.transportFactory(transportFactory);
}
/**
* @deprecated Since 12.0, does nothing and will be removed in 15.0
*/
@Deprecated
@Override
public RemoteStoreConfigurationBuilder valueSizeEstimate(int valueSizeEstimate) {
return builder.valueSizeEstimate(valueSizeEstimate);
}
@Override
public void validate(GlobalConfiguration globalConfig) {
}
public RemoteStoreConfigurationBuilder getRemoteStoreBuilder() {
return builder;
}
}
| 4,272
| 30.189781
| 172
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/ConnectionPoolConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.client.hotrod.impl.ConfigurationProperties;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
@BuiltBy(ConnectionPoolConfigurationBuilder.class)
public class ConnectionPoolConfiguration extends ConfigurationElement<ConnectionPoolConfiguration> {
static final AttributeDefinition<ExhaustedAction> EXHAUSTED_ACTION = AttributeDefinition.builder(Attribute.EXHAUSTED_ACTION, ExhaustedAction.WAIT, ExhaustedAction.class).immutable().build();
static final AttributeDefinition<Integer> MAX_ACTIVE = AttributeDefinition.builder(Attribute.MAX_ACTIVE, ConfigurationProperties.DEFAULT_MAX_ACTIVE).immutable().build();
static final AttributeDefinition<Integer> MAX_WAIT = AttributeDefinition.builder(Attribute.MAX_WAIT, ConfigurationProperties.DEFAULT_MAX_WAIT).immutable().build();
static final AttributeDefinition<Integer> MIN_IDLE = AttributeDefinition.builder(Attribute.MIN_IDLE, ConfigurationProperties.DEFAULT_MIN_IDLE).immutable().build();
static final AttributeDefinition<Long> MIN_EVICTABLE_IDLE_TIME = AttributeDefinition.builder(Attribute.MIN_EVICTABLE_IDLE_TIME, ConfigurationProperties.DEFAULT_MIN_EVICTABLE_IDLE_TIME).immutable().build();
static final AttributeDefinition<Integer> MAX_PENDING_REQUESTS = AttributeDefinition.builder(Attribute.MAX_PENDING_REQUESTS, ConfigurationProperties.DEFAULT_MAX_PENDING_REQUESTS).immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ConnectionPoolConfiguration.class, EXHAUSTED_ACTION, MAX_ACTIVE, MAX_WAIT, MIN_IDLE, MIN_EVICTABLE_IDLE_TIME, MAX_PENDING_REQUESTS);
}
ConnectionPoolConfiguration(AttributeSet attributes) {
super(Element.CONNECTION_POOL, attributes);
}
public ExhaustedAction exhaustedAction() {
return attributes.attribute(EXHAUSTED_ACTION).get();
}
public int maxActive() {
return attributes.attribute(MAX_ACTIVE).get();
}
public int maxWait() {
return attributes.attribute(MAX_WAIT).get();
}
/*
* deprecated since 10.0. Always returns -1
*/
@Deprecated
public int maxIdle() {
return -1;
}
public int minIdle() {
return attributes.attribute(MIN_IDLE).get();
}
public int maxPendingRequests() {
return attributes.attribute(MAX_PENDING_REQUESTS).get();
}
public long minEvictableIdleTime() {
return attributes.attribute(MIN_EVICTABLE_IDLE_TIME).get();
}
}
| 2,715
| 44.266667
| 208
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/TrustStoreConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.TrustStoreConfiguration.TRUSTSTORE_FILENAME;
import static org.infinispan.persistence.remote.configuration.TrustStoreConfiguration.TRUSTSTORE_PASSWORD;
import static org.infinispan.persistence.remote.configuration.TrustStoreConfiguration.TRUSTSTORE_TYPE;
import org.infinispan.client.hotrod.logging.Log;
import org.infinispan.client.hotrod.logging.LogFactory;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class TrustStoreConfigurationBuilder extends AbstractSecurityConfigurationChildBuilder implements Builder<TrustStoreConfiguration> {
private static final Log log = LogFactory.getLog(TrustStoreConfigurationBuilder.class);
protected TrustStoreConfigurationBuilder(SecurityConfigurationBuilder builder) {
super(builder, TrustStoreConfiguration.attributeDefinitionSet());
}
public AttributeSet attributes() {
return attributes;
}
public TrustStoreConfigurationBuilder trustStoreFileName(String trustStoreFileName) {
this.attributes.attribute(TRUSTSTORE_FILENAME).set(trustStoreFileName);
return this;
}
public TrustStoreConfigurationBuilder trustStoreType(String trustStoreType) {
this.attributes.attribute(TRUSTSTORE_TYPE).set(trustStoreType);
return this;
}
public TrustStoreConfigurationBuilder trustStorePassword(char[] trustStorePassword) {
this.attributes.attribute(TRUSTSTORE_PASSWORD).set(new String(trustStorePassword));
return this;
}
@Override
public TrustStoreConfiguration create() {
return new TrustStoreConfiguration(attributes.protect());
}
@Override
public TrustStoreConfigurationBuilder read(TrustStoreConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
}
| 2,042
| 36.833333
| 139
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/RemoteStoreConfigurationSerializer.java
|
package org.infinispan.persistence.remote.configuration;
import java.util.List;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.serializing.AbstractStoreSerializer;
import org.infinispan.configuration.serializing.ConfigurationSerializer;
import org.infinispan.configuration.serializing.SerializeUtils;
/**
* RemoteStoreConfigurationSerializer.
*
* @author Tristan Tarrant
* @since 9.0
*/
public class RemoteStoreConfigurationSerializer extends AbstractStoreSerializer implements ConfigurationSerializer<RemoteStoreConfiguration> {
@Override
public void serialize(ConfigurationWriter writer, RemoteStoreConfiguration configuration) {
writer.writeStartElement(Element.REMOTE_STORE);
writer.writeDefaultNamespace(RemoteStoreConfigurationParser.NAMESPACE + Version.getMajorMinor());
configuration.attributes().write(writer);
writeCommonStoreSubAttributes(writer, configuration);
writeAsyncExecutor(writer, configuration.asyncExecutorFactory());
writeConnectionPool(writer, configuration.connectionPool());
writeServers(writer, configuration.servers());
writeSecurity(writer, configuration.security());
writeCommonStoreElements(writer, configuration);
writer.writeEndElement();
}
private void writeAsyncExecutor(ConfigurationWriter writer, ExecutorFactoryConfiguration executorFactoryConfiguration) {
AttributeSet attributes = executorFactoryConfiguration.attributes();
if(attributes.isModified()) {
writer.writeStartElement(Element.ASYNC_TRANSPORT_EXECUTOR);
attributes.write(writer, ExecutorFactoryConfiguration.EXECUTOR_FACTORY, Attribute.FACTORY);
SerializeUtils.writeTypedProperties(writer, executorFactoryConfiguration.properties());
writer.writeEndElement();
}
}
private void writeConnectionPool(ConfigurationWriter writer, ConnectionPoolConfiguration connectionPool) {
writer.writeStartElement(Element.CONNECTION_POOL);
writer.writeAttribute(Attribute.EXHAUSTED_ACTION, connectionPool.exhaustedAction().name());
writer.writeAttribute(Attribute.MAX_ACTIVE, Integer.toString(connectionPool.maxActive()));
writer.writeAttribute(Attribute.MAX_PENDING_REQUESTS, Integer.toString(connectionPool.maxPendingRequests()));
writer.writeAttribute(Attribute.MAX_WAIT, Integer.toString(connectionPool.maxWait()));
writer.writeAttribute(Attribute.MIN_IDLE, Integer.toString(connectionPool.minIdle()));
writer.writeAttribute(Attribute.MIN_EVICTABLE_IDLE_TIME, Long.toString(connectionPool.minEvictableIdleTime()));
writer.writeEndElement();
}
private void writeServers(ConfigurationWriter writer, List<RemoteServerConfiguration> servers) {
writer.writeStartListElement(Element.REMOTE_SERVER, false);
for(RemoteServerConfiguration server : servers) {
writer.writeStartElement(Element.REMOTE_SERVER);
writer.writeAttribute(Attribute.HOST, server.host());
writer.writeAttribute(Attribute.PORT, Integer.toString(server.port()));
writer.writeEndElement();
}
writer.writeEndListElement();
}
private void writeSecurity(ConfigurationWriter writer, SecurityConfiguration security) {
if (security.authentication().attributes().isModified() || security.ssl().attributes().isModified()) {
writer.writeStartElement(Element.SECURITY);
writeAuthentication(writer, security.authentication());
writeEncryption(writer, security.ssl());
writer.writeEndElement();
}
}
private void writeAuthentication(ConfigurationWriter writer, AuthenticationConfiguration authentication) {
AttributeSet attributeSet = authentication.attributes();
if (attributeSet.isModified()) {
writer.writeStartElement(Element.AUTHENTICATION);
attributeSet.write(writer);
switch (authentication.saslMechanism()) {
case "PLAIN": {
writer.writeStartElement(Element.AUTH_PLAIN);
writer.writeAttribute(Attribute.USERNAME, authentication.username());
writer.writeAttribute(Attribute.PASSWORD, new String(authentication.password()));
writer.writeEndElement();
break;
}
case "DIGEST-MD5": {
writer.writeStartElement(Element.AUTH_DIGEST);
writer.writeAttribute(Attribute.USERNAME, authentication.username());
writer.writeAttribute(Attribute.PASSWORD, new String(authentication.password()));
writer.writeAttribute(Attribute.REALM, authentication.realm());
writer.writeEndElement();
break;
}
case "EXTERNAL": {
writer.writeEmptyElement(Element.AUTH_EXTERNAL);
break;
}
}
writer.writeEndElement();
}
}
private void writeEncryption(ConfigurationWriter writer, SslConfiguration ssl) {
AttributeSet attributes = ssl.attributes();
if (attributes.isModified()) {
writer.writeStartElement(Element.ENCRYPTION);
attributes.write(writer);
if (ssl.keyStoreFileName() != null) {
writer.writeStartElement(Element.KEYSTORE);
writer.writeAttribute(Attribute.FILENAME, ssl.keyStoreFileName());
writer.writeAttribute(Attribute.PASSWORD, new String(ssl.keyStorePassword()));
if (ssl.keyStoreCertificatePassword() != null) {
writer.writeAttribute(Attribute.CERTIFICATE_PASSWORD, new String(ssl.keyStoreCertificatePassword()));
}
if (ssl.keyAlias() != null) {
writer.writeAttribute(Attribute.KEY_ALIAS, ssl.keyAlias());
}
writer.writeAttribute(Attribute.TYPE, ssl.keyStoreType());
writer.writeEndElement();
}
if (ssl.trustStoreFileName() != null) {
writer.writeStartElement(Element.TRUSTSTORE);
writer.writeAttribute(Attribute.FILENAME, ssl.trustStoreFileName());
writer.writeAttribute(Attribute.PASSWORD, new String(ssl.trustStorePassword()));
writer.writeAttribute(Attribute.TYPE, ssl.trustStoreType());
writer.writeEndElement();
}
writer.writeEndElement();
}
}
}
| 6,488
| 45.35
| 142
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/MechanismConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.Element.AUTH_DIGEST;
import static org.infinispan.persistence.remote.configuration.Element.AUTH_EXTERNAL;
import static org.infinispan.persistence.remote.configuration.Element.AUTH_PLAIN;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.util.Util;
public class MechanismConfiguration {
static final AttributeDefinition<String> USERNAME = AttributeDefinition.builder("username", null, String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> PASSWORD = AttributeDefinition.builder("password", null, String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> REALM = AttributeDefinition.builder("realm", null, String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> SASL_MECHANISM = AttributeDefinition.builder("sasl-mechanism", null, String.class)
.immutable().autoPersist(false).build();
private final AttributeSet attributes;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(MechanismConfiguration.class, USERNAME, PASSWORD, REALM, SASL_MECHANISM);
}
public MechanismConfiguration(AttributeSet attributes) {
this.attributes = attributes;
}
public String username() {
return attributes.attribute(USERNAME).get();
}
public char[] password() {
return Util.toCharArray(attributes.attribute(PASSWORD).get());
}
public String realm() {
return attributes.attribute(REALM).get();
}
public String saslMechanism() {
return attributes.attribute(SASL_MECHANISM).get();
}
public AttributeSet attributes() {
return attributes;
}
static String serializeMechanism(String mechanism) {
if (mechanism == null) return null;
switch (mechanism) {
case "PLAIN": {
return AUTH_PLAIN.getLocalName();
}
case "DIGEST-MD5": {
return AUTH_DIGEST.getLocalName();
}
case "EXTERNAL": {
return AUTH_EXTERNAL.getLocalName();
}
}
throw new CacheConfigurationException("Invalid sasl mechanism");
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
MechanismConfiguration that = (MechanismConfiguration) o;
return attributes != null ? attributes.equals(that.attributes) : that.attributes == null;
}
@Override
public int hashCode() {
return attributes != null ? attributes.hashCode() : 0;
}
@Override
public String toString() {
return "MechanismConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 3,019
| 32.555556
| 154
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/Attribute.java
|
package org.infinispan.persistence.remote.configuration;
import java.util.HashMap;
import java.util.Map;
/**
* Enumerates the attributes used by the Remote cache store configuration
*
* @author Tristan Tarrant
* @since 5.2
*/
public enum Attribute {
// must be first
UNKNOWN(null),
ASYNC_EXECUTOR("async-executor"),
BALANCING_STRATEGY("balancing-strategy"),
CONNECT_TIMEOUT("connect-timeout"),
ENABLED("enabled"),
EXHAUSTED_ACTION("exhausted-action"),
FACTORY("factory"),
FORCE_RETURN_VALUES("force-return-values"),
HOST("host"),
HOTROD_WRAPPING("hotrod-wrapping"),
FILENAME("filename"),
CERTIFICATE_PASSWORD("certificate-password"),
KEY_ALIAS("key-alias"),
TYPE("type"),
MARSHALLER("marshaller"),
MAX_ACTIVE("max-active"),
MAX_IDLE("max-idle"),
MAX_PENDING_REQUESTS("max-pending-requests"),
MAX_TOTAL("max-total"),
MAX_WAIT("max-wait"),
MIN_EVICTABLE_IDLE_TIME("min-evictable-idle-time"),
MIN_IDLE("min-idle"),
/**
* @deprecated Since 12.0, will be removed in 15.0
*/
@Deprecated
KEY_SIZE_ESTIMATE("key-size-estimate"),
OUTBOUND_SOCKET_BINDING("outbound-socket-binding"),
PASSWORD("password"),
PING_ON_STARTUP("ping-on-start"),
PORT("port"),
PROTOCOL("protocol"),
PROTOCOL_VERSION("protocol-version"),
RAW_VALUES("raw-values"),
REALM("realm"),
REMOTE_CACHE_NAME("cache"),
SASL_MECHANISM("sasl-mechanism"),
SERVER_NAME("server-name"),
SNI_HOSTNAME("sni-hostname"),
SOCKET_TIMEOUT("socket-timeout"),
TCP_NO_DELAY("tcp-no-delay"),
TEST_WHILE_IDLE("test-idle"),
TIME_BETWEEN_EVICTION_RUNS("eviction-interval"),
TRANSPORT_FACTORY("transport-factory"),
URI("uri"),
USERNAME("username"),
/**
* @deprecated Since 12.0, will be removed in 15.0
*/
@Deprecated
VALUE_SIZE_ESTIMATE("value-size-estimate");
private final String name;
Attribute(final String name) {
this.name = name;
}
/**
* Get the local name of this element.
*
* @return the local name
*/
public String getLocalName() {
return name;
}
private static final Map<String, Attribute> attributes;
static {
final Map<String, Attribute> map = new HashMap<>(64);
for (Attribute attribute : values()) {
final String name = attribute.getLocalName();
if (name != null) {
map.put(name, attribute);
}
}
attributes = map;
}
public static Attribute forName(final String localName) {
final Attribute attribute = attributes.get(localName);
return attribute == null ? UNKNOWN : attribute;
}
@Override
public String toString() {
return name;
}
}
| 2,708
| 24.8
| 73
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/ExhaustedAction.java
|
package org.infinispan.persistence.remote.configuration;
public enum ExhaustedAction {
EXCEPTION,
WAIT,
CREATE_NEW
}
| 127
| 15
| 56
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/KeyStoreConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
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.Util;
/**
* @since 10.0
*/
public class KeyStoreConfiguration extends ConfigurationElement<KeyStoreConfiguration> {
static final AttributeDefinition<String> KEYSTORE_FILENAME = AttributeDefinition.builder(Attribute.FILENAME, null, String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> KEYSTORE_TYPE = AttributeDefinition.builder(Attribute.TYPE, "JKS", String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> KEYSTORE_PASSWORD = AttributeDefinition.builder(Attribute.PASSWORD, null, String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> KEYSTORE_CERTIFICATE_PASSWORD = AttributeDefinition.builder(Attribute.CERTIFICATE_PASSWORD, null, String.class).immutable().autoPersist(false).build();
static final AttributeDefinition<String> KEY_ALIAS = AttributeDefinition.builder(Attribute.KEY_ALIAS, null, String.class).immutable().autoPersist(false).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(SslConfiguration.class, KEYSTORE_FILENAME, KEYSTORE_TYPE, KEYSTORE_PASSWORD, KEYSTORE_CERTIFICATE_PASSWORD, KEY_ALIAS);
}
KeyStoreConfiguration(AttributeSet attributes) {
super(Element.KEYSTORE, attributes);
}
public String keyStoreFileName() {
return attributes.attribute(KEYSTORE_FILENAME).get();
}
public String keyStoreType() {
return attributes.attribute(KEYSTORE_TYPE).get();
}
public char[] keyStorePassword() {
return Util.toCharArray(attributes.attribute(KEYSTORE_PASSWORD).get());
}
public char[] keyStoreCertificatePassword() {
return Util.toCharArray(attributes.attribute(KEYSTORE_CERTIFICATE_PASSWORD).get());
}
public String keyAlias() {
return attributes.attribute(KEY_ALIAS).get();
}
}
| 2,169
| 45.170213
| 195
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/ConnectionPoolConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.ConnectionPoolConfiguration.EXHAUSTED_ACTION;
import static org.infinispan.persistence.remote.configuration.ConnectionPoolConfiguration.MAX_ACTIVE;
import static org.infinispan.persistence.remote.configuration.ConnectionPoolConfiguration.MAX_PENDING_REQUESTS;
import static org.infinispan.persistence.remote.configuration.ConnectionPoolConfiguration.MAX_WAIT;
import static org.infinispan.persistence.remote.configuration.ConnectionPoolConfiguration.MIN_EVICTABLE_IDLE_TIME;
import static org.infinispan.persistence.remote.configuration.ConnectionPoolConfiguration.MIN_IDLE;
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;
/**
* ConnectionPoolConfigurationBuilder. Specifies connection pooling properties for the HotRod client.
*
* @author Tristan Tarrant
* @since 5.2
*/
public class ConnectionPoolConfigurationBuilder extends AbstractRemoteStoreConfigurationChildBuilder<RemoteStoreConfigurationBuilder> implements
Builder<ConnectionPoolConfiguration> {
ConnectionPoolConfigurationBuilder(RemoteStoreConfigurationBuilder builder) {
super(builder, ConnectionPoolConfiguration.attributeDefinitionSet());
}
public AttributeSet attributes() {
return attributes;
}
/**
* Specifies what happens when asking for a connection from a server's pool, and that pool is
* exhausted.
*/
public ConnectionPoolConfigurationBuilder exhaustedAction(ExhaustedAction exhaustedAction) {
this.attributes.attribute(EXHAUSTED_ACTION).set(exhaustedAction);
return this;
}
/**
* Controls the maximum number of connections per server that are allocated (checked out to
* client threads, or idle in the pool) at one time. When non-positive, there is no limit to the
* number of connections per server. When maxActive is reached, the connection pool for that
* server is said to be exhausted. The default setting for this parameter is -1, i.e. there is no
* limit.
*/
public ConnectionPoolConfigurationBuilder maxActive(int maxActive) {
this.attributes.attribute(MAX_ACTIVE).set(maxActive);
return this;
}
/**
* Sets a global limit on the number persistent connections that can be in circulation within the
* combined set of servers. When non-positive, there is no limit to the total number of
* persistent connections in circulation. When maxTotal is exceeded, all connections pools are
* exhausted. The default setting for this parameter is -1 (no limit).
*
* @deprecated since 10.0. This method has no effect
*/
@Deprecated
public ConnectionPoolConfigurationBuilder maxTotal(int maxTotal) {
return this;
}
/**
* Controls the maximum number of idle persistent connections, per server, at any time. When
* negative, there is no limit to the number of connections that may be idle per server. The
* default setting for this parameter is -1.
*
* @deprecated since 10.0. This method has no effect
*/
@Deprecated
public ConnectionPoolConfigurationBuilder maxIdle(int maxIdle) {
return this;
}
/**
* The amount of time in milliseconds to wait for a connection to become available when the
* exhausted action is {@link org.infinispan.client.hotrod.configuration.ExhaustedAction#WAIT}, after which a {@link java.util.NoSuchElementException}
* will be thrown. If a negative value is supplied, the pool will block indefinitely.
*/
public ConnectionPoolConfigurationBuilder maxWait(int maxWait) {
this.attributes.attribute(MAX_WAIT).set(maxWait);
return this;
}
/**
* Sets a target value for the minimum number of idle connections (per server) that should always
* be available. If this parameter is set to a positive number and timeBetweenEvictionRunsMillis
* > 0, each time the idle connection eviction thread runs, it will try to create enough idle
* instances so that there will be minIdle idle instances available for each server. The default
* setting for this parameter is 1.
*/
public ConnectionPoolConfigurationBuilder minIdle(int minIdle) {
this.attributes.attribute(MIN_IDLE).set(minIdle);
return this;
}
/**
* Indicates how long the eviction thread should sleep before "runs" of examining idle
* connections. When non-positive, no eviction thread will be launched. The default setting for
* this parameter is 2 minutes.
*
* @deprecated since 10.0. This method has no effect
*/
@Deprecated
public ConnectionPoolConfigurationBuilder timeBetweenEvictionRuns(long timeBetweenEvictionRuns) {
return this;
}
/**
* Specifies the minimum amount of time that an connection may sit idle in the pool before it is
* eligible for eviction due to idle time. When non-positive, no connection will be dropped from
* the pool due to idle time alone. This setting has no effect unless
* timeBetweenEvictionRunsMillis > 0. The default setting for this parameter is 1800000(30
* minutes).
*/
public ConnectionPoolConfigurationBuilder minEvictableIdleTime(long minEvictableIdleTime) {
this.attributes.attribute(MIN_EVICTABLE_IDLE_TIME).set(minEvictableIdleTime);
return this;
}
/**
* Indicates whether or not idle connections should be validated by sending an TCP packet to the
* server, during idle connection eviction runs. Connections that fail to validate will be
* dropped from the pool. This setting has no effect unless timeBetweenEvictionRunsMillis > 0.
* The default setting for this parameter is true.
*
* @deprecated since 10.0. This method has no effect
*/
@Deprecated
public ConnectionPoolConfigurationBuilder testWhileIdle(boolean testWhileIdle) {
return this;
}
/**
* Specifies maximum number of requests sent over single connection at one instant.
* Connections with more concurrent requests will be ignored in the pool when choosing available connection
* and the pool will try to create a new connection if all connections are utilized. Only if the new connection
* cannot be created and the {@link #exhaustedAction(ExhaustedAction) exhausted action}
* is set to {@link org.infinispan.client.hotrod.configuration.ExhaustedAction#WAIT} the pool will allow sending the request over one of the over-utilized
* connections.
* The rule of thumb is that this should be set to higher values if the values are small (< 1kB) and to lower values
* if the entries are big (> 10kB).
* Default setting for this parameter is 5.
*/
public ConnectionPoolConfigurationBuilder maxPendingRequests(int maxPendingRequests) {
this.attributes.attribute(MAX_PENDING_REQUESTS).set(maxPendingRequests);
return this;
}
@Override
public void validate(GlobalConfiguration globalConfig) {
}
@Override
public ConnectionPoolConfiguration create() {
return new ConnectionPoolConfiguration(attributes.protect());
}
@Override
public ConnectionPoolConfigurationBuilder read(ConnectionPoolConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
}
| 7,498
| 43.636905
| 157
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/MechanismConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.persistence.remote.configuration.MechanismConfiguration.PASSWORD;
import static org.infinispan.persistence.remote.configuration.MechanismConfiguration.SASL_MECHANISM;
import static org.infinispan.persistence.remote.configuration.MechanismConfiguration.USERNAME;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class MechanismConfigurationBuilder extends AbstractSecurityConfigurationChildBuilder implements Builder<MechanismConfiguration> {
MechanismConfigurationBuilder(SecurityConfigurationBuilder builder) {
super(builder, MechanismConfiguration.attributeDefinitionSet());
}
public AttributeSet attributes() {
return attributes;
}
public MechanismConfigurationBuilder saslMechanism(String mechanism) {
this.attributes.attribute(SASL_MECHANISM).set(mechanism);
return this;
}
public MechanismConfigurationBuilder username(String username) {
this.attributes.attribute(USERNAME).set(username);
return this;
}
public MechanismConfigurationBuilder password(String password) {
this.attributes.attribute(PASSWORD).set(password);
return this;
}
public MechanismConfigurationBuilder password(char[] password) {
this.password(new String(password));
return this;
}
public MechanismConfigurationBuilder realm(String realm) {
this.attributes.attribute(MechanismConfiguration.REALM).set(realm);
return this;
}
@Override
public MechanismConfiguration create() {
return new MechanismConfiguration(attributes.protect());
}
@Override
public Builder<?> read(MechanismConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
}
| 1,970
| 31.85
| 137
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/ExecutorFactoryConfigurationBuilder.java
|
package org.infinispan.persistence.remote.configuration;
import static org.infinispan.commons.configuration.AbstractTypedPropertiesConfiguration.PROPERTIES;
import static org.infinispan.persistence.remote.configuration.ExecutorFactoryConfiguration.EXECUTOR_FACTORY;
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;
import org.infinispan.configuration.global.GlobalConfiguration;
/**
* Configures executor factory.
*/
public class ExecutorFactoryConfigurationBuilder extends AbstractRemoteStoreConfigurationChildBuilder<RemoteStoreConfigurationBuilder> implements Builder<ExecutorFactoryConfiguration> {
ExecutorFactoryConfigurationBuilder(RemoteStoreConfigurationBuilder builder) {
super(builder, ExecutorFactoryConfiguration.attributeDefinitionSet());
}
/**
* 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(EXECUTOR_FACTORY).set(factory);
return this;
}
public AttributeSet attributes() {
return attributes;
}
/**
* 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 ExecutorFactoryConfigurationBuilder addExecutorProperty(String key, String value) {
TypedProperties properties = attributes.attribute(PROPERTIES).get();
properties.put(key, value);
attributes.attribute(PROPERTIES).set(properties);
return this;
}
/**
* Set key/value properties to this executor factory configuration
*
* @param props
* Properties
* @return this ExecutorFactoryConfig
*/
public ExecutorFactoryConfigurationBuilder withExecutorProperties(Properties props) {
attributes.attribute(PROPERTIES).set(TypedProperties.toTypedProperties(props));
return this;
}
@Override
public void validate() {
// No-op, no validation required
}
@Override
public void validate(GlobalConfiguration globalConfig) {
}
@Override
public ExecutorFactoryConfiguration create() {
return new ExecutorFactoryConfiguration(attributes.protect());
}
@Override
public ExecutorFactoryConfigurationBuilder read(ExecutorFactoryConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public String toString() {
return "ExecutorFactoryConfigurationBuilder [attributes=" + attributes + "]";
}
}
| 3,239
| 32.75
| 185
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/configuration/ExecutorFactoryConfiguration.java
|
package org.infinispan.persistence.remote.configuration;
import org.infinispan.commons.configuration.AbstractTypedPropertiesConfiguration;
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.executors.ExecutorFactory;
import org.infinispan.executors.DefaultExecutorFactory;
public class ExecutorFactoryConfiguration extends AbstractTypedPropertiesConfiguration {
static final AttributeDefinition<ExecutorFactory> EXECUTOR_FACTORY = AttributeDefinition.builder(Attribute.FACTORY, null, ExecutorFactory.class)
.initializer(DefaultExecutorFactory::new)
.serializer(AttributeSerializer.INSTANCE_CLASS_NAME)
.immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(ExecutorFactoryConfiguration.class, AbstractTypedPropertiesConfiguration.attributeSet(), EXECUTOR_FACTORY);
};
ExecutorFactoryConfiguration(AttributeSet attributes) {
super(attributes);
}
public ExecutorFactory factory() {
return attributes.attribute(EXECUTOR_FACTORY).get();
}
@Override
public String toString() {
return "ExecutorFactoryConfiguration [attributes=" + attributes + "]";
}
public AttributeSet attributes() {
return attributes;
}
}
| 1,442
| 36.973684
| 147
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/wrapper/HotRodEntryMarshaller.java
|
package org.infinispan.persistence.remote.wrapper;
import java.io.IOException;
import java.util.Arrays;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.io.ByteBuffer;
import org.infinispan.commons.io.ByteBufferFactory;
import org.infinispan.commons.marshall.BufferSizePredictor;
import org.infinispan.commons.marshall.Marshaller;
/**
* HotRodEntryMarshaller.
*
* @author Tristan Tarrant
* @since 5.2
* @deprecated Use {@link org.infinispan.commons.marshall.IdentityMarshaller} instead.
*/
@Deprecated
public class HotRodEntryMarshaller implements Marshaller {
private final ByteBufferFactory byteBufferFactory;
BufferSizePredictor predictor = new IdentityBufferSizePredictor();
public HotRodEntryMarshaller(ByteBufferFactory byteBufferFactory) {
this.byteBufferFactory = byteBufferFactory;
}
@Override
public byte[] objectToByteBuffer(Object obj, int estimatedSize) throws IOException, InterruptedException {
return (byte[]) obj;
}
@Override
public byte[] objectToByteBuffer(Object obj) throws IOException, InterruptedException {
return (byte[]) obj;
}
@Override
public Object objectFromByteBuffer(byte[] buf) throws IOException, ClassNotFoundException {
return buf;
}
@Override
public Object objectFromByteBuffer(byte[] buf, int offset, int length) throws IOException, ClassNotFoundException {
return Arrays.copyOfRange(buf, offset, offset + length);
}
@Override
public ByteBuffer objectToBuffer(Object o) throws IOException, InterruptedException {
byte[] b = (byte[]) o;
return byteBufferFactory.newByteBuffer(b, 0, b.length);
}
@Override
public boolean isMarshallable(Object o) throws Exception {
return o instanceof byte[];
}
@Override
public BufferSizePredictor getBufferSizePredictor(Object o) {
return predictor;
}
@Override
public MediaType mediaType() {
return MediaType.APPLICATION_JBOSS_MARSHALLING;
}
class IdentityBufferSizePredictor implements BufferSizePredictor {
@Override
public int nextSize(Object obj) {
return ((byte[]) obj).length;
}
@Override
public void recordSize(int previousSize) {
// NOOP
}
}
}
| 2,288
| 26.25
| 118
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/logging/Log.java
|
package org.infinispan.persistence.remote.logging;
import static org.infinispan.util.logging.Log.LOG_ROOT;
import static org.jboss.logging.Logger.Level.INFO;
import static org.jboss.logging.Logger.Level.WARN;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.dataconversion.MediaType;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
/**
* Log abstraction for the remote cache store. For this module, message ids
* ranging from 10001 to 11000 inclusively have been reserved.
*
* @author Galder Zamarreño
* @since 5.0
*/
@MessageLogger(projectCode = "ISPN")
public interface Log extends BasicLogger {
Log CONFIG = Logger.getMessageLogger(Log.class, LOG_ROOT + "CONFIG");
@Message(value = "Could not find migration data in cache %s", id = 276)
CacheException missingMigrationData(String name);
@LogMessage(level = WARN)
@Message(value = "Could not migrate key %s", id = 277)
void keyMigrationFailed(String key, @Cause Throwable cause);
@LogMessage(level = INFO)
@Message(value = "Ignoring XML attribute %s, please remove from configuration file", id = 293)
void ignoreXmlAttribute(Object attribute);
@Message(value = "Could not migrate data for cache %s, check remote store config in the target cluster. Make sure only one remote store is present and is pointing to the source cluster", id = 397)
CacheException couldNotMigrateData(String name);
@Message(value = "Cannot enable HotRod wrapping if a marshaller and/or an entryWrapper have already been set", id = 10005)
CacheConfigurationException cannotEnableHotRodWrapping();
@Message(value = "The RemoteCacheStore for cache %s should be configured with hotRodWrapping enabled", id = 10007)
CacheException remoteStoreNoHotRodWrapping(String cacheName);
@Message(value = "RemoteStore only supports segmentation when using at least protocol version %s or higher", id = 10008)
CacheConfigurationException segmentationNotSupportedInThisVersion(ProtocolVersion version);
@Message(value = "A RemoteStore must be shared in a cache that is clustered", id = 10009)
CacheConfigurationException clusteredRequiresBeingShared();
@Message(value = "Segmentation is not supported for a RemoteStore when the configured segments %d do not match the remote servers amount %s", id = 10010)
CacheConfigurationException segmentationRequiresEqualSegments(int cacheSegmentCount, Integer serverSegmentCount);
@Message(value = "Segmentation is not supported for a RemoteStore when the configured key media type %s does not match the remote servers key media type %s", id = 10011)
CacheConfigurationException segmentationRequiresEqualMediaTypes(MediaType cacheMediaType, MediaType serverMediaType);
@Message(value = "The RemoteCacheStore cannot be segmented when grouping is enabled", id = 10012)
CacheConfigurationException segmentationNotSupportedWithGroups();
}
| 3,233
| 49.53125
| 199
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/MigrationTask.java
|
package org.infinispan.persistence.remote.upgrade;
import static java.util.Spliterators.spliteratorUnknownSize;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.BitSet;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.StreamSupport;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.cache.impl.InvocationHelper;
import org.infinispan.client.hotrod.MetadataValue;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.commands.CommandsFactory;
import org.infinispan.commands.write.ComputeCommand;
import org.infinispan.commons.dataconversion.ByteArrayWrapper;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.util.CloseableIterator;
import org.infinispan.commons.util.EnumUtil;
import org.infinispan.commons.util.Util;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.context.Flag;
import org.infinispan.context.InvocationContext;
import org.infinispan.distribution.ch.KeyPartitioner;
import org.infinispan.encoding.DataConversion;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.factories.threads.BlockingThreadFactory;
import org.infinispan.factories.threads.DefaultThreadFactory;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.metadata.Metadata;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved;
import org.infinispan.notifications.cachelistener.event.CacheEntryRemovedEvent;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.remote.ExternalizerIds;
import org.infinispan.persistence.remote.RemoteStore;
import org.infinispan.persistence.remote.logging.Log;
import org.infinispan.util.logging.LogFactory;
public class MigrationTask implements Function<EmbeddedCacheManager, Integer> {
private static final Log log = LogFactory.getLog(MigrationTask.class, Log.class);
private static final String THREAD_NAME = "RollingUpgrade-MigrationTask";
private final String cacheName;
private final Set<Integer> segments;
private final int readBatch;
private final int threads;
private final Set<Object> deletedKeys = ConcurrentHashMap.newKeySet();
private InvocationHelper invocationHelper;
private CommandsFactory commandsFactory;
private KeyPartitioner keyPartitioner;
public MigrationTask(String cacheName, Set<Integer> segments, int readBatch, int threads) {
this.cacheName = cacheName;
this.segments = segments;
this.readBatch = readBatch;
this.threads = threads;
}
@Override
public Integer apply(EmbeddedCacheManager embeddedCacheManager) {
AtomicInteger counter = new AtomicInteger(0);
DefaultThreadFactory threadFactory = new BlockingThreadFactory(null, 1, THREAD_NAME + "-%t", null, null);
ExecutorService executorService = Executors.newFixedThreadPool(threads, threadFactory);
RemoveListener listener = null;
AdvancedCache<Object, Object> advancedCache = embeddedCacheManager.getCache(cacheName).getAdvancedCache();
Cache cache = advancedCache.withStorageMediaType();
try {
ComponentRegistry cr = cache.getAdvancedCache().getComponentRegistry();
invocationHelper = cr.getComponent(InvocationHelper.class);
commandsFactory = cr.getCommandsFactory();
keyPartitioner = cr.getComponent(KeyPartitioner.class);
PersistenceManager loaderManager = cr.getComponent(PersistenceManager.class);
Set<RemoteStore<Object, Object>> stores = (Set) loaderManager.getStores(RemoteStore.class);
listener = new RemoveListener();
cache.addFilteredListener(listener, new RemovedFilter<>(), null, Util.asSet(CacheEntryRemoved.class));
Iterator<RemoteStore<Object, Object>> storeIterator = stores.iterator();
if (storeIterator.hasNext()) {
RemoteStore<Object, Object> store = storeIterator.next();
RemoteCache<Object, Object> storeCache = store.getRemoteCache();
migrateEntriesWithMetadata(storeCache, counter, executorService, cache);
}
} finally {
if (listener != null) {
cache.removeListener(listener);
}
executorService.shutdown();
}
return counter.get();
}
@Listener(clustered = true)
@SuppressWarnings("unused")
private class RemoveListener {
@CacheEntryRemoved
public void entryRemoved(CacheEntryRemovedEvent event) {
deletedKeys.add(ByteArrayWrapper.INSTANCE.wrap(event.getKey()));
}
}
private void migrateEntriesWithMetadata(RemoteCache<Object, Object> sourceCache, AtomicInteger counter,
ExecutorService executorService, Cache<Object, Object> cache) {
AdvancedCache<Object, Object> destinationCache = cache.getAdvancedCache();
DataConversion keyDataConversion = destinationCache.getKeyDataConversion();
DataConversion valueDataConversion = destinationCache.getValueDataConversion();
try (CloseableIterator<Entry<Object, MetadataValue<Object>>> iterator = sourceCache.retrieveEntriesWithMetadata(segments, readBatch)) {
CompletableFuture<?>[] completableFutures = StreamSupport.stream(spliteratorUnknownSize(iterator, 0), false)
.map(entry -> {
Object key = entry.getKey();
MetadataValue<Object> metadataValue = entry.getValue();
int lifespan = metadataValue.getLifespan();
int maxIdle = metadataValue.getMaxIdle();
long version = metadataValue.getVersion();
Metadata metadata = new EmbeddedMetadata.Builder()
.version(new NumericVersion(version))
.lifespan(lifespan, TimeUnit.SECONDS)
.maxIdle(maxIdle, TimeUnit.SECONDS)
.build();
if (!deletedKeys.contains(ByteArrayWrapper.INSTANCE.wrap(key))) {
return CompletableFuture.supplyAsync(() -> {
int currentCount = counter.incrementAndGet();
if (log.isDebugEnabled() && currentCount % 100 == 0)
log.debugf(">> Migrated %s entries\n", currentCount);
return writeToDestinationCache(entry, metadata, keyDataConversion, valueDataConversion);
}, executorService);
}
return CompletableFuture.completedFuture(null);
}).toArray(CompletableFuture[]::new);
CompletableFuture.allOf(completableFutures).join();
}
}
private Object writeToDestinationCache(Entry<Object, MetadataValue<Object>> entry, Metadata metadata, DataConversion keyDataConversion, DataConversion valueDataConversion) {
Object key = keyDataConversion.toStorage(entry.getKey());
Object value = valueDataConversion.toStorage(entry.getValue().getValue());
int segment = keyPartitioner.getSegment(key);
long flags = EnumUtil.bitSetOf(Flag.SKIP_CACHE_LOAD, Flag.ROLLING_UPGRADE);
ComputeCommand computeCommand = commandsFactory.buildComputeCommand(key, new EntryWriter<>(value), false, segment, metadata, flags);
InvocationContext context = invocationHelper.createInvocationContextWithImplicitTransaction(1, true);
return invocationHelper.invoke(context, computeCommand);
}
public static class Externalizer extends AbstractExternalizer<MigrationTask> {
@Override
public Set<Class<? extends MigrationTask>> getTypeClasses() {
return Collections.singleton(MigrationTask.class);
}
@Override
public void writeObject(ObjectOutput output, MigrationTask task) throws IOException {
output.writeObject(task.cacheName);
UnsignedNumeric.writeUnsignedInt(output, task.readBatch);
UnsignedNumeric.writeUnsignedInt(output, task.threads);
BitSet bs = new BitSet();
for (Integer segment : task.segments) {
bs.set(segment);
}
byte[] bytes = bs.toByteArray();
UnsignedNumeric.writeUnsignedInt(output, bytes.length);
output.write(bs.toByteArray());
}
@Override
public MigrationTask readObject(ObjectInput input) throws IOException, ClassNotFoundException {
String cacheName = (String) input.readObject();
int readBatch = UnsignedNumeric.readUnsignedInt(input);
int threads = UnsignedNumeric.readUnsignedInt(input);
int segmentsSize = UnsignedNumeric.readUnsignedInt(input);
byte[] bytes = new byte[segmentsSize];
input.read(bytes);
BitSet bitSet = BitSet.valueOf(bytes);
Set<Integer> segments = bitSet.stream().boxed().collect(Collectors.toSet());
return new MigrationTask(cacheName, segments, readBatch, threads);
}
}
public static class EntryWriter<K, V> implements BiFunction<K, V, V> {
private final V newEntry;
public EntryWriter(V newEntry) {
this.newEntry = newEntry;
}
@Override
public V apply(K k, V v) {
return v == null ? newEntry : v;
}
}
public static class EntryWriterExternalizer extends AbstractExternalizer<EntryWriter> {
@Override
public Set<Class<? extends EntryWriter>> getTypeClasses() {
return Collections.singleton(EntryWriter.class);
}
@Override
public Integer getId() {
return ExternalizerIds.ENTRY_WRITER;
}
@Override
public void writeObject(ObjectOutput output, EntryWriter object) throws IOException {
output.writeObject(object.newEntry);
}
@Override
public EntryWriter readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object newEntry = input.readObject();
return new EntryWriter(newEntry);
}
}
}
| 10,604
| 43.1875
| 176
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/HotRodTargetMigrator.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.persistence.remote.upgrade.HotRodMigratorHelper.DEFAULT_READ_BATCH_SIZE;
import static org.infinispan.persistence.remote.upgrade.HotRodMigratorHelper.range;
import static org.infinispan.persistence.remote.upgrade.HotRodMigratorHelper.split;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.infinispan.Cache;
import org.infinispan.client.hotrod.CacheTopologyInfo;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.util.ProcessorInfo;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.manager.ClusterExecutor;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.remote.RemoteStore;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration;
import org.infinispan.persistence.remote.logging.Log;
import org.infinispan.remoting.transport.Address;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.upgrade.TargetMigrator;
import org.infinispan.util.function.TriConsumer;
import org.infinispan.util.logging.LogFactory;
import org.kohsuke.MetaInfServices;
@MetaInfServices
public class HotRodTargetMigrator implements TargetMigrator {
private static final Log log = LogFactory.getLog(HotRodTargetMigrator.class, Log.class);
public HotRodTargetMigrator() {
}
@Override
public String getName() {
return "hotrod";
}
@Override
public long synchronizeData(final Cache<Object, Object> cache) throws CacheException {
return synchronizeData(cache, DEFAULT_READ_BATCH_SIZE, ProcessorInfo.availableProcessors());
}
@Override
@SuppressWarnings("rawtypes")
public long synchronizeData(Cache<Object, Object> cache, int readBatch, int threads) throws CacheException {
ComponentRegistry cr = SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache());
PersistenceManager loaderManager = cr.getComponent(PersistenceManager.class);
Set<RemoteStore> stores = loaderManager.getStores(RemoteStore.class);
String cacheName = cache.getName();
if (stores.size() != 1) {
throw log.couldNotMigrateData(cacheName);
}
RemoteStore store = stores.iterator().next();
final RemoteCache remoteSourceCache = store.getRemoteCache();
ClusterExecutor clusterExecutor = SecurityActions.getClusterExecutor(cache.getCacheManager());
clusterExecutor = clusterExecutor.timeout(Long.MAX_VALUE, TimeUnit.NANOSECONDS).singleNodeSubmission();
CacheTopologyInfo sourceCacheTopologyInfo = remoteSourceCache.getCacheTopologyInfo();
if (sourceCacheTopologyInfo.getSegmentsPerServer().size() == 1) {
return migrateFromSingleServer(cache.getCacheManager(), cacheName, readBatch, threads);
}
int sourceSegments = sourceCacheTopologyInfo.getNumSegments();
List<Address> targetServers = cache.getAdvancedCache().getDistributionManager().getCacheTopology().getMembers();
List<List<Integer>> partitions = split(range(sourceSegments), targetServers.size());
Iterator<Address> iterator = targetServers.iterator();
AtomicInteger count = new AtomicInteger();
TriConsumer<Address, Integer, Throwable> consumer = (a, value, t) -> {
if (t != null) {
throw new CacheException(t);
}
count.addAndGet(value);
};
CompletableFuture[] futures = new CompletableFuture[partitions.size()];
int offset = 0;
for (List<Integer> partition : partitions) {
Set<Integer> segmentSet = new HashSet<>(partition);
futures[offset++] = clusterExecutor
.filterTargets(Collections.singleton(iterator.next()))
.submitConsumer(new MigrationTask(cacheName, segmentSet, readBatch, threads), consumer);
}
CompletableFuture.allOf(futures).join();
return count.get();
}
private long migrateFromSingleServer(EmbeddedCacheManager embeddedCacheManager, String cacheName, int readBatch, int threads) {
MigrationTask migrationTask = new MigrationTask(cacheName, null, readBatch, threads);
try {
return migrationTask.apply(embeddedCacheManager);
} catch (Exception e) {
throw new CacheException(e);
}
}
@Override
public void disconnectSource(Cache<Object, Object> cache) throws CacheException {
DisconnectRemoteStoreTask disconnectRemoteStoreTask = new DisconnectRemoteStoreTask(cache.getName());
ClusterExecutor executor = SecurityActions.getClusterExecutor(cache.getCacheManager());
CompletableFuture<Void> future = executor.submitConsumer(disconnectRemoteStoreTask, (address, v, t) -> {
if (t != null) {
throw new CacheException(t);
}
});
CompletableFuture.allOf(future).join();
}
@Override
public void connectSource(Cache<Object, Object> cache, StoreConfiguration configuration) {
AddSourceRemoteStoreTask addStoreTask = new AddSourceRemoteStoreTask(cache.getName(), (RemoteStoreConfiguration) configuration);
ClusterExecutor executor = SecurityActions.getClusterExecutor(cache.getCacheManager());
CompletableFuture<Void> future = executor.submitConsumer(addStoreTask, (address, v, t) -> {
if (t != null) {
throw new CacheException(t);
}
});
CompletableFuture.allOf(future).join();
}
@Override
public boolean isConnected(Cache<Object, Object> cache) {
ClusterExecutor executor = SecurityActions.getClusterExecutor(cache.getCacheManager());
ConcurrentMap<Address, Boolean> responses = new ConcurrentHashMap<>();
CompletableFuture<Void> future = executor.submitConsumer(new CheckRemoteStoreTask(cache.getName()), (address, result, error) -> {
if (error != null) throw new CacheException(error);
responses.put(address, result);
});
CompletableFuture.allOf(future).join();
return responses.values().stream().reduce(true, (v1, v2) -> v1 & v2);
}
}
| 6,526
| 44.013793
| 135
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/RemovedFilter.java
|
package org.infinispan.persistence.remote.upgrade;
import java.io.ObjectInput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.marshall.exts.NoStateExternalizer;
import org.infinispan.metadata.Metadata;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilter;
import org.infinispan.notifications.cachelistener.filter.EventType;
public class RemovedFilter<K, V> implements CacheEventFilter<K, V> {
@Override
public boolean accept(Object key, Object oldValue, Metadata oldMetadata, Object newValue, Metadata newMetadata,
EventType eventType) {
return eventType.isRemove();
}
@Override
public MediaType format() {
return null;
}
public static class Externalizer extends NoStateExternalizer<RemovedFilter> {
@Override
public Set<Class<? extends RemovedFilter>> getTypeClasses() {
return Collections.singleton(RemovedFilter.class);
}
@Override
public RemovedFilter readObject(ObjectInput input) {
return new RemovedFilter();
}
}
}
| 1,157
| 28.692308
| 114
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/HotRodMigratorHelper.java
|
package org.infinispan.persistence.remote.upgrade;
import java.util.ArrayList;
import java.util.List;
/**
* @author gustavonalle
* @since 8.2
*/
public class HotRodMigratorHelper {
static final int DEFAULT_READ_BATCH_SIZE = 10000;
static List<Integer> range(int end) {
List<Integer> integers = new ArrayList<>();
for (int i = 0; i < end; i++) {
integers.add(i);
}
return integers;
}
static <T> List<List<T>> split(List<T> list, final int parts) {
List<List<T>> subLists = new ArrayList<>(parts);
for (int i = 0; i < parts; i++) {
subLists.add(new ArrayList<T>());
}
for (int i = 0; i < list.size(); i++) {
subLists.get(i % parts).add(list.get(i));
}
return subLists;
}
}
| 780
| 23.40625
| 66
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/DisconnectRemoteStoreTask.java
|
package org.infinispan.persistence.remote.upgrade;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import java.util.function.Function;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.remote.RemoteStore;
import org.infinispan.persistence.remote.logging.Log;
import org.infinispan.util.concurrent.CompletionStages;
import org.infinispan.util.logging.LogFactory;
/**
* Cluster task to remove the remote store from a set a caches
*
* @since 12.1
*/
public class DisconnectRemoteStoreTask implements Function<EmbeddedCacheManager, Void> {
private static final Log log = LogFactory.getLog(DisconnectRemoteStoreTask.class, Log.class);
private final String cacheName;
public DisconnectRemoteStoreTask(String cacheName) {
this.cacheName = cacheName;
}
@Override
public Void apply(EmbeddedCacheManager embeddedCacheManager) {
ComponentRegistry cr = embeddedCacheManager.getCache(cacheName).getAdvancedCache().getComponentRegistry();
PersistenceManager persistenceManager = cr.getComponent(PersistenceManager.class);
try {
log.debugf("Disconnecting source for cache {}", cacheName);
return CompletionStages.join(persistenceManager.disableStore(RemoteStore.class.getName()));
} catch (Exception e) {
throw new CacheException(e);
}
}
public static class Externalizer extends AbstractExternalizer<DisconnectRemoteStoreTask> {
@Override
public Set<Class<? extends DisconnectRemoteStoreTask>> getTypeClasses() {
return Collections.singleton(DisconnectRemoteStoreTask.class);
}
@Override
public void writeObject(ObjectOutput output, DisconnectRemoteStoreTask task) throws IOException {
output.writeObject(task.cacheName);
}
@Override
public DisconnectRemoteStoreTask readObject(ObjectInput input) throws IOException, ClassNotFoundException {
String cacheName = (String) input.readObject();
return new DisconnectRemoteStoreTask(cacheName);
}
}
}
| 2,371
| 34.402985
| 113
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/SerializationUtils.java
|
package org.infinispan.persistence.remote.upgrade;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import org.infinispan.commons.configuration.io.ConfigurationResourceResolvers;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.io.StringBuilderWriter;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ParserRegistry;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfigurationBuilder;
/**
* Utilities to parse and serialize {@link RemoteStoreConfiguration} to and from JSON.
*
* @since 13.0
*/
public final class SerializationUtils {
private static final ParserRegistry parserRegistry = new ParserRegistry();
private static final String PLACEHOLDER = "cache-holder";
private SerializationUtils() {
}
public static String toJson(RemoteStoreConfiguration configuration) {
ConfigurationBuilder builder = new ConfigurationBuilder();
RemoteStoreConfigurationBuilder storeBuilder = builder.persistence().addStore(RemoteStoreConfigurationBuilder.class);
storeBuilder.read(configuration);
StringBuilderWriter sw = new StringBuilderWriter();
try (ConfigurationWriter w = ConfigurationWriter.to(sw).withType(APPLICATION_JSON).build()) {
parserRegistry.serialize(w, null, builder.build());
}
return Json.read(sw.toString()).at("local-cache").at("persistence").toString();
}
public static RemoteStoreConfiguration fromJson(String json) throws IOException {
ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder();
holder.newConfigurationBuilder(PLACEHOLDER);
try (ByteArrayInputStream bais = new ByteArrayInputStream(json.getBytes(UTF_8))) {
ConfigurationBuilderHolder parsedHolder = parserRegistry.parse(bais, holder, ConfigurationResourceResolvers.DEFAULT, APPLICATION_JSON);
Configuration parsedConfig = parsedHolder.getNamedConfigurationBuilders().get(PLACEHOLDER).build();
return (RemoteStoreConfiguration) parsedConfig.persistence().stores().iterator().next();
}
}
}
| 2,561
| 46.444444
| 144
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/CheckRemoteStoreTask.java
|
package org.infinispan.persistence.remote.upgrade;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.remote.RemoteStore;
/**
* Task to check for the remote store in a cache.
*
* @since 13.0
*/
public class CheckRemoteStoreTask implements Function<EmbeddedCacheManager, Boolean> {
private final String cacheName;
public CheckRemoteStoreTask(String cacheName) {
this.cacheName = cacheName;
}
@Override
@SuppressWarnings("rawtypes")
public Boolean apply(EmbeddedCacheManager embeddedCacheManager) {
ComponentRegistry cr = embeddedCacheManager.getCache(cacheName).getAdvancedCache().getComponentRegistry();
PersistenceManager persistenceManager = cr.getComponent(PersistenceManager.class);
try {
List<RemoteStore> stores = new ArrayList<>(persistenceManager.getStores(RemoteStore.class));
return stores.size() == 1;
} catch (Exception e) {
throw new CacheException(e);
}
}
public static class Externalizer extends AbstractExternalizer<CheckRemoteStoreTask> {
@Override
public Set<Class<? extends CheckRemoteStoreTask>> getTypeClasses() {
return Collections.singleton(CheckRemoteStoreTask.class);
}
@Override
public void writeObject(ObjectOutput output, CheckRemoteStoreTask task) throws IOException {
output.writeObject(task.cacheName);
}
@Override
public CheckRemoteStoreTask readObject(ObjectInput input) throws IOException, ClassNotFoundException {
String cacheName = (String) input.readObject();
return new CheckRemoteStoreTask(cacheName);
}
}
}
| 2,118
| 33.177419
| 112
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/upgrade/AddSourceRemoteStoreTask.java
|
package org.infinispan.persistence.remote.upgrade;
import static org.infinispan.persistence.remote.upgrade.SerializationUtils.fromJson;
import static org.infinispan.persistence.remote.upgrade.SerializationUtils.toJson;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import java.util.function.Function;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.remote.RemoteStore;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration;
import org.infinispan.util.concurrent.CompletionStages;
/**
* Task to add a remote store to the cache.
*
* @since 13.0
*/
public class AddSourceRemoteStoreTask implements Function<EmbeddedCacheManager, Void> {
private final String cacheName;
private final RemoteStoreConfiguration storeConfiguration;
public AddSourceRemoteStoreTask(String cacheName, RemoteStoreConfiguration storeConfiguration) {
this.cacheName = cacheName;
this.storeConfiguration = storeConfiguration;
}
@Override
public Void apply(EmbeddedCacheManager embeddedCacheManager) {
ComponentRegistry cr = embeddedCacheManager.getCache(cacheName).getAdvancedCache().getComponentRegistry();
PersistenceManager persistenceManager = cr.getComponent(PersistenceManager.class);
try {
if (persistenceManager.getStores(RemoteStore.class).isEmpty()) {
return CompletionStages.join(persistenceManager.addStore(storeConfiguration));
}
return null;
} catch (Exception e) {
throw new CacheException(e);
}
}
public static class Externalizer extends AbstractExternalizer<AddSourceRemoteStoreTask> {
@Override
public Set<Class<? extends AddSourceRemoteStoreTask>> getTypeClasses() {
return Collections.singleton(AddSourceRemoteStoreTask.class);
}
@Override
public void writeObject(ObjectOutput output, AddSourceRemoteStoreTask task) throws IOException {
output.writeObject(task.cacheName);
output.writeObject(toJson(task.storeConfiguration));
}
@Override
public AddSourceRemoteStoreTask readObject(ObjectInput input) throws IOException, ClassNotFoundException {
String cacheName = (String) input.readObject();
String config = (String) input.readObject();
return new AddSourceRemoteStoreTask(cacheName, fromJson(config));
}
}
}
| 2,714
| 37.785714
| 112
|
java
|
null |
infinispan-main/persistence/remote/src/main/java/org/infinispan/persistence/remote/internal/RemoteStoreBlockHoundIntegration.java
|
package org.infinispan.persistence.remote.internal;
import org.infinispan.client.hotrod.impl.transport.netty.ChannelFactory;
import org.infinispan.commons.internal.CommonsBlockHoundIntegration;
import org.kohsuke.MetaInfServices;
import reactor.blockhound.BlockHound;
import reactor.blockhound.integration.BlockHoundIntegration;
@MetaInfServices
public class RemoteStoreBlockHoundIntegration implements BlockHoundIntegration {
@Override
public void applyTo(BlockHound.Builder builder) {
// TODO: this needs to be moved to the client hotrod module when it adds BlockHound
// https://issues.redhat.com/browse/ISPN-12180
builder.allowBlockingCallsInside("org.infinispan.client.hotrod.impl.transport.netty.ChannelInitializer", "initSsl");
CommonsBlockHoundIntegration.allowPublicMethodsToBlock(builder, ChannelFactory.class);
}
}
| 862
| 42.15
| 122
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/ManagedConnectionFactoryTest.java
|
package org.infinispan.persistence.jdbc;
import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import org.infinispan.persistence.BaseNonBlockingStoreTest;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.SimpleConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.test.jndi.DummyContextFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* @author Mircea.Markus@jboss.com
*/
@Test(groups = "functional")
public abstract class ManagedConnectionFactoryTest extends BaseNonBlockingStoreTest {
private DummyDataSource ds;
@BeforeClass
public void bindDatasourceInJndi() throws Exception {
System.setProperty(Context.INITIAL_CONTEXT_FACTORY, DummyContextFactory.class.getName());
ds = new DummyDataSource();
ds.start();
InitialContext ic = new InitialContext();
ic.bind(getDatasourceLocation(), ds);
assert ic.lookup(getDatasourceLocation()) instanceof DummyDataSource;
}
public abstract String getDatasourceLocation();
@AfterClass(alwaysRun = true)
public void destroyDatasourceAndUnbind() throws NamingException {
InitialContext ic = new InitialContext();
ic.unbind(getDatasourceLocation());
assert ic.lookup(getDatasourceLocation()) == null;
ds.stop();
}
public static class DummyDataSource implements DataSource {
private SimpleConnectionFactory simpleFactory;
public void start() throws PersistenceException {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = TestCacheManagerFactory
.getDefaultCacheConfiguration(false)
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
simpleFactory = new SimpleConnectionFactory();
simpleFactory.start(UnitTestDatabaseManager.configureSimpleConnectionFactory(storeBuilder).create(), Thread.currentThread().getContextClassLoader());
}
public void stop() {
simpleFactory.stop();
}
@Override
public Connection getConnection() throws SQLException {
try {
return simpleFactory.getConnection();
} catch (PersistenceException e) {
throw new SQLException(e);
}
}
@Override
public Connection getConnection(String username, String password) throws SQLException {
return getConnection();
}
@Override
public PrintWriter getLogWriter() throws SQLException {
throw new IllegalStateException("This should not be called!");
}
@Override
public void setLogWriter(PrintWriter out) throws SQLException {
throw new IllegalStateException("This should not be called!");
}
@Override
public void setLoginTimeout(int seconds) throws SQLException {
throw new IllegalStateException("This should not be called!");
}
@Override
public int getLoginTimeout() throws SQLException {
throw new IllegalStateException("This should not be called!");
}
@Override
public <T> T unwrap(Class<T> iface) throws SQLException {
throw new IllegalStateException("This should not be called!");
}
@Override
public boolean isWrapperFor(Class<?> iface) throws SQLException {
throw new IllegalStateException("This should not be called!");
}
public Logger getParentLogger() {
throw new IllegalStateException("This should not be called!");
}
}
}
| 3,960
| 32.285714
| 158
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/JdbcStoreCompatibilityTest.java
|
package org.infinispan.persistence.jdbc;
import java.io.File;
import java.nio.file.Paths;
import java.util.HashMap;
import java.util.Map;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.AbstractPersistenceCompatibilityTest;
import org.infinispan.persistence.IdentityKeyValueWrapper;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.stringbased.JdbcStringBasedStore;
import org.infinispan.test.data.Value;
import org.testng.annotations.Test;
/**
* Tests if {@link JdbcStringBasedStore} can migrate data from Infinispan 10.1.x.
*
* @author Pedro Ruivo
* @since 11.0
*/
@Test(groups = "functional", testName = "persistence.jdbc.JdbcStoreCompatibilityTest")
public class JdbcStoreCompatibilityTest extends AbstractPersistenceCompatibilityTest<Value> {
private static final String DB_FILE_NAME = "jdbc_db.mv.db";
private static final Map<Version, String> data = new HashMap<>(2);
static {
data.put(Version._10_1, "10_1_x_jdbc_data");
data.put(Version._11_0, "11_0_x_jdbc_data");
}
public JdbcStoreCompatibilityTest() {
super(IdentityKeyValueWrapper.instance());
}
// The jdbc store should still be able to migrate data from 10.x stream
@Test
public void testReadWriteFrom101() throws Exception {
oldVersion = Version._10_1;
doTestReadWrite();
}
@Test
public void testReadWriteFrom11() throws Exception {
beforeStartCache();
doTestReadWrite();
}
protected void beforeStartCache() throws Exception {
new File(tmpDirectory).mkdirs();
copyFile(combinePath(data.get(oldVersion), DB_FILE_NAME), Paths.get(tmpDirectory), DB_FILE_NAME);
}
@Override
protected String cacheName() {
return "jdbc_store_cache";
}
@Override
protected void configurePersistence(ConfigurationBuilder builder, boolean generatingData) {
JdbcStringBasedStoreConfigurationBuilder jdbcB = builder.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
jdbcB.segmented(oldSegmented);
jdbcB.table()
.createOnStart(generatingData)
.tableNamePrefix("ISPN_STRING_TABLE")
.idColumnName("ID_COLUMN").idColumnType("VARCHAR(255)")
.dataColumnName("DATA_COLUMN").dataColumnType("BINARY VARYING")
.timestampColumnName("TIMESTAMP_COLUMN").timestampColumnType("BIGINT")
.segmented(false);
jdbcB.connectionPool()
.driverClass(org.h2.Driver.class)
//-1 = never closed (== thread leak reported at the end), 0 = close when all connection are closed
.connectionUrl(String.format("jdbc:h2:%s;DB_CLOSE_DELAY=0", combinePath(tmpDirectory, "jdbc_db")))
.username("sa");
}
}
| 2,860
| 34.320988
| 110
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/IracJDBCStoreTest.java
|
package org.infinispan.persistence.jdbc;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.IdentityKeyValueWrapper;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.stringbased.JdbcStringBasedStore;
import org.infinispan.xsite.irac.persistence.BaseIracPersistenceTest;
import org.testng.annotations.Test;
/**
* Tests if the IRAC metadata is properly stored and retrieved from a {@link JdbcStringBasedStore}.
*
* @author Pedro Ruivo
* @since 11.0
*/
@Test(groups = "functional", testName = "persistence.jdbc.IracJDBCStoreTest")
public class IracJDBCStoreTest extends BaseIracPersistenceTest<String> {
public IracJDBCStoreTest() {
super(IdentityKeyValueWrapper.instance());
}
@Override
protected void configure(ConfigurationBuilder builder) {
JdbcStringBasedStoreConfigurationBuilder jdbcBuilder = builder.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
UnitTestDatabaseManager.buildTableManipulation(jdbcBuilder.table());
UnitTestDatabaseManager.configureUniqueConnectionFactory(jdbcBuilder);
}
}
| 1,214
| 38.193548
| 99
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/UnitTestDatabaseManager.java
|
package org.infinispan.persistence.jdbc;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import org.infinispan.persistence.jdbc.common.JdbcUtil;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.TableManipulationConfigurationBuilder;
import org.infinispan.persistence.jdbc.impl.table.TableName;
/**
* Class that assures concurrent access to the in memory database.
*
* @author Mircea.Markus@jboss.com
* @author Navin Surtani (<a href="mailto:nsurtani@redhat.com">nsurtani@redhat.com</a>)
* @author Tristan Tarrant
*/
public class UnitTestDatabaseManager extends org.infinispan.persistence.jdbc.common.UnitTestDatabaseManager {
public static void buildTableManipulation(TableManipulationConfigurationBuilder<?, ?> table) {
table
.tableNamePrefix("ISPN_STRING")
.idColumnName("ID_COLUMN")
.idColumnType("VARCHAR(255)")
.dataColumnName("DATA_COLUMN")
.dataColumnType("BLOB")
.timestampColumnName("TIMESTAMP_COLUMN")
.timestampColumnType("BIGINT")
.segmentColumnName("SEGMENT_COLUMN")
.segmentColumnType("INTEGER");
}
/**
* Counts the number of rows in the given table.
*/
public static int rowCount(ConnectionFactory connectionFactory, TableName tableName) {
Connection conn = null;
PreparedStatement statement = null;
ResultSet resultSet = null;
try {
conn = connectionFactory.getConnection();
String sql = "SELECT count(*) FROM " + tableName;
statement = conn.prepareStatement(sql);
resultSet = statement.executeQuery();
resultSet.next();
return resultSet.getInt(1);
} catch (Exception ex) {
throw new RuntimeException(ex);
} finally {
org.infinispan.persistence.jdbc.common.JdbcUtil.safeClose(resultSet);
JdbcUtil.safeClose(statement);
connectionFactory.releaseConnection(conn);
}
}
}
| 2,091
| 35.068966
| 109
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/TableManagerTest.java
|
package org.infinispan.persistence.jdbc;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Random;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.marshall.TestObjectStreamMarshaller;
import org.infinispan.persistence.DummyInitializationContext;
import org.infinispan.persistence.jdbc.common.JdbcUtil;
import org.infinispan.persistence.jdbc.common.configuration.ConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.configuration.PooledConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.configuration.SimpleConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.PooledConnectionFactory;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.SimpleConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfiguration;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.jdbc.impl.table.TableManagerFactory;
import org.infinispan.persistence.jdbc.impl.table.TableName;
import org.infinispan.persistence.spi.InitializationContext;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* Tester class for {@link TableManager}.
*
* @author Mircea.Markus@jboss.com
* @author Ryan Emerson
*/
@Test(groups = "functional", testName = "persistence.jdbc.TableManagerTest")
public class TableManagerTest extends AbstractInfinispanTest {
protected ConnectionFactory connectionFactory;
protected Connection connection;
protected TableManager tableManager;
protected InitializationContext ctx;
@BeforeClass
public void createConnection() throws Exception {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = TestCacheManagerFactory
.getDefaultCacheConfiguration(false)
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
UnitTestDatabaseManager.setDialect(storeBuilder);
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
ConnectionFactoryConfiguration factoryConfiguration = UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder).create();
if (factoryConfiguration instanceof SimpleConnectionFactoryConfiguration) {
SimpleConnectionFactoryConfiguration simpleConfiguration = (SimpleConnectionFactoryConfiguration)
factoryConfiguration;
connectionFactory = ConnectionFactory.getConnectionFactory(SimpleConnectionFactory.class);
connectionFactory.start(simpleConfiguration, connectionFactory.getClass().getClassLoader());
connection = connectionFactory.getConnection();
} else if (factoryConfiguration instanceof PooledConnectionFactoryConfiguration) {
PooledConnectionFactoryConfiguration pooledConfiguration = (PooledConnectionFactoryConfiguration)
factoryConfiguration;
connectionFactory = ConnectionFactory.getConnectionFactory(PooledConnectionFactory.class);
connectionFactory.start(pooledConfiguration, connectionFactory.getClass().getClassLoader());
connection = connectionFactory.getConnection();
}
Cache<?, ?> cache = mock(Cache.class);
when(cache.getCacheConfiguration()).thenReturn(new ConfigurationBuilder().build());
JdbcStringBasedStoreConfiguration config = storeBuilder.create();
GlobalConfiguration globalConfiguration = mock(GlobalConfiguration.class);
when(globalConfiguration.classLoader()).thenReturn(getClass().getClassLoader());
ctx = new DummyInitializationContext(config, cache, new TestObjectStreamMarshaller(), null, null, null, globalConfiguration, null, null, null);
tableManager = TableManagerFactory.getManager(ctx, connectionFactory, config, "aName");
}
@AfterClass(alwaysRun = true)
public void closeConnection() throws SQLException {
connection.close();
connectionFactory.stop();
}
public void testConnectionLeakGuessDialect() {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = TestCacheManagerFactory
.getDefaultCacheConfiguration(false)
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
PooledConnectionFactory connectionFactory = new PooledConnectionFactory();
ConnectionFactoryConfiguration config = UnitTestDatabaseManager
.configureUniqueConnectionFactory(storeBuilder).create();
connectionFactory.start(config, Thread.currentThread().getContextClassLoader());
// JdbcStringBasedStoreConfiguration defaults to null dialect, so dialect and versions must be guessed
TableManager tableManager = TableManagerFactory.getManager(ctx, connectionFactory, storeBuilder.create(), "GuessDialect");
tableManager.start();
UnitTestDatabaseManager.verifyConnectionLeaks(connectionFactory);
tableManager.stop();
connectionFactory.stop();
}
public void testCreateTable() throws Exception {
assert !existsTable(connection, tableManager.getDataTableName());
assert !existsTable(connection, tableManager.getMetaTableName());
tableManager.createDataTable(connection);
tableManager.createMetaTable(connection);
assert existsTable(connection, tableManager.getDataTableName());
assert existsTable(connection, tableManager.getMetaTableName());
}
@Test(dependsOnMethods = "testCreateTable")
public void testExists() throws PersistenceException {
assert tableManager.tableExists(connection, tableManager.getDataTableName());
assert tableManager.tableExists(connection, tableManager.getMetaTableName());
assert !tableManager.tableExists(connection, new TableName("\"", "", "does_not_exist"));
}
@Test(dependsOnMethods = "testExists")
public void testDrop() throws Exception {
TableName dataTableName = tableManager.getDataTableName();
TableName metaTableName = tableManager.getMetaTableName();
assert tableManager.tableExists(connection, dataTableName);
assert tableManager.tableExists(connection, metaTableName);
byte[] data = new byte[64];
new Random().nextBytes(data);
PreparedStatement ps = null;
try {
ps = connection.prepareStatement("INSERT INTO " + tableManager.getDataTableName() + "(ID_COLUMN, DATA_COLUMN, TIMESTAMP_COLUMN, SEGMENT_COLUMN) values(?, ?, ?, ?)");
ps.setString(1, System.currentTimeMillis() + "");
ps.setBytes(2, data);
ps.setLong(3, System.currentTimeMillis());
ps.setLong(4, 1);
assert 1 == ps.executeUpdate();
} finally {
org.infinispan.persistence.jdbc.common.JdbcUtil.safeClose(ps);
}
tableManager.dropTables(connection);
assert !tableManager.tableExists(connection, dataTableName);
assert !tableManager.tableExists(connection, metaTableName);
}
public void testTableQuoting() throws Exception {
TableName dataTableName = tableManager.getDataTableName();
tableManager.dropDataTable(connection);
assert !existsTable(connection, dataTableName);
tableManager.createDataTable(connection);
assert existsTable(connection, tableManager.getDataTableName());
}
static boolean existsTable(Connection connection, TableName tableName) throws Exception {
Statement st = connection.createStatement();
ResultSet rs = null;
try {
rs = st.executeQuery("select * from " + tableName);
return true;
} catch (SQLException e) {
return false;
} finally {
org.infinispan.persistence.jdbc.common.JdbcUtil.safeClose(rs);
JdbcUtil.safeClose(st);
}
}
}
| 8,500
| 47.577143
| 174
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/TableNameUniquenessTest.java
|
package org.infinispan.persistence.jdbc;
import static org.testng.AssertJUnit.assertEquals;
import java.io.Serializable;
import java.sql.Connection;
import java.util.Objects;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.manager.CacheContainer;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfiguration;
import org.infinispan.persistence.jdbc.impl.table.TableName;
import org.infinispan.persistence.jdbc.stringbased.JdbcStringBasedStore;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.persistence.support.WaitDelegatingNonBlockingStore;
import org.infinispan.persistence.support.WaitNonBlockingStore;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Test to make sure that no two caches will use the same table for storing data.
*
* @author Mircea.Markus@jboss.com
*/
@Test(groups = "functional", testName = "persistence.jdbc.TableNameUniquenessTest")
public class TableNameUniquenessTest extends AbstractInfinispanTest {
public void testForJdbcStringBasedCacheStore() throws Exception {
CacheContainer cm = null;
try {
cm = TestCacheManagerFactory.fromXml("configs/all/string-based.xml");
Cache<String, String> first = cm.getCache("first");
Cache<String, String> second = cm.getCache("second");
StoreConfiguration firstCacheLoaderConfig = first.getCacheConfiguration().persistence().stores().get(0);
StoreConfiguration secondCacheLoaderConfig = second.getCacheConfiguration().persistence().stores().get(0);
assertEquals(JdbcStringBasedStoreConfiguration.class, firstCacheLoaderConfig.getClass());
assertEquals(JdbcStringBasedStoreConfiguration.class, secondCacheLoaderConfig.getClass());
WaitDelegatingNonBlockingStore<String, String> firstCs = TestingUtil.getFirstStoreWait(first);
WaitDelegatingNonBlockingStore<String, String> secondCs = TestingUtil.getFirstStoreWait(second);
JdbcStringBasedStore<String, String> firstJdbcS = (JdbcStringBasedStore<String, String> ) firstCs.delegate();
assertTableExistence(firstJdbcS.getConnectionFactory().getConnection(), firstJdbcS.getTableManager().getIdentifierQuoteString(),
"second", "first", "ISPN_STRING_TABLE");
assertNoOverlapingState(first, second, firstCs, secondCs);
} finally {
TestingUtil.killCacheManagers(cm);
}
}
static class Person implements Serializable {
int age;
String name;
private static final long serialVersionUID = 4227565864228124235L;
Person(int age, String name) {
this.age = age;
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof Person)) return false;
Person person = (Person) o;
if (age != person.age) return false;
return Objects.equals(name, person.name);
}
@Override
public int hashCode() {
int result = age;
result = 31 * result + (name != null ? name.hashCode() : 0);
return result;
}
}
private void assertTableExistence(Connection connection, String identifierQuote, String secondTable, String firstTable, String tablePrefix) throws Exception {
assert !TableManagerTest.existsTable(connection, new TableName(identifierQuote, tablePrefix, "")) : "this table should not exist!";
assert TableManagerTest.existsTable(connection, new TableName(identifierQuote, tablePrefix, firstTable));
assert TableManagerTest.existsTable(connection, new TableName(identifierQuote, tablePrefix, secondTable));
connection.close();
}
private void assertNoOverlapingState(Cache<String, String> first, Cache<String, String> second,
WaitNonBlockingStore<String, String> firstCs,
WaitNonBlockingStore<String, String> secondCs) throws PersistenceException {
first.put("k", "v");
assert firstCs.contains("k");
assert !secondCs.contains("k");
assert first.get("k").equals("v");
assert second.get("k") == null;
second.put("k2", "v2");
assert second.get("k2").equals("v2");
assert first.get("k2") == null;
}
}
| 4,522
| 40.87963
| 161
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/PooledConnectionFactoryTest.java
|
package org.infinispan.persistence.jdbc;
import java.sql.Connection;
import java.util.HashSet;
import java.util.Set;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.persistence.jdbc.common.configuration.ConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.configuration.ConnectionFactoryConfigurationBuilder;
import org.infinispan.persistence.jdbc.common.configuration.PooledConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.PooledConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Tester class for {@link PooledConnectionFactory}.
*
* @author Mircea.Markus@jboss.com
* @author Tristan Tarrant
*/
@Test(groups = "functional", testName = "persistence.jdbc.PooledConnectionFactoryTest")
public class PooledConnectionFactoryTest {
private PooledConnectionFactory factory;
private JdbcStringBasedStoreConfigurationBuilder storeBuilder;
private ConnectionFactoryConfigurationBuilder<?> factoryBuilder;
private PooledConnectionFactoryConfiguration customFactoryConfiguration;
public PooledConnectionFactoryTest() {}
//Invoked from external resource
@SuppressWarnings("unused")
public PooledConnectionFactoryTest(PooledConnectionFactoryConfiguration customFactoryConfiguration) {
this.customFactoryConfiguration = customFactoryConfiguration;
}
@BeforeMethod
public void beforeMethod() {
factory = new PooledConnectionFactory();
}
@AfterMethod
public void destroyFactory() {
factory.stop();
}
@Test
public void testValuesNoOverrides() throws Exception {
storeBuilder = TestCacheManagerFactory
.getDefaultCacheConfiguration(false)
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
if(customFactoryConfiguration != null) {
factoryBuilder = storeBuilder.connectionPool().read(customFactoryConfiguration, Combine.DEFAULT);
} else {
// We load agroal.properties to enable metrics and ensure that property file loading works as expected
factoryBuilder = storeBuilder.connectionPool().propertyFile("src/test/resources/configs/agroal.properties");
}
ConnectionFactoryConfiguration factoryConfiguration = factoryBuilder.create();
factory.start(factoryConfiguration, Thread.currentThread().getContextClassLoader());
int hardcodedMaxPoolSize = factory.getMaxPoolSize();
assert hardcodedMaxPoolSize == 20;
Set<Connection> connections = new HashSet<>();
for (int i = 0; i < hardcodedMaxPoolSize; i++) {
connections.add(factory.getConnection());
}
assert connections.size() == hardcodedMaxPoolSize;
assert factory.getActiveConnections() == hardcodedMaxPoolSize;
for (Connection conn : connections) {
conn.close();
}
long start = System.currentTimeMillis();
while (System.currentTimeMillis() - start < 2000) {
if (factory.getActiveConnections() == 0)
break;
}
//this must happen eventually
assert factory.getActiveConnections() == 0;
}
@Test(expectedExceptions = PersistenceException.class)
public void testNoDriverClassFound() {
storeBuilder = TestCacheManagerFactory
.getDefaultCacheConfiguration(false)
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
factoryBuilder = UnitTestDatabaseManager.configureBrokenConnectionFactory(storeBuilder);
ConnectionFactoryConfiguration factoryConfiguration = factoryBuilder.create();
factory.start(factoryConfiguration, Thread.currentThread().getContextClassLoader());
}
}
| 4,036
| 39.777778
| 117
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/TableNameTest.java
|
package org.infinispan.persistence.jdbc;
import static org.testng.Assert.assertEquals;
import org.infinispan.persistence.jdbc.impl.table.TableName;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "persistence.jdbc.TableNameTest")
public class TableNameTest {
private static final String IDENTIFIER_QUOTE = "\"";
@BeforeClass
public void beforeClass(){
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void testNullType(){
new TableName(null, "", "");
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void testNullPrefix(){
new TableName(IDENTIFIER_QUOTE, null, "");
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void testNullName(){
new TableName(IDENTIFIER_QUOTE, "", null);
}
@Test(expectedExceptions = IllegalArgumentException.class)
public void testEmptySchema(){
TableName tableName = new TableName(IDENTIFIER_QUOTE, ".ISPN", "FOOBAR");
assertEquals(tableName.getSchema(), "");
}
public void testSchema(){
TableName tableName = new TableName(IDENTIFIER_QUOTE, "TEST.ISPN", "FOOBAR");
assertEquals(tableName.getSchema(), "TEST");
assertEquals(tableName.getName(), "ISPN_FOOBAR");
assertEquals(tableName.toString(), "\"TEST\".\"ISPN_FOOBAR\"");
tableName = new TableName(IDENTIFIER_QUOTE, "ISPN", "FOOBAR");
assertEquals(tableName.getSchema(), null);
assertEquals(tableName.getName(), "ISPN_FOOBAR");
assertEquals(tableName.toString(), "\"ISPN_FOOBAR\"");
}
public void testName(){
TableName tableName = new TableName(IDENTIFIER_QUOTE, "ISPN", "FOOBäR");
assertEquals(tableName.toString(), "\"ISPN_FOOB_R\"");
}
}
| 1,811
| 30.789474
| 83
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/configuration/ConfigurationTest.java
|
package org.infinispan.persistence.jdbc.configuration;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.common.configuration.ManagedConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.configuration.PooledConnectionFactoryConfiguration;
import org.testng.annotations.Test;
@Test(groups = "unit", testName = "persistence.jdbc.configuration.ConfigurationTest")
public class ConfigurationTest {
private static final String JDBC_URL = "jdbc:h2:mem:infinispan;DB_CLOSE_DELAY=-1";
public void testImplicitPooledConnectionFactory() {
ConfigurationBuilder b = new ConfigurationBuilder();
JdbcStringBasedStoreConfigurationBuilder jdbc = b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class);
UnitTestDatabaseManager.buildTableManipulation(jdbc.table());
jdbc
.connectionPool().connectionUrl(JDBC_URL);
Configuration configuration = b.build();
JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0);
assert store.connectionFactory() instanceof PooledConnectionFactoryConfiguration;
}
public void testImplicitManagedConnectionFactory() {
ConfigurationBuilder b = new ConfigurationBuilder();
JdbcStringBasedStoreConfigurationBuilder jdbc = b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class);
UnitTestDatabaseManager.buildTableManipulation(jdbc.table());
jdbc.dataSource().jndiUrl("java:jboss/datasources/ExampleDS");
Configuration configuration = b.build();
JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0);
assert store.connectionFactory() instanceof ManagedConnectionFactoryConfiguration;
}
public void testJdbcStringCacheStoreConfigurationAdaptor() {
ConfigurationBuilder b = new ConfigurationBuilder();
b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.connectionPool()
.connectionUrl(JDBC_URL)
.fetchPersistentState(true)
.table()
.tableNamePrefix("STRINGS_")
.idColumnName("id").idColumnType("VARCHAR")
.dataColumnName("datum").dataColumnType("BINARY")
.timestampColumnName("version").timestampColumnType("BIGINT")
.segmentColumnName("segfault").segmentColumnType("BIGINT")
.async().enable();
Configuration configuration = b.build();
JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0);
assertTrue(store.connectionFactory() instanceof PooledConnectionFactoryConfiguration);
assertEquals(JDBC_URL, ((PooledConnectionFactoryConfiguration) store.connectionFactory()).connectionUrl());
assertEquals("STRINGS_", store.table().tableNamePrefix());
assertEquals("id", store.table().idColumnName());
assertEquals("VARCHAR", store.table().idColumnType());
assertEquals("datum", store.table().dataColumnName());
assertEquals("BINARY", store.table().dataColumnType());
assertEquals("version", store.table().timestampColumnName());
assertEquals("BIGINT", store.table().timestampColumnType());
assertEquals("segfault", store.table().segmentColumnName());
assertEquals("BIGINT", store.table().segmentColumnType());
assertTrue(store.async().enabled());
b = new ConfigurationBuilder();
b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class).read(store, Combine.DEFAULT);
Configuration configuration2 = b.build();
JdbcStringBasedStoreConfiguration store2 = (JdbcStringBasedStoreConfiguration) configuration2.persistence().stores().get(0);
assertTrue(store2.connectionFactory() instanceof PooledConnectionFactoryConfiguration);
assertEquals(JDBC_URL, ((PooledConnectionFactoryConfiguration) store2.connectionFactory()).connectionUrl());
assertEquals("STRINGS_", store2.table().tableNamePrefix());
assertEquals("id", store2.table().idColumnName());
assertEquals("VARCHAR", store2.table().idColumnType());
assertEquals("datum", store2.table().dataColumnName());
assertEquals("BINARY", store2.table().dataColumnType());
assertEquals("version", store2.table().timestampColumnName());
assertEquals("BIGINT", store2.table().timestampColumnType());
assertEquals("segfault", store2.table().segmentColumnName());
assertEquals("BIGINT", store2.table().segmentColumnType());
assertTrue(store2.async().enabled());
}
public void testTableProperties() {
ConfigurationBuilder b = new ConfigurationBuilder();
JdbcStringBasedStoreConfigurationBuilder jdbc = b.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class);
UnitTestDatabaseManager.buildTableManipulation(jdbc.table());
jdbc
.table().createOnStart(false).dropOnExit(true)
.connectionPool().connectionUrl(JDBC_URL);
Configuration stringConfiguration = b.build();
JdbcStringBasedStoreConfiguration stringStoreConfiguration = (JdbcStringBasedStoreConfiguration) stringConfiguration.persistence().stores().get(0);
assertFalse(stringStoreConfiguration.table().createOnStart());
assertTrue(stringStoreConfiguration.table().dropOnExit());
}
}
| 5,766
| 56.09901
| 153
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/configuration/ConfigurationSerializerTest.java
|
package org.infinispan.persistence.jdbc.configuration;
import static org.testng.AssertJUnit.assertEquals;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.configuration.serializer.AbstractConfigurationSerializerTest;
import org.infinispan.persistence.jdbc.common.configuration.AbstractJdbcStoreConfiguration;
import org.testng.annotations.Test;
@Test(testName = "persistence.jdbc.configuration.ConfigurationSerializerTest", groups = "functional")
public class ConfigurationSerializerTest extends AbstractConfigurationSerializerTest {
@Override
protected void compareStoreConfiguration(String name, StoreConfiguration beforeStore, StoreConfiguration afterStore) {
if (beforeStore instanceof AbstractJdbcStoreConfiguration) {
AbstractJdbcStoreConfiguration before = (AbstractJdbcStoreConfiguration) beforeStore;
AbstractJdbcStoreConfiguration after = (AbstractJdbcStoreConfiguration) afterStore;
assertEquals("Configuration " + name + " JDBC connection factory", before.connectionFactory(), after.connectionFactory());
}
if (beforeStore instanceof JdbcStringBasedStoreConfiguration) {
JdbcStringBasedStoreConfiguration before = (JdbcStringBasedStoreConfiguration) beforeStore;
JdbcStringBasedStoreConfiguration after = (JdbcStringBasedStoreConfiguration) afterStore;
compareAttributeSets("Configuration " + name + " table", before.table().attributes(), after.table().attributes());
compareAttributeSets("Configuration " + name + " idColumn", before.table().idColumnConfiguration().attributes(), after.table().idColumnConfiguration().attributes());
compareAttributeSets("Configuration " + name + " dataColumn", before.table().dataColumnConfiguration().attributes(), after.table().dataColumnConfiguration().attributes());
compareAttributeSets("Configuration " + name + " timestampColumn", before.table().timeStampColumnConfiguration().attributes(), after.table().timeStampColumnConfiguration().attributes());
compareAttributeSets("Configuration " + name + " segmentColumn", before.table().segmentColumnConfiguration().attributes(), after.table().segmentColumnConfiguration().attributes());
}
super.compareStoreConfiguration(name, beforeStore, afterStore);
}
}
| 2,323
| 73.967742
| 195
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/configuration/XmlFileParsingTest.java
|
package org.infinispan.persistence.jdbc.configuration;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import org.infinispan.commons.util.Version;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.jdbc.common.DatabaseType;
import org.infinispan.persistence.jdbc.common.configuration.PooledConnectionFactoryConfiguration;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
@Test(groups = "unit", testName = "persistence.jdbc.configuration.XmlFileParsingTest")
public class XmlFileParsingTest extends AbstractInfinispanTest {
protected EmbeddedCacheManager cacheManager;
@AfterMethod
public void cleanup() {
TestingUtil.killCacheManagers(cacheManager);
}
public void testStringKeyedJdbcStore() throws Exception {
String config = TestingUtil.wrapXMLWithSchema(
" <cache-container default-cache=\"default\">\n" +
" <transport/>\n" +
" <distributed-cache name=\"default\">\n" +
" <persistence>\n" +
" <string-keyed-jdbc-store xmlns=\"urn:infinispan:config:store:jdbc:" + Version.getSchemaVersion() + "\" key-to-string-mapper=\"DummyKey2StringMapper\" shared=\"true\" " +
" preload=\"true\" read-only=\"false\" dialect=\"H2\">\n" +
" <connection-pool connection-url=\"jdbc:h2:mem:infinispan;DB_CLOSE_DELAY=-1\" username=\"dbuser\" password=\"dbpass\" driver=\"org.h2.Driver\"/>\n" +
" <string-keyed-table prefix=\"entry\" fetch-size=\"34\" batch-size=\"128\" >\n" +
" <id-column name=\"id\" type=\"VARCHAR\" />\n" +
" <data-column name=\"datum\" type=\"BINARY\" />\n" +
" <timestamp-column name=\"version\" type=\"BIGINT\" />\n" +
" <segment-column name=\"segfault\" type=\"BIGINT\" />\n" +
" </string-keyed-table>\n" +
" <write-behind />\n" +
" </string-keyed-jdbc-store>\n" +
" </persistence>\n" +
" </distributed-cache></cache-container>\n"
);
InputStream is = new ByteArrayInputStream(config.getBytes());
cacheManager = TestCacheManagerFactory.fromStream(is, true, false);
assertEquals(1, cacheManager.getDefaultCacheConfiguration().persistence().stores().size());
JdbcStringBasedStoreConfiguration store = (JdbcStringBasedStoreConfiguration) cacheManager.getDefaultCacheConfiguration().persistence().stores().get(0);
assertEquals(128, store.table().batchSize());
assertEquals(34, store.table().fetchSize());
assertEquals("BINARY", store.table().dataColumnType());
assertEquals("version", store.table().timestampColumnName());
assertEquals("segfault", store.table().segmentColumnName());
assertTrue(store.async().enabled());
assertEquals("DummyKey2StringMapper", store.key2StringMapper());
assertTrue(store.shared());
assertTrue(store.preload());
assertEquals(DatabaseType.H2, store.dialect());
PooledConnectionFactoryConfiguration connectionFactory = (PooledConnectionFactoryConfiguration) store.connectionFactory();
assertEquals("jdbc:h2:mem:infinispan;DB_CLOSE_DELAY=-1", connectionFactory.connectionUrl());
assertEquals("org.h2.Driver", connectionFactory.driverClass());
assertEquals("dbuser", connectionFactory.username());
assertEquals("dbpass", connectionFactory.password());
assertFalse(store.ignoreModifications());
assertFalse(store.purgeOnStartup());
}
}
| 4,043
| 52.92
| 195
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/configuration/DummyKey2StringMapper.java
|
package org.infinispan.persistence.jdbc.configuration;
import org.infinispan.persistence.keymappers.DefaultTwoWayKey2StringMapper;
public class DummyKey2StringMapper extends DefaultTwoWayKey2StringMapper {
}
| 211
| 25.5
| 75
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.BaseNonBlockingStoreTest;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* Tester class for {@link JdbcStringBasedStore}.
*
* @author William Burns
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreTest")
public class JdbcStringBasedStoreTest extends BaseNonBlockingStoreTest {
boolean segmented;
public JdbcStringBasedStoreTest segmented(boolean segmented) {
this.segmented = segmented;
return this;
}
@Factory
public Object[] factory() {
return new Object[] {
new JdbcStringBasedStoreTest().segmented(false),
new JdbcStringBasedStoreTest().segmented(true),
};
}
@Override
protected String parameters() {
return "[" + segmented + "]";
}
@Override
protected JdbcStringBasedStore createStore() throws Exception {
return new JdbcStringBasedStore();
}
@Override
protected Configuration buildConfig(ConfigurationBuilder configurationBuilder) {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = configurationBuilder
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
storeBuilder.segmented(segmented);
UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder);
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
return configurationBuilder.build();
}
}
| 1,823
| 32.163636
| 96
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreFunctionalTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import org.infinispan.configuration.cache.PersistenceConfigurationBuilder;
import org.infinispan.persistence.BaseStoreFunctionalTest;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.testng.annotations.Test;
@Test(groups = {"functional", "smoke"}, testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreFunctionalTest")
public class JdbcStringBasedStoreFunctionalTest extends BaseStoreFunctionalTest {
@Override
protected PersistenceConfigurationBuilder createCacheStoreConfig(PersistenceConfigurationBuilder persistence,
String cacheName, boolean preload) {
JdbcStringBasedStoreConfigurationBuilder store = persistence
.addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.preload(preload);
UnitTestDatabaseManager.buildTableManipulation(store.table());
UnitTestDatabaseManager.configureUniqueConnectionFactory(store);
modifyJdbcConfiguration(store);
return persistence;
}
protected void modifyJdbcConfiguration(JdbcStringBasedStoreConfigurationBuilder builder) {
}
}
| 1,237
| 43.214286
| 117
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/TwoWayPersonKey2StringMapper.java
|
package org.infinispan.persistence.jdbc.stringbased;
import java.util.StringTokenizer;
import org.infinispan.persistence.keymappers.TwoWayKey2StringMapper;
import org.infinispan.test.data.Address;
import org.infinispan.test.data.Person;
/**
* @author Mircea.Markus@jboss.com
* @since 4.1
*/
public class TwoWayPersonKey2StringMapper extends PersonKey2StringMapper implements TwoWayKey2StringMapper {
@Override
public Object getKeyMapping(String key) {
StringTokenizer tkz = new StringTokenizer(key, "_");
String name = tkz.nextToken();
if (!tkz.hasMoreTokens())
return new Person(name);
String street = tkz.nextToken();
String city = tkz.nextToken();
String zip = tkz.nextToken();
return new Person(name, new Address(street, city, Integer.parseInt(zip)));
}
}
| 828
| 28.607143
| 108
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringParallelIterationTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.ParallelIterationTest;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.testng.annotations.Test;
/**
* @author Mircea Markus
* @since 6.0
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.JdbcStringParallelIterationTest")
public class JdbcStringParallelIterationTest extends ParallelIterationTest {
@Override
protected void configurePersistence(ConfigurationBuilder cb) {
JdbcStringBasedStoreConfigurationBuilder storeBuilder =
cb.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class);
UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder);
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
}
}
| 990
| 38.64
| 103
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreMetaTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.infinispan.test.TestingUtil.withCacheManager;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertTrue;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManagerStartupException;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Test to ensure that JDBC meta table validation when loading existing stores.
*
* @author Ryan Emerson
* @since 12.0
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreMetaTest")
public class JdbcStringBasedStoreMetaTest extends AbstractInfinispanTest {
public void testSegmentCompatibility() {
// Create the original store
createCacheManager(true, 10);
try {
// Attempt to use the original store with a different number of segments
createCacheManager(false, 15);
} catch (EmbeddedCacheManagerStartupException e) {
assertNotNull(e);
Throwable cause = e.getCause();
assertNotNull(cause);
assertTrue(cause instanceof CacheConfigurationException);
}
}
private void createCacheManager(boolean createOnStart, int segments) {
ConfigurationBuilder cfg = TestCacheManagerFactory.getDefaultCacheConfiguration(false);
cfg.clustering().hash().numSegments(segments);
JdbcStringBasedStoreConfigurationBuilder store = cfg
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.fetchPersistentState(true);
store.table().createOnStart(createOnStart);
UnitTestDatabaseManager.buildTableManipulation(store.table());
store.simpleConnection()
.driverClass(org.h2.Driver.class)
.connectionUrl(String.format("jdbc:h2:mem:%s;DB_CLOSE_DELAY=-1", JdbcStringBasedStoreMetaTest.class))
.username("sa");
withCacheManager(() -> TestCacheManagerFactory.createCacheManager(cfg), Void -> {});
}
}
| 2,364
| 40.491228
| 113
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreVamAltMapperTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.infinispan.test.TestingUtil.extractPersistenceMarshaller;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* JdbcStringBasedStoreAltMapperTest using production level marshaller.
*
* @author Galder Zamarreño
* @since 4.0
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreVamAltMapperTest")
public class JdbcStringBasedStoreVamAltMapperTest extends JdbcStringBasedStoreAltMapperTest {
EmbeddedCacheManager cm;
PersistenceMarshaller marshaller;
@BeforeClass
@Override
public void createCacheStore() throws PersistenceException {
cm = TestCacheManagerFactory.createCacheManager(false);
marshaller = extractPersistenceMarshaller(cm);
super.createCacheStore();
}
@AfterClass
@Override
public void destroyStore() throws PersistenceException {
super.destroyStore();
cm.stop();
}
protected PersistenceMarshaller getMarshaller() {
return marshaller;
}
}
| 1,354
| 28.456522
| 108
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/StringStoreWithManagedConnectionTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertTrue;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.StoreConfiguration;
import org.infinispan.persistence.jdbc.ManagedConnectionFactoryTest;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.ManagedConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfiguration;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.support.WaitDelegatingNonBlockingStore;
import org.infinispan.test.CacheManagerCallable;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* @author Mircea.Markus@jboss.com
*/
@Test (groups = "functional", testName = "persistence.jdbc.stringbased.StringStoreWithManagedConnectionTest")
public class StringStoreWithManagedConnectionTest extends ManagedConnectionFactoryTest {
@Override
protected JdbcStringBasedStore<Object, Object> createStore() throws Exception {
return new JdbcStringBasedStore<>();
}
@Override
protected Configuration buildConfig(ConfigurationBuilder configurationBuilder) {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = configurationBuilder
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
storeBuilder.dataSource()
.jndiUrl(getDatasourceLocation());
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
return configurationBuilder.build();
}
public void testLoadFromFile() throws Exception {
TestingUtil.withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.fromXml("configs/managed/str-managed-connection-factory.xml"), true) {
@Override
public void call() {
Cache<String, String> first = cm.getCache("first");
Cache<String, String> second = cm.getCache("second");
StoreConfiguration firstCacheLoaderConfig = first.getCacheConfiguration().persistence().stores().get(0);
assertNotNull(firstCacheLoaderConfig);
assertTrue(firstCacheLoaderConfig instanceof JdbcStringBasedStoreConfiguration);
StoreConfiguration secondCacheLoaderConfig = second.getCacheConfiguration().persistence().stores().get(0);
assertNotNull(secondCacheLoaderConfig);
assertTrue(secondCacheLoaderConfig instanceof JdbcStringBasedStoreConfiguration);
WaitDelegatingNonBlockingStore loader = TestingUtil.getFirstStoreWait(first);
assertTrue(((JdbcStringBasedStore) loader.delegate()).getConnectionFactory() instanceof ManagedConnectionFactory);
}
});
}
@Override
public String getDatasourceLocation() {
return "java:/StringStoreWithManagedConnectionTest/DS";
}
@Override
protected boolean storePurgesAllExpired() {
return false;
}
}
| 3,275
| 43.876712
| 154
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/AbstractStringBasedCacheStore.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.infinispan.persistence.jdbc.UnitTestDatabaseManager.buildTableManipulation;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import static org.testng.AssertJUnit.assertNull;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.context.Flag;
import org.infinispan.eviction.EvictionType;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
import org.infinispan.persistence.DummyInitializationContext;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.configuration.TableManipulationConfiguration;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.jdbc.impl.table.TableManagerFactory;
import org.infinispan.persistence.spi.InitializationContext;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.AbstractStringBasedCacheStore")
public abstract class AbstractStringBasedCacheStore extends AbstractInfinispanTest {
protected EmbeddedCacheManager dcm;
protected ConnectionFactory connectionFactory;
protected TableManager tableManager;
protected TableManipulationConfiguration tableConfiguration;
protected Cache<String, String> cache;
@AfterMethod
public void cleanAfterEach() {
tableManager.stop();
connectionFactory.stop();
TestingUtil.killCacheManagers(dcm);
}
@Test
public void testPutGetRemoveWithoutPassivationWithPreload() throws Exception {
dcm = configureCacheManager(false, true, false);
cache = dcm.getCache();
assertCleanCacheAndStore(cache);
cache.put("k1", "v1");
cache.put("k2", "v2");
// test passivation==false, database should contain all entries which are in the cache
assertNotNull(getValueByKey("k1"));
assertNotNull(getValueByKey("k2"));
cache.stop();
cache.start();
assertNotNull(getValueByKey("k1"));
assertNotNull(getValueByKey("k2"));
assertEquals("v1", cache.get("k1"));
assertEquals("v2", cache.get("k2"));
// when the entry is removed from the cache, it should be also removed from the cache store (the store
// and the cache are the same sets of keys)
cache.remove("k1");
assertNull(cache.get("k1"));
assertNull(getValueByKey("k1"));
}
@Test
public void testPutGetRemoveWithPassivationWithoutPreload() throws Exception {
dcm = configureCacheManager(true, false, true);
cache = dcm.getCache();
assertCleanCacheAndStore(cache);
cache.put("k1", "v1");
cache.put("k2", "v2");
//not yet in store (eviction.max-entries=2)
assertNull(getValueByKey("k1"));
assertNull(getValueByKey("k2"));
cache.put("k3", "v3");
assertEquals("v3", cache.get("k3"));
//now some key is evicted and stored in store
assertEquals(2, cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD).size());
// Passivation is async
eventuallyEquals(1, () -> getAllRows().size());
//retrieve from store to cache and remove from store, another key must be evicted
cache.get("k1");
cache.get("k2");
assertEquals(2, cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD).size());
eventuallyEquals(1, () -> getAllRows().size());
cache.stop();
cache.start();
assertEquals(0, cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD).size());
// test purge==false, entries should remain in the database after restart
assertEquals(3, getAllRows().size());
assertNotNull(getValueByKey("k1"));
assertEquals("v1", cache.get("k1"));
cache.remove("k1");
assertNull(cache.get("k1"));
assertNull(getValueByKey("k1"));
}
public EmbeddedCacheManager configureCacheManager(boolean passivation, boolean preload, boolean eviction) {
GlobalConfigurationBuilder gcb = new GlobalConfigurationBuilder().nonClusteredDefault().defaultCacheName("StringBasedCache");
ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false);
JdbcStringBasedStoreConfigurationBuilder storeBuilder = builder
.persistence()
.passivation(passivation)
.addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.preload(preload);
connectionFactory = getConnectionFactory(storeBuilder);
setTableManipulation(storeBuilder);
if (eviction) {
builder.memory().evictionType(EvictionType.COUNT).size(2);
} else {
builder.memory().evictionType(EvictionType.COUNT).size(-1);
}
tableConfiguration = storeBuilder.create().table();
EmbeddedCacheManager defaultCacheManager = TestCacheManagerFactory.newDefaultCacheManager(true, gcb, builder);
String cacheName = defaultCacheManager.getCache().getName();
PersistenceMarshaller marshaller = defaultCacheManager.getCache().getAdvancedCache().getComponentRegistry().getPersistenceMarshaller();
InitializationContext ctx = new DummyInitializationContext(null, null, marshaller, null, null, null, null, null, null, null);
tableManager = TableManagerFactory.getManager(ctx, connectionFactory, storeBuilder.create(), cacheName);
return defaultCacheManager;
}
protected void setTableManipulation(JdbcStringBasedStoreConfigurationBuilder storeBuilder) {
buildTableManipulation(storeBuilder.table());
}
protected abstract ConnectionFactory getConnectionFactory(JdbcStringBasedStoreConfigurationBuilder storeBuilder);
protected void assertCleanCacheAndStore(Cache<String, String> cache) throws Exception {
cache.clear();
deleteAllRows();
assertEquals(0, cache.size());
assertNull(getValueByKey("k1"));
assertNull(getValueByKey("k2"));
}
public Object getValueByKey(String key) throws Exception {
Object result = null;
Connection connection = connectionFactory.getConnection();
PreparedStatement ps = connection.prepareStatement(tableManager.getSelectRowSql());
ps.setString(1, key);
ResultSet rs = ps.executeQuery();
if (rs.next()) {
result = rs.getObject(tableConfiguration.idColumnName()); //start from 1, not 0
}
connectionFactory.releaseConnection(connection);
return result;
}
private List<String> getAllRows() {
try {
Connection connection = connectionFactory.getConnection();
Statement s = connection.createStatement();
ResultSet rs = s.executeQuery(tableManager.getLoadAllRowsSql());
List<String> rows = new ArrayList<>();
while (rs.next()) {
rows.add(rs.toString());
}
connectionFactory.releaseConnection(connection);
return rows;
} catch (Throwable t) {
throw new AssertionError(t);
}
}
private void deleteAllRows() throws Exception {
Connection connection = connectionFactory.getConnection();
Statement s = connection.createStatement();
s.executeUpdate(tableManager.getDeleteAllSql());
connectionFactory.releaseConnection(connection);
}
@AfterMethod(alwaysRun = true)
public void tearDown() {
connectionFactory.stop();
}
}
| 8,430
| 40.945274
| 143
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreVamTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.infinispan.test.TestingUtil.extractPersistenceMarshaller;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* JdbcStringBasedStoreTest using production level marshaller.
*
* @author Galder Zamarreño
* @since 4.0
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreVamTest")
public class JdbcStringBasedStoreVamTest extends JdbcStringBasedStoreTest {
EmbeddedCacheManager cm;
PersistenceMarshaller marshaller;
@Factory
public Object[] factory() {
return new Object[] {
new JdbcStringBasedStoreVamTest().segmented(false),
new JdbcStringBasedStoreVamTest().segmented(true),
};
}
@BeforeClass
public void setUpClass() {
cm = TestCacheManagerFactory.createCacheManager(false);
marshaller = extractPersistenceMarshaller(cm.getCache().getCacheManager());
}
@AfterClass(alwaysRun = true)
public void tearDownClass() throws PersistenceException {
cm.stop();
}
@Override
protected PersistenceMarshaller getMarshaller() {
return marshaller;
}
}
| 1,510
| 28.627451
| 99
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/PersonKey2StringMapper.java
|
package org.infinispan.persistence.jdbc.stringbased;
import org.infinispan.persistence.keymappers.Key2StringMapper;
import org.infinispan.test.data.Address;
import org.infinispan.test.data.Person;
/**
* Used for testing jdbc cache stores.
*
* @author Mircea.Markus@jboss.com
*/
public class PersonKey2StringMapper implements Key2StringMapper {
public boolean isSupportedType(Class keyType) {
return keyType == Person.class;
}
public String getStringMapping(Object key) {
Person person = (Person) key;
Address addr = person.getAddress();
if (addr == null)
return person.getName();
return person.getName() + "_" + addr.getStreet() + "_" + addr.getCity() + "_" + addr.getZip();
}
}
| 738
| 27.423077
| 100
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/StringStoreWithPooledConnectionFunctionalTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.infinispan.persistence.jdbc.UnitTestDatabaseManager.configureUniqueConnectionFactory;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.persistence.jdbc.common.configuration.ConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.configuration.PooledConnectionFactoryConfiguration;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.PooledConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.StringStoreWithPooledConnectionFunctionalTest")
public class StringStoreWithPooledConnectionFunctionalTest extends AbstractStringBasedCacheStore {
private PooledConnectionFactoryConfiguration customFactoryConfiguration;
public StringStoreWithPooledConnectionFunctionalTest() {}
//Invoked from external resource
@SuppressWarnings("unused")
public StringStoreWithPooledConnectionFunctionalTest(PooledConnectionFactoryConfiguration customFactoryConfiguration) {
this.customFactoryConfiguration = customFactoryConfiguration;
}
@Override
public ConnectionFactory getConnectionFactory(JdbcStringBasedStoreConfigurationBuilder storeBuilder) {
ConnectionFactoryConfiguration connectionFactoryConfiguration;
if(customFactoryConfiguration != null) {
connectionFactoryConfiguration = storeBuilder.connectionPool().read(customFactoryConfiguration, Combine.DEFAULT).create();
} else {
connectionFactoryConfiguration = configureUniqueConnectionFactory(storeBuilder).create();
}
final ConnectionFactory connectionFactory = ConnectionFactory.getConnectionFactory(PooledConnectionFactory.class);
connectionFactory.start(connectionFactoryConfiguration, connectionFactory.getClass().getClassLoader());
return connectionFactory;
}
}
| 2,122
| 53.435897
| 134
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/NonStringKeyPreloadTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.infinispan.test.TestingUtil.clearCacheLoader;
import static org.infinispan.test.TestingUtil.withCacheManager;
import static org.testng.AssertJUnit.assertEquals;
import java.util.function.Consumer;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commons.CacheException;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestDataSCI;
import org.infinispan.test.data.Person;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Tester for https://jira.jboss.org/browse/ISPN-579.
*
* @author Mircea.Markus@jboss.com
* @since 4.1
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.NonStringKeyPreloadTest")
public class NonStringKeyPreloadTest extends AbstractInfinispanTest {
public void testPreloadWithKey2StringMapper() {
String mapperName = PersonKey2StringMapper.class.getName();
ConfigurationBuilder config = createCacheStoreConfig(mapperName, true);
withCacheManager(() -> TestCacheManagerFactory.createCacheManager(TestDataSCI.INSTANCE), cm -> {
try {
cm.createCache("invalidCache", config.build());
assert false : " Preload with Key2StringMapper is not supported. Specify an TwoWayKey2StringMapper if you want to support it (or disable preload).";
} catch (CacheException e) {
log.debugf("Ignoring expected exception", e);
}
});
}
public void testPreloadWithTwoWayKey2StringMapper() {
String mapperName = TwoWayPersonKey2StringMapper.class.getName();
ConfigurationBuilder config = createCacheStoreConfig(mapperName, true);
final Person mircea = new Person("Mircea");
final Person dan = new Person("Dan");
withCacheManagerConfig(config, cm -> {
Cache<Object, Object> cache = cm.getCache();
cache.put(mircea, "me");
cache.put(dan, "mate");
});
withCacheManagerConfig(config, cm -> {
Cache<Object, Object> cache = null;
try {
cache = cm.getCache();
assert cache.containsKey(mircea);
assert cache.containsKey(dan);
} finally {
clearCacheLoader(cache);
}
});
}
public void testPreloadWithTwoWayKey2StringMapperAndBoundedCache() {
String mapperName = TwoWayPersonKey2StringMapper.class.getName();
ConfigurationBuilder config = createCacheStoreConfig(mapperName, true);
config.memory().size(3);
withCacheManagerConfig(config, cm -> {
for (int i = 0; i < 10; i++)
cm.getCache().getAdvancedCache().put(new Person("name" + i), "" + i);
});
withCacheManagerConfig(config, cm -> {
AdvancedCache<Object, Object> cache = cm.getCache().getAdvancedCache();
assertEquals(3, cache.getDataContainer().size());
int found = 0;
for (int i = 0; i < 10; i++) {
Person p = new Person("name" + i);
if (cache.getDataContainer().containsKey(p)) {
found++;
}
}
assertEquals(3, found);
});
}
static ConfigurationBuilder createCacheStoreConfig(String mapperName, boolean preload) {
ConfigurationBuilder cfg = TestCacheManagerFactory.getDefaultCacheConfiguration(false);
JdbcStringBasedStoreConfigurationBuilder store = cfg
.persistence()
.connectionAttempts(1)
.addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.fetchPersistentState(true)
.preload(preload)
.key2StringMapper(mapperName);
UnitTestDatabaseManager.buildTableManipulation(store.table());
UnitTestDatabaseManager.configureUniqueConnectionFactory(store);
return cfg;
}
private void withCacheManagerConfig(ConfigurationBuilder config, Consumer<EmbeddedCacheManager> consumer) {
withCacheManager(() -> TestCacheManagerFactory.createCacheManager(TestDataSCI.INSTANCE, config), consumer);
}
}
| 4,391
| 37.867257
| 160
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreTxFunctionalTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNull;
import java.lang.reflect.Method;
import org.infinispan.Cache;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.test.ExceptionRunnable;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.transaction.TransactionMode;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
import jakarta.transaction.NotSupportedException;
import jakarta.transaction.SystemException;
import jakarta.transaction.TransactionManager;
@Test(groups = {"functional", "smoke"}, testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreTxFunctionalTest")
public class JdbcStringBasedStoreTxFunctionalTest extends JdbcStringBasedStoreFunctionalTest {
private boolean transactionalConfig;
private boolean sharedConfig;
@Factory
public Object[] factory() {
return new Object[]{
new JdbcStringBasedStoreTxFunctionalTest().transactionalConfig(true).sharedConfig(false),
new JdbcStringBasedStoreTxFunctionalTest().transactionalConfig(false).sharedConfig(false),
new JdbcStringBasedStoreTxFunctionalTest().transactionalConfig(true).sharedConfig(true),
new JdbcStringBasedStoreTxFunctionalTest().transactionalConfig(false).sharedConfig(true),
};
}
@Override
protected String parameters() {
return " [transactionalConfig=" + transactionalConfig + ", sharedConfig=" + sharedConfig + "]";
}
private JdbcStringBasedStoreTxFunctionalTest transactionalConfig(boolean transactionalConfig) {
this.transactionalConfig = transactionalConfig;
return this;
}
private JdbcStringBasedStoreTxFunctionalTest sharedConfig(boolean sharedConfig) {
this.sharedConfig = sharedConfig;
return this;
}
@Override
protected ConfigurationBuilder getDefaultCacheConfiguration() {
ConfigurationBuilder configurationBuilder = super.getDefaultCacheConfiguration();
configurationBuilder.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
if (sharedConfig) {
// Shared requires a clustered config, even though we have a single node
configurationBuilder.clustering().cacheMode(CacheMode.REPL_SYNC);
}
return configurationBuilder;
}
@Override
protected void modifyJdbcConfiguration(JdbcStringBasedStoreConfigurationBuilder builder) {
builder.transactional(transactionalConfig);
builder.shared(sharedConfig);
}
@Override
protected EmbeddedCacheManager createCacheManager(boolean start, GlobalConfigurationBuilder global,
ConfigurationBuilder cb) {
// Make sure defaults are transactional as well for created configs
if (transactionalConfig) {
cb.transaction().transactionMode(TransactionMode.TRANSACTIONAL);
}
if (sharedConfig) {
ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder(Thread.currentThread().getContextClassLoader(), global);
if (cb != null) {
String defaultName = JdbcStringBasedStoreTxFunctionalTest.class.getName() + "-default";
global.defaultCacheName(defaultName);
holder.newConfigurationBuilder(defaultName).read(cb.build(), Combine.DEFAULT);
}
global.transport().defaultTransport();
return TestCacheManagerFactory.createClusteredCacheManager(start, holder);
} else {
return super.createCacheManager(start, global, cb);
}
}
@Override
public void testRemoveCacheWithPassivation() {
// Shared and purgeOnStartup don't mix
// Transactional and passivation don't mix
if (!sharedConfig && !transactionalConfig) {
super.testRemoveCacheWithPassivation();
}
}
@Override
public void testStoreByteArrays(Method m) throws PersistenceException {
// Shared and purgeOnStartup don't mix
// Transactional and passivation don't mix
if (!sharedConfig && !transactionalConfig) {
super.testStoreByteArrays(m);
}
}
public void testWithPassivation(Method m) throws Exception {
ConfigurationBuilder base = getDefaultCacheConfiguration();
base.persistence().passivation(true);
ExceptionRunnable runnable = () -> TestingUtil.defineConfiguration(cacheManager, m.getName(), configureCacheLoader(base, m.getName(), false).build());
// transactional and shared don't mix with passivation
if (transactionalConfig || sharedConfig) {
Exceptions.expectException(CacheConfigurationException.class, runnable);
} else {
runnable.run();
}
}
public void testWithPurgeOnStartup(Method m) throws Exception {
ConfigurationBuilder base = getDefaultCacheConfiguration();
ExceptionRunnable runnable = () -> TestingUtil.defineConfiguration(cacheManager, m.getName(), configureCacheLoader(base, m.getName(), true).build());
// shared doesn't mix with purgeOnStartup
if (sharedConfig) {
Exceptions.expectException(CacheConfigurationException.class, runnable);
} else {
runnable.run();
}
}
public void testRollback() throws SystemException, NotSupportedException {
String cacheName = "testRollback";
ConfigurationBuilder cb = getDefaultCacheConfiguration();
createCacheStoreConfig(cb.persistence(), cacheName, false);
TestingUtil.defineConfiguration(cacheManager, cacheName, cb.build());
Cache<String, Object> cache = cacheManager.getCache(cacheName);
String key = "rollback-test";
assertNull(cache.get(key));
TransactionManager manager = cache.getAdvancedCache().getTransactionManager();
String value = "the-value";
manager.begin();
cache.put(key, value);
assertEquals(value, cache.get(key));
manager.rollback();
assertNull(cache.get(key));
}
}
| 6,604
| 39.521472
| 156
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/StringStoreWithManagedConnectionFunctionalTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.SimpleConnectionFactory;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.testng.annotations.Test;
import static org.infinispan.persistence.jdbc.UnitTestDatabaseManager.configureSimpleConnectionFactory;
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.StringStoreWithManagedConnectionFunctionalTest")
public class StringStoreWithManagedConnectionFunctionalTest extends AbstractStringBasedCacheStore {
@Override
protected ConnectionFactory getConnectionFactory(JdbcStringBasedStoreConfigurationBuilder storeBuilder) {
SimpleConnectionFactory simpleFactory = new SimpleConnectionFactory();
simpleFactory.start(configureSimpleConnectionFactory(storeBuilder).create(), Thread.currentThread().getContextClassLoader());
return simpleFactory;
}
}
| 1,063
| 52.2
| 133
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreAltMapperTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertNull;
import static org.testng.AssertJUnit.assertTrue;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.distribution.ch.impl.SingleSegmentKeyPartitioner;
import org.infinispan.marshall.TestObjectStreamMarshaller;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
import org.infinispan.marshall.persistence.impl.MarshalledEntryUtil;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.jdbc.impl.table.TableName;
import org.infinispan.persistence.keymappers.UnsupportedKeyTypeException;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.persistence.support.WaitDelegatingNonBlockingStore;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestDataSCI;
import org.infinispan.test.data.Person;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.test.fwk.TestInternalCacheEntryFactory;
import org.infinispan.util.PersistenceMockUtil;
import org.testng.annotations.AfterClass;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
/**
* Tester for {@link JdbcStringBasedStore} with an alternative {@link org.infinispan.persistence.keymappers.Key2StringMapper}.
*
* @author Mircea.Markus@jboss.com
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreAltMapperTest")
public class JdbcStringBasedStoreAltMapperTest extends AbstractInfinispanTest {
protected WaitDelegatingNonBlockingStore cacheStore;
protected TableManager tableManager;
protected static final Person MIRCEA = new Person("Mircea");
protected static final Person MANIK = new Person("Manik");
protected PersistenceMarshaller marshaller;
protected JdbcStringBasedStoreConfigurationBuilder createJdbcConfig(ConfigurationBuilder builder) {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = builder
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.key2StringMapper(PersonKey2StringMapper.class);
return storeBuilder;
}
@BeforeClass
public void createCacheStore() throws PersistenceException {
ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false);
JdbcStringBasedStoreConfigurationBuilder storeBuilder = createJdbcConfig(builder);
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder);
JdbcStringBasedStore jdbcStringBasedStore = new JdbcStringBasedStore();
cacheStore = new WaitDelegatingNonBlockingStore(jdbcStringBasedStore, SingleSegmentKeyPartitioner.getInstance());
marshaller = new TestObjectStreamMarshaller(TestDataSCI.INSTANCE);
cacheStore.startAndWait(PersistenceMockUtil.createContext(getClass(), builder.build(), marshaller));
tableManager = jdbcStringBasedStore.getTableManager();
}
@AfterMethod
public void clearStore() {
cacheStore.clear();
assertRowCount(0);
}
@AfterClass
public void destroyStore() throws PersistenceException {
cacheStore.stop();
marshaller.stop();
}
/**
* When trying to persist an unsupported object an exception is expected.
*/
public void persistUnsupportedObject() throws Exception {
CompletionStage<Void> stage = cacheStore.write(0, MarshalledEntryUtil.create("key", "value", marshaller));
Exceptions.expectCompletionException(UnsupportedKeyTypeException.class, stage);
//just check that an person object will be persisted okay
cacheStore.write(MarshalledEntryUtil.create(MIRCEA, "Cluj Napoca", marshaller));
}
public void testStoreLoadRemove() throws Exception {
assertRowCount(0);
assertNull("should not be present in the store", cacheStore.loadEntry(MIRCEA));
String value = "adsdsadsa";
cacheStore.write(MarshalledEntryUtil.create(MIRCEA, value, marshaller));
assertRowCount(1);
assertEquals(value, cacheStore.loadEntry(MIRCEA).getValue());
assertFalse(cacheStore.delete(MANIK));
assertEquals(value, cacheStore.loadEntry(MIRCEA).getValue());
assertRowCount(1);
assertTrue(cacheStore.delete(MIRCEA));
assertRowCount(0);
}
public void testClear() throws Exception {
assertRowCount(0);
cacheStore.write(MarshalledEntryUtil.create(MIRCEA, "value", marshaller));
cacheStore.write(MarshalledEntryUtil.create(MANIK, "value", marshaller));
assertRowCount(2);
cacheStore.clear();
assertRowCount(0);
}
public void testPurgeExpired() throws Exception {
InternalCacheEntry first = TestInternalCacheEntryFactory.create(MIRCEA, "val", 1000);
InternalCacheEntry second = TestInternalCacheEntryFactory.create(MANIK, "val2");
cacheStore.write(MarshalledEntryUtil.create(first, marshaller));
cacheStore.write(MarshalledEntryUtil.create(second, marshaller));
assertRowCount(2);
Thread.sleep(1100);
cacheStore.purge();
assertRowCount(1);
assertEquals("val2", cacheStore.loadEntry(MANIK).getValue());
}
protected int rowCount() {
ConnectionFactory connectionFactory = getConnection();
TableName tableName = tableManager.getDataTableName();
return UnitTestDatabaseManager.rowCount(connectionFactory, tableName);
}
protected ConnectionFactory getConnection() {
JdbcStringBasedStore store = (JdbcStringBasedStore) cacheStore.delegate();
return store.getConnectionFactory();
}
protected void assertRowCount(int size) {
assertEquals(size, rowCount());
}
}
| 6,335
| 42.39726
| 126
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedClusterTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.concurrent.TimeUnit;
import org.infinispan.Cache;
import org.infinispan.commons.time.ControlledTimeService;
import org.infinispan.commons.time.TimeService;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.PersistenceConfigurationBuilder;
import org.infinispan.configuration.cache.StoreConfigurationBuilder;
import org.infinispan.container.impl.InternalDataContainer;
import org.infinispan.distribution.BaseDistStoreTest;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.test.TestingUtil;
import org.infinispan.util.concurrent.CompletionStages;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "persistence.jdbc.JdbcStringBasedClusterTest")
public class JdbcStringBasedClusterTest extends BaseDistStoreTest<Integer, String, JdbcStringBasedClusterTest> {
private ControlledTimeService controlledTimeService = new ControlledTimeService();
{
INIT_CLUSTER_SIZE = 2;
l1CacheEnabled = false;
}
@Override
protected void amendCacheManagerBeforeStart(EmbeddedCacheManager ecm) {
TestingUtil.replaceComponent(ecm, TimeService.class, controlledTimeService, true);
}
@Override
public Object[] factory() {
return new Object[]{
new JdbcStringBasedClusterTest().segmented(true).shared(true).cacheMode(CacheMode.DIST_SYNC),
new JdbcStringBasedClusterTest().segmented(false).shared(true).cacheMode(CacheMode.DIST_SYNC),
new JdbcStringBasedClusterTest().segmented(true).cacheMode(CacheMode.LOCAL),
new JdbcStringBasedClusterTest().segmented(false).cacheMode(CacheMode.LOCAL),
};
}
@Override
protected StoreConfigurationBuilder addStore(PersistenceConfigurationBuilder persistenceConfigurationBuilder, boolean shared) {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = persistenceConfigurationBuilder
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
storeBuilder.shared(shared);
storeBuilder.segmented(segmented);
UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder);
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
return storeBuilder;
}
public void testPurgeExpired() throws SQLException {
Cache<String, String> cacheToUse = cache(0, cacheName);
cacheToUse.put("key1", "expired", 10, TimeUnit.MINUTES);
cacheToUse.put("key2", "value");
cacheToUse.put("key3", "expired", 10, TimeUnit.MINUTES);
cacheToUse.put("key4", "value");
assertEquals(4, cache(0, cacheName).size());
// Remove all entries from memory
for (int i = 0; i < cacheManagers.size(); ++i) {
TestingUtil.extractComponent(cache(i, cacheName), InternalDataContainer.class).clear();
}
assertEquals(4, cacheToUse.size());
// Advance to expire one of the entries
controlledTimeService.advance(TimeUnit.MINUTES.toMillis(11));
PersistenceManager persistenceManager = TestingUtil.extractComponent(cache(0, cacheName), PersistenceManager.class);
CompletionStages.join(persistenceManager.purgeExpired());
assertEquals(2, cacheToUse.size());
// Make sure the purge actually removed the data from the database
JdbcStringBasedStore jdbcStringBasedStore = persistenceManager.getStores(JdbcStringBasedStore.class).iterator().next();
ConnectionFactory connectionFactory = jdbcStringBasedStore.getConnectionFactory();
Connection connection = connectionFactory.getConnection();
try (Statement stat = connection.createStatement()) {
try (ResultSet rs = stat.executeQuery("SELECT COUNT(1) FROM " + jdbcStringBasedStore.getTableManager().getDataTableName())) {
assertTrue(rs.next());
assertEquals(2, rs.getInt(1));
assertFalse(rs.next());
}
} finally {
connectionFactory.releaseConnection(connection);
}
}
}
| 4,612
| 42.518868
| 134
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/JdbcStringBasedStoreAltTwoWayMapperTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.testng.AssertJUnit.assertEquals;
import java.util.List;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.marshall.persistence.impl.MarshalledEntryUtil;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.test.fwk.TestInternalCacheEntryFactory;
import org.testng.annotations.Test;
/**
* @author Ryan Emerson
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.JdbcStringBasedStoreAltTwoWayMapperTest")
public class JdbcStringBasedStoreAltTwoWayMapperTest extends JdbcStringBasedStoreAltMapperTest {
@Override
protected JdbcStringBasedStoreConfigurationBuilder createJdbcConfig(ConfigurationBuilder builder) {
JdbcStringBasedStoreConfigurationBuilder storeBuilder = builder
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.key2StringMapper(TwoWayPersonKey2StringMapper.class);
return storeBuilder;
}
public void testPurgeListenerIsNotified() throws Exception {
InternalCacheEntry first = TestInternalCacheEntryFactory.create(MIRCEA, "val", 1000);
cacheStore.write(MarshalledEntryUtil.create(first, marshaller));
assertRowCount(1);
Thread.sleep(1100);
List<MarshallableEntry> purged = cacheStore.purge();
assertEquals(1, purged.size());
assertEquals(MIRCEA, purged.get(0).getKey());
assertRowCount(0);
}
}
| 1,658
| 39.463415
| 111
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stringbased/NonStringKeyStateTransferTest.java
|
package org.infinispan.persistence.jdbc.stringbased;
import static org.infinispan.test.TestingUtil.withCacheManager;
import static org.testng.AssertJUnit.assertEquals;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.test.AbstractCacheTest;
import org.infinispan.test.TestDataSCI;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.data.Person;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* @author Mircea.Markus@jboss.com
* @since 4.1
*/
@Test(groups = "functional", testName = "persistence.jdbc.stringbased.NonStringKeyStateTransferTest")
public class NonStringKeyStateTransferTest extends AbstractCacheTest {
public void testReplicatedStateTransfer() {
EmbeddedCacheManager cm1 = null, cm2 = null;
try {
cm1 = createCacheManager(true, CacheMode.REPL_SYNC);
Cache<Person, String> c1 = cm1.getCache();
Person mircea = new Person("mircea");
Person mircea2 = new Person("mircea2");
c1.put(mircea, "mircea");
c1.put(mircea2, "mircea2");
cm2 = createCacheManager(true, CacheMode.REPL_SYNC);
Cache<Person, String> c2 = cm2.getCache();
assertEquals("mircea", c2.get(mircea));
assertEquals("mircea2", c2.get(mircea2));
c2.get(mircea2);
} finally {
TestingUtil.killCacheManagers(cm1, cm2);
}
}
public void testDistributedStateTransfer() {
EmbeddedCacheManager cm1 = null, cm2 = null;
try {
cm1 = createCacheManager(false, CacheMode.DIST_SYNC);
Cache<Person, String> c1 = cm1.getCache();
for (int i = 0; i < 100; i++) {
Person mircea = new Person("mircea"+i);
c1.put(mircea, "mircea"+i);
}
cm2 = createCacheManager(false, CacheMode.DIST_SYNC);
Cache<Person, String> c2 = cm2.getCache();
assert c2.size() > 0;
for (InternalCacheEntry entry : c2.getAdvancedCache().getDataContainer()) {
Object key = entry.getKey();
assert key instanceof Person: "expected key to be person but obtained " + key;
}
} finally {
TestingUtil.killCacheManagers(cm1, cm2);
}
}
public void testDistributedAndNoTwoWay() {
ConfigurationBuilder config = NonStringKeyPreloadTest.createCacheStoreConfig(TwoWayPersonKey2StringMapper.class.getName(), false);
config.clustering().cacheMode(CacheMode.DIST_SYNC);
withCacheManager(() -> TestCacheManagerFactory.createClusteredCacheManager(TestDataSCI.INSTANCE, config), EmbeddedCacheManager::getCache);
}
private EmbeddedCacheManager createCacheManager(boolean preload, CacheMode cacheMode) {
ConfigurationBuilder config = NonStringKeyPreloadTest.createCacheStoreConfig(TwoWayPersonKey2StringMapper.class.getName(), preload);
config.clustering().cacheMode(cacheMode);
return TestCacheManagerFactory.createClusteredCacheManager(TestDataSCI.INSTANCE, config);
}
}
| 3,235
| 38.950617
| 144
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/impl/table/OracleTableManagerTest.java
|
package org.infinispan.persistence.jdbc.impl.table;
import static org.testng.AssertJUnit.assertFalse;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
import org.infinispan.persistence.InitializationContextImpl;
import org.infinispan.persistence.jdbc.common.DatabaseType;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfiguration;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.mockito.Mockito;
import org.testng.annotations.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
@Test(groups = "functional", testName = "persistence.jdbc.OracleTableManagerTest")
public class OracleTableManagerTest {
public void testShortIndexNamesOverlap() {
DbMetaData dbMetaData = new DbMetaData(DatabaseType.ORACLE, 12, 0, 30, false, false, false);
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.persistence().addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.table()
.tableNamePrefix("TBL")
.dataColumnName("DTC").dataColumnType("BINARY")
.idColumnName("IDC").idColumnType("VARCHAR(255)")
.timestampColumnName("TSC").timestampColumnType("BIGINT")
.segmentColumnName("SGC").segmentColumnType("INT")
.dataSource().jndiUrl("a_fake_jdni_url");
Configuration configuration = builder.build();
JdbcStringBasedStoreConfiguration storeConfiguration = (JdbcStringBasedStoreConfiguration) configuration.persistence().stores().get(0);
InitializationContextImpl context = new InitializationContextImpl(null, null, null, Mockito.mock(PersistenceMarshaller.class), null, null, null, null, null, null, null);
OracleTableManager tableManager = new OracleTableManager(context, null, storeConfiguration, dbMetaData, "ALongishCacheName");
String segmentIndexName = tableManager.getIndexName(30, true, "segment_index");
String timestampIndexName = tableManager.getIndexName(30, true, "timestamp_index");
assertFalse(segmentIndexName.equals(timestampIndexName));
}
}
| 2,275
| 53.190476
| 175
|
java
|
null |
infinispan-main/persistence/jdbc/src/test/java/org/infinispan/persistence/jdbc/stores/TxStoreTest.java
|
package org.infinispan.persistence.jdbc.stores;
import static jakarta.transaction.Status.STATUS_ROLLEDBACK;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyBoolean;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.testng.AssertJUnit.assertEquals;
import jakarta.transaction.RollbackException;
import jakarta.transaction.Transaction;
import jakarta.transaction.TransactionManager;
import javax.transaction.xa.XAException;
import org.infinispan.Cache;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.context.Flag;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.jdbc.UnitTestDatabaseManager;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.impl.table.TableName;
import org.infinispan.persistence.jdbc.stringbased.JdbcStringBasedStore;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.persistence.support.WaitDelegatingNonBlockingStore;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.testng.annotations.AfterMethod;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* Test to check that a transactional store commits/rollsback stored values as expected. Also ensures that a failed
* prepare on the store results in the entire cache Tx rollingback.
*
* @author Ryan Emerson
*/
@Test(groups = "functional", testName = "persistence.jdbc.stores.TxStoreTest")
public class TxStoreTest extends AbstractInfinispanTest {
private static final String KEY1 = "Key 1";
private static final String KEY2 = "Key 2";
private static final String VAL1 = "Val 1";
private static final String VAL2 = "Val 2";
private EmbeddedCacheManager cacheManager;
private Cache<String, String> cache;
private WaitDelegatingNonBlockingStore<String, String> store;
@BeforeMethod
public void beforeClass() {
ConfigurationBuilder cc = TestCacheManagerFactory.getDefaultCacheConfiguration(true);
JdbcStringBasedStoreConfigurationBuilder storeBuilder = cc
.clustering().cacheMode(CacheMode.DIST_SYNC)
.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class)
.shared(true)
.transactional(true);
UnitTestDatabaseManager.configureUniqueConnectionFactory(storeBuilder);
UnitTestDatabaseManager.setDialect(storeBuilder);
UnitTestDatabaseManager.buildTableManipulation(storeBuilder.table());
cacheManager = TestCacheManagerFactory.createClusteredCacheManager(cc);
cache = cacheManager.getCache();
store = TestingUtil.getFirstStoreWait(cache);
}
@AfterMethod(alwaysRun = true)
public void tearDown() throws PersistenceException {
if (store != null) {
store.clearAndWait();
assertRowCount(0);
}
TestingUtil.killCacheManagers(cacheManager);
}
@Test
public void testTxCommit() throws Exception {
cache.put(KEY1, VAL1);
TransactionManager tm = TestingUtil.getTransactionManager(cache);
tm.begin();
cache.put(KEY2, VAL1);
String oldValue = cache.put(KEY1, VAL2);
assertEquals(oldValue, VAL1);
tm.commit();
String cacheVal = cache.getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD).get(KEY1);
assertEquals(cacheVal, VAL2);
// Ensure the values committed in the Tx were actually written to the store as well as to the cache
assertRowCount(2);
assertEquals(store.loadEntry(KEY1).getValue(), VAL2);
assertEquals(store.loadEntry(KEY2).getValue(), VAL1);
}
@Test
public void testTxRollback() throws Exception {
TransactionManager tm = TestingUtil.getTransactionManager(cache);
tm.begin();
Transaction tx = tm.getTransaction();
cache.put(KEY1, VAL1);
cache.put(KEY2, VAL2);
tm.rollback();
assert tx.getStatus() == STATUS_ROLLEDBACK;
assertRowCount(0);
}
@Test
public void testTxRollbackOnStoreException() throws Exception {
PersistenceManager pm = TestingUtil.extractComponent(cache, PersistenceManager.class);
PersistenceManager mockPM = mock(PersistenceManager.class);
when(mockPM.loadFromAllStores(any(), anyInt(), anyBoolean(), anyBoolean())).thenReturn(CompletableFutures.completedNull());
doThrow(new PersistenceException()).when(mockPM).prepareAllTxStores(any(), any());
TestingUtil.replaceComponent(cache, PersistenceManager.class, mockPM, true);
try {
TransactionManager tm = TestingUtil.getTransactionManager(cache);
tm.begin();
Transaction tx = tm.getTransaction();
cache.put(KEY1, VAL1);
cache.put(KEY2, VAL2);
// Throws PersistenceException, forcing the Tx to rollback
Throwable throwable = Exceptions.extractException(tm::commit);
Exceptions.assertException(RollbackException.class, throwable);
Exceptions.assertException(XAException.class, PersistenceException.class, throwable.getSuppressed()[0]);
assertEquals(STATUS_ROLLEDBACK, tx.getStatus());
assertRowCount(0);
} finally {
// The mock doesn't have any metadata, so its stop() method won't be invoked
pm.stop();
store = null;
}
}
private void assertRowCount(int rowCount) {
JdbcStringBasedStore jdbcStore = (JdbcStringBasedStore) store.delegate();
ConnectionFactory connectionFactory = jdbcStore.getConnectionFactory();
TableName tableName = jdbcStore.getTableManager().getDataTableName();
int value = UnitTestDatabaseManager.rowCount(connectionFactory, tableName);
assert value == rowCount : "Expected " + rowCount + " rows, actual value is " + value;
}
public void testSizeWithEntryInContext() throws Exception {
cache.put(KEY1, VAL1);
assertEquals(1, cache.size());
TransactionManager tm = TestingUtil.getTransactionManager(cache);
TestingUtil.withTx(tm, () -> {
cache.put(KEY2, VAL2);
assertEquals(2, cache.size());
return null;
});
}
}
| 6,750
| 40.164634
| 129
|
java
|
null |
infinispan-main/persistence/jdbc/src/main/java/org/infinispan/persistence/jdbc/package-info.java
|
/**
* This package contains a {@link org.infinispan.persistence.spi.AdvancedLoadWriteStore} implementation based on
* a JDBC database connection.
*/
package org.infinispan.persistence.jdbc;
| 193
| 31.333333
| 112
|
java
|
null |
infinispan-main/persistence/jdbc/src/main/java/org/infinispan/persistence/jdbc/configuration/package-info.java
|
/**
* Configuration for the JDBC CacheStore.
*
* @api.public
*/
package org.infinispan.persistence.jdbc.configuration;
| 123
| 16.714286
| 54
|
java
|
null |
infinispan-main/persistence/jdbc/src/main/java/org/infinispan/persistence/jdbc/configuration/JdbcStringBasedStoreConfigurationBuilder.java
|
package org.infinispan.persistence.jdbc.configuration;
import static org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfiguration.KEY2STRING_MAPPER;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.cache.PersistenceConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.persistence.jdbc.common.configuration.AbstractJdbcStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.common.configuration.ManagedConnectionFactoryConfigurationBuilder;
import org.infinispan.persistence.jdbc.common.configuration.PooledConnectionFactoryConfigurationBuilder;
import org.infinispan.persistence.keymappers.DefaultTwoWayKey2StringMapper;
import org.infinispan.persistence.keymappers.Key2StringMapper;
/**
*
* JdbcStringBasedStoreConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 5.2
*/
public class JdbcStringBasedStoreConfigurationBuilder extends AbstractJdbcStoreConfigurationBuilder<JdbcStringBasedStoreConfiguration, JdbcStringBasedStoreConfigurationBuilder> {
private StringTableManipulationConfigurationBuilder table;
public JdbcStringBasedStoreConfigurationBuilder(PersistenceConfigurationBuilder builder) {
super(builder, JdbcStringBasedStoreConfiguration.attributeDefinitionSet());
table = new StringTableManipulationConfigurationBuilder(this);
}
@Override
public JdbcStringBasedStoreConfigurationBuilder self() {
return this;
}
/**
* The class name of a {@link Key2StringMapper} to use for mapping keys to strings suitable for
* storage in a database table. Defaults to {@link DefaultTwoWayKey2StringMapper}
*/
public JdbcStringBasedStoreConfigurationBuilder key2StringMapper(String key2StringMapper) {
attributes.attribute(KEY2STRING_MAPPER).set(key2StringMapper);
return this;
}
/**
* The class of a {@link Key2StringMapper} to use for mapping keys to strings suitable for
* storage in a database table. Defaults to {@link DefaultTwoWayKey2StringMapper}
*/
public JdbcStringBasedStoreConfigurationBuilder key2StringMapper(Class<? extends Key2StringMapper> klass) {
key2StringMapper(klass.getName());
return this;
}
/**
* Allows configuration of table-specific parameters such as column names and types
*/
public StringTableManipulationConfigurationBuilder table() {
return table;
}
@Override
public void validate() {
table.validate();
super.validate();
}
@Override
public void validate(GlobalConfiguration globalConfig) {
super.validate(globalConfig);
}
@Override
public JdbcStringBasedStoreConfiguration create() {
return new JdbcStringBasedStoreConfiguration(attributes.protect(), async.create(),
connectionFactory != null ? connectionFactory.create() : null,
table.create());
}
@Override
public Builder<?> read(JdbcStringBasedStoreConfiguration template, Combine combine) {
super.read(template, combine);
this.table.read(template.table(), combine);
return this;
}
public class StringTableManipulationConfigurationBuilder extends
TableManipulationConfigurationBuilder<JdbcStringBasedStoreConfigurationBuilder, StringTableManipulationConfigurationBuilder> {
StringTableManipulationConfigurationBuilder(AbstractJdbcStoreConfigurationBuilder<?, JdbcStringBasedStoreConfigurationBuilder> builder) {
super(builder);
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public StringTableManipulationConfigurationBuilder self() {
return this;
}
@Override
public PooledConnectionFactoryConfigurationBuilder<JdbcStringBasedStoreConfigurationBuilder> connectionPool() {
return JdbcStringBasedStoreConfigurationBuilder.this.connectionPool();
}
@Override
public ManagedConnectionFactoryConfigurationBuilder<JdbcStringBasedStoreConfigurationBuilder> dataSource() {
return JdbcStringBasedStoreConfigurationBuilder.this.dataSource();
}
}
@Override
public String toString() {
return "JdbcStringBasedStoreConfigurationBuilder [table=" + table + ", connectionFactory=" + connectionFactory +
", attributes=" + attributes + ", async=" + async + "]";
}
}
| 4,577
| 36.834711
| 178
|
java
|
null |
infinispan-main/persistence/jdbc/src/main/java/org/infinispan/persistence/jdbc/configuration/TableManipulationConfiguration.java
|
package org.infinispan.persistence.jdbc.configuration;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.cache.AbstractStoreConfiguration;
import org.infinispan.persistence.jdbc.common.configuration.Element;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
public class TableManipulationConfiguration {
public static final AttributeDefinition<String> TABLE_NAME_PREFIX = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.PREFIX, null, String.class).immutable().build();
// TODO remove in 10.0
public static final AttributeDefinition<Integer> BATCH_SIZE = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.BATCH_SIZE, AbstractStoreConfiguration.MAX_BATCH_SIZE.getDefaultValue()).immutable().build();
public static final AttributeDefinition<Integer> FETCH_SIZE = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.FETCH_SIZE, TableManager.DEFAULT_FETCH_SIZE).immutable().build();
public static final AttributeDefinition<Boolean> CREATE_ON_START = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.CREATE_ON_START, true).immutable().build();
public static final AttributeDefinition<Boolean> DROP_ON_EXIT = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.DROP_ON_EXIT, false).immutable().build();
static AttributeSet attributeSet() {
return new AttributeSet(TableManipulationConfiguration.class, Element.TABLE_JDBC_STORE, TABLE_NAME_PREFIX, BATCH_SIZE, FETCH_SIZE, CREATE_ON_START, DROP_ON_EXIT);
}
private final Attribute<String> tableNamePrefix;
private final Attribute<Integer> batchSize;
private final Attribute<Integer> fetchSize;
private final Attribute<Boolean> createOnStart;
private final Attribute<Boolean> dropOnExit;
private final AttributeSet attributes;
private final IdColumnConfiguration idColumn;
private final DataColumnConfiguration dataColumn;
private final TimestampColumnConfiguration timeStamp;
private final SegmentColumnConfiguration segmentColumn;
TableManipulationConfiguration(AttributeSet attributes,
IdColumnConfiguration idColumn,
DataColumnConfiguration dataColumn,
TimestampColumnConfiguration timestampColumn,
SegmentColumnConfiguration segmentColumn) {
this.attributes = attributes.checkProtection();
tableNamePrefix = attributes.attribute(TABLE_NAME_PREFIX);
batchSize = attributes.attribute(BATCH_SIZE);
fetchSize = attributes.attribute(FETCH_SIZE);
createOnStart = attributes.attribute(CREATE_ON_START);
dropOnExit = attributes.attribute(DROP_ON_EXIT);
this.idColumn = idColumn;
this.dataColumn = dataColumn;
this.timeStamp = timestampColumn;
this.segmentColumn = segmentColumn;
}
public boolean createOnStart() {
return createOnStart.get();
}
public boolean dropOnExit() {
return dropOnExit.get();
}
public String idColumnName() {
return idColumn.idColumnName();
}
public String idColumnType() {
return idColumn.idColumnType();
}
public String tableNamePrefix() {
return tableNamePrefix.get();
}
public String dataColumnName() {
return dataColumn.dataColumnName();
}
public String dataColumnType() {
return dataColumn.dataColumnType();
}
public String timestampColumnName() {
return timeStamp.dataColumnName();
}
public String timestampColumnType() {
return timeStamp.dataColumnType();
}
public String segmentColumnName() {
return segmentColumn.segmentColumnName();
}
public String segmentColumnType() {
return segmentColumn.segmentColumnType();
}
public int fetchSize() {
return fetchSize.get();
}
/**
* @deprecated please use {@link org.infinispan.configuration.cache.AbstractStoreConfiguration#maxBatchSize()} instead.
* @return the size of batches to process. Guaranteed to be a power of two.
*/
@Deprecated
public int batchSize() {
return batchSize.get();
}
public AttributeSet attributes() {
return attributes;
}
public IdColumnConfiguration idColumnConfiguration() {
return idColumn;
}
public DataColumnConfiguration dataColumnConfiguration() {
return dataColumn;
}
public TimestampColumnConfiguration timeStampColumnConfiguration() {
return timeStamp;
}
public SegmentColumnConfiguration segmentColumnConfiguration() {
return segmentColumn;
}
@Override
public String toString() {
return "TableManipulationConfiguration [attributes=" + attributes + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((attributes == null) ? 0 : attributes.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
TableManipulationConfiguration other = (TableManipulationConfiguration) obj;
if (attributes == null) {
if (other.attributes != null)
return false;
} else if (!attributes.equals(other.attributes))
return false;
return true;
}
}
| 5,747
| 34.925
| 249
|
java
|
null |
infinispan-main/persistence/jdbc/src/main/java/org/infinispan/persistence/jdbc/configuration/TimestampColumnConfiguration.java
|
package org.infinispan.persistence.jdbc.configuration;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class TimestampColumnConfiguration {
public static final AttributeDefinition<String> TIMESTAMP_COLUMN_NAME = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.NAME, null, String.class).immutable().build();
public static final AttributeDefinition<String> TIMESTAMP_COLUMN_TYPE = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.TYPE, null, String.class).immutable().build();
static AttributeSet attributeSet() {
return new AttributeSet(TimestampColumnConfiguration.class, TIMESTAMP_COLUMN_NAME, TIMESTAMP_COLUMN_TYPE);
}
private final Attribute<String> timestampColumnName;
private final Attribute<String> timestampColumnType;
private final AttributeSet attributes;
public TimestampColumnConfiguration(AttributeSet attributes) {
timestampColumnName = attributes.attribute(TIMESTAMP_COLUMN_NAME);
timestampColumnType = attributes.attribute(TIMESTAMP_COLUMN_TYPE);
this.attributes = attributes;
}
public AttributeSet attributes() {
return attributes;
}
public String dataColumnName() {
return timestampColumnName.get();
}
public String dataColumnType() {
return timestampColumnType.get();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TimestampColumnConfiguration that = (TimestampColumnConfiguration) o;
return attributes.equals(that.attributes);
}
@Override
public int hashCode() {
return attributes.hashCode();
}
@Override
public String toString() {
return "TimestampColumnConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 2,060
| 33.35
| 212
|
java
|
null |
infinispan-main/persistence/jdbc/src/main/java/org/infinispan/persistence/jdbc/configuration/JdbcStoreConfigurationParser.java
|
package org.infinispan.persistence.jdbc.configuration;
import static org.infinispan.persistence.jdbc.configuration.JdbcStoreConfigurationParser.NAMESPACE;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.PersistenceConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ConfigurationParser;
import org.infinispan.configuration.parsing.Namespace;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.configuration.parsing.Parser;
import org.infinispan.persistence.jdbc.common.configuration.AbstractJdbcStoreConfigurationParser;
import org.infinispan.persistence.jdbc.common.configuration.Attribute;
import org.infinispan.persistence.jdbc.common.configuration.Element;
import org.kohsuke.MetaInfServices;
/**
* JDBC cache store configuration parser.
*
* @author Galder Zamarreño
* @since 9.0
*/
@MetaInfServices(ConfigurationParser.class)
@Namespace(root = "string-keyed-jdbc-store")
@Namespace(root = "binary-keyed-jdbc-store")
@Namespace(root = "mixed-keyed-jdbc-store")
@Namespace(uri = NAMESPACE + "*", root = "string-keyed-jdbc-store")
@Namespace(uri = NAMESPACE + "*", root = "binary-keyed-jdbc-store", until = "9.0")
@Namespace(uri = NAMESPACE + "*", root = "mixed-keyed-jdbc-store", until = "9.0")
public class JdbcStoreConfigurationParser extends AbstractJdbcStoreConfigurationParser {
static final String NAMESPACE = Parser.NAMESPACE + "store:jdbc:";
public JdbcStoreConfigurationParser() {
}
@Override
public void readElement(final ConfigurationReader reader, final ConfigurationBuilderHolder holder) {
ConfigurationBuilder builder = holder.getCurrentConfigurationBuilder();
Element element = Element.forName(reader.getLocalName());
switch (element) {
case STRING_KEYED_JDBC_STORE: {
parseStringKeyedJdbcStore(reader, builder.persistence());
break;
}
case BINARY_KEYED_JDBC_STORE:
case MIXED_KEYED_JDBC_STORE: {
throw new CacheConfigurationException("Binary and Mixed Keyed JDBC stores were removed in 9.0. " +
"Please use JdbcStringBasedStore instead");
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseStringKeyedJdbcStore(final ConfigurationReader reader,
PersistenceConfigurationBuilder persistenceBuilder) {
JdbcStringBasedStoreConfigurationBuilder builder = new JdbcStringBasedStoreConfigurationBuilder(
persistenceBuilder);
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
if (!handleCommonAttributes(reader, builder, attribute, value)) {
if (attribute == Attribute.KEY_TO_STRING_MAPPER) {
builder.key2StringMapper(value);
} else {
Parser.parseStoreAttribute(reader, i, builder);
}
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
if (!handleCommonElement(builder, element, reader)) {
if (element == Element.STRING_KEYED_TABLE) {
parseTable(reader, builder.table());
} else {
Parser.parseStoreElement(reader, builder);
}
}
}
persistenceBuilder.addStore(builder);
}
private void parseTable(ConfigurationReader reader, TableManipulationConfigurationBuilder<?, ?> builder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case BATCH_SIZE: {
builder.batchSize(Integer.parseInt(value));
break;
}
case CREATE_ON_START: {
builder.createOnStart(Boolean.parseBoolean(value));
break;
}
case DROP_ON_EXIT: {
builder.dropOnExit(Boolean.parseBoolean(value));
break;
}
case FETCH_SIZE: {
builder.fetchSize(Integer.parseInt(value));
break;
}
case PREFIX: {
builder.tableNamePrefix(value);
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
parseTableElements(reader, builder);
}
private void parseTableElements(ConfigurationReader reader, TableManipulationConfigurationBuilder<?, ?> builder)
{
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case ID_COLUMN: {
Column column = parseTableElementAttributes(reader);
builder.idColumnName(column.name);
builder.idColumnType(column.type);
break;
}
case DATA_COLUMN: {
Column column = parseTableElementAttributes(reader);
builder.dataColumnName(column.name);
builder.dataColumnType(column.type);
break;
}
case TIMESTAMP_COLUMN: {
Column column = parseTableElementAttributes(reader);
builder.timestampColumnName(column.name);
builder.timestampColumnType(column.type);
break;
}
case SEGMENT_COLUMN: {
Column column = parseTableElementAttributes(reader);
builder.segmentColumnName(column.name);
builder.segmentColumnType(column.type);
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
private Column parseTableElementAttributes(ConfigurationReader reader) {
Column column = new Column();
for (int i = 0; i < reader.getAttributeCount(); i++) {
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME: {
column.name = value;
break;
}
case TYPE: {
column.type = value;
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
ParseUtils.requireNoContent(reader);
return column;
}
static class Column {
String name;
String type;
}
@Override
public Namespace[] getNamespaces() {
return ParseUtils.getNamespaceAnnotations(getClass());
}
}
| 7,193
| 36.664921
| 115
|
java
|
null |
infinispan-main/persistence/jdbc/src/main/java/org/infinispan/persistence/jdbc/configuration/DataColumnConfiguration.java
|
package org.infinispan.persistence.jdbc.configuration;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class DataColumnConfiguration {
public static final AttributeDefinition<String> DATA_COLUMN_NAME = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.NAME, null, String.class).immutable().build();
public static final AttributeDefinition<String> DATA_COLUMN_TYPE = AttributeDefinition.builder(org.infinispan.persistence.jdbc.common.configuration.Attribute.TYPE, null, String.class).immutable().build();
static AttributeSet attributeSet() {
return new AttributeSet(DataColumnConfiguration.class, DATA_COLUMN_NAME, DATA_COLUMN_TYPE);
}
private final Attribute<String> dataColumnName;
private final Attribute<String> dataColumnType;
private final AttributeSet attributes;
public DataColumnConfiguration(AttributeSet attributes) {
dataColumnName = attributes.attribute(DATA_COLUMN_NAME);
dataColumnType = attributes.attribute(DATA_COLUMN_TYPE);
this.attributes = attributes;
}
public AttributeSet attributes() {
return attributes;
}
public String dataColumnName() {
return dataColumnName.get();
}
public String dataColumnType() {
return dataColumnType.get();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
DataColumnConfiguration that = (DataColumnConfiguration) o;
return attributes.equals(that.attributes);
}
@Override
public int hashCode() {
return attributes.hashCode();
}
@Override
public String toString() {
return "DataColumnConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 1,970
| 31.85
| 207
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.