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/server/testdriver/junit5/src/test/java/org/infinispan/server/test/junit5/InfinispanXSiteServerTest.java
|
package org.infinispan.server.test.junit5;
import static org.infinispan.server.test.core.InfinispanServerTestConfiguration.LON;
import static org.infinispan.server.test.core.InfinispanServerTestConfiguration.NYC;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.commons.configuration.StringConfiguration;
import org.infinispan.commons.test.Eventually;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Gustavo Lira
* @since 12
*/
public class InfinispanXSiteServerTest {
protected static final int NUM_SERVERS = 1;
protected static final String LON_CACHE_XML_CONFIG =
"<infinispan><cache-container>" +
" <replicated-cache name=\"%s\">" +
" <backups>" +
" <backup site=\"" + NYC + "\" strategy=\"SYNC\"/>" +
" </backups>" +
" </replicated-cache>" +
"</cache-container></infinispan>";
static final InfinispanServerExtensionBuilder LON_SERVER = InfinispanServerExtensionBuilder.config("XSiteServerTest.xml").numServers(NUM_SERVERS);
static final InfinispanServerExtensionBuilder NYC_SERVER = InfinispanServerExtensionBuilder.config("XSiteServerTest.xml").numServers(NUM_SERVERS);
@RegisterExtension
static InfinispanXSiteServerExtension SERVER_TEST = new InfinispanXSiteServerExtensionBuilder()
.addSite(LON, LON_SERVER)
.addSite(NYC, NYC_SERVER)
.build();
@Test
public void testSingleServer() {
String lonXML = String.format(LON_CACHE_XML_CONFIG, SERVER_TEST.getMethodName());
RemoteCache<String, String> lonCache = SERVER_TEST.hotrod(LON)
.withServerConfiguration(new StringConfiguration(lonXML)).create();
RemoteCache<String, String> nycCache = SERVER_TEST.hotrod(NYC).create(); //nyc cache don't backup to lon
lonCache.put("k1", "v1");
nycCache.put("k2", "v2");
assertEquals("v1", lonCache.get("k1"));
Eventually.eventuallyEquals("v1", () -> nycCache.get("k1"));
assertEquals(null, lonCache.get("k2"));
assertEquals ("v2", nycCache.get("k2"));
}
}
| 2,237
| 40.444444
| 149
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/test/java/org/infinispan/server/test/junit5/InfinispanServerExtensionTest.java
|
package org.infinispan.server.test.junit5;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.ServerRunMode;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
public class InfinispanServerExtensionTest {
@RegisterExtension
static InfinispanServerExtension SERVER = InfinispanServerExtensionBuilder.config("infinispan.xml")
.numServers(1)
.runMode(ServerRunMode.EMBEDDED)
.build();
@Test
public void testSingleServer() {
RemoteCache<String, String> cache = SERVER.hotrod()
.withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
}
| 891
| 29.758621
| 102
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/test/java/org/infinispan/server/test/junit5/InfinispanServerExtensionContainerTest.java
|
package org.infinispan.server.test.junit5;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.configuration.cache.CacheMode;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
public class InfinispanServerExtensionContainerTest {
@RegisterExtension
static InfinispanServerExtension SERVER = InfinispanServerExtensionBuilder.server("infinispan.xml");
@Test
public void testSingleServer() {
RemoteCache<String, String> cache = SERVER.hotrod()
.withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
}
| 763
| 29.56
| 103
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/main/java/org/infinispan/server/test/junit5/InfinispanXSiteServerExtensionBuilder.java
|
package org.infinispan.server.test.junit5;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.server.test.core.TestServer;
/**
* Infinispan Server XSite Extension Builder
*
* @author Gustavo Lira
* @since 12.0
*/
public class InfinispanXSiteServerExtensionBuilder {
private final List<InfinispanServerExtensionBuilder> sites = new ArrayList<>();
public InfinispanXSiteServerExtensionBuilder addSite(String siteName, InfinispanServerExtensionBuilder siteBuilder) {
siteBuilder.site(siteName);
sites.add(siteBuilder);
return this;
}
public InfinispanXSiteServerExtension build() {
Set<String> uniqueSiteName = new HashSet<>();
List<TestServer> testServers = sites.stream()
.map(it -> new TestServer(it.createServerTestConfiguration()))
.peek(testServer -> {
if (!uniqueSiteName.add(testServer.getSiteName())) {
throw new IllegalStateException("Site name already set: " + testServer.getSiteName());
}
})
.collect(Collectors.toList());
return new InfinispanXSiteServerExtension(testServers);
}
}
| 1,257
| 29.682927
| 120
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/main/java/org/infinispan/server/test/junit5/InfinispanSuite.java
|
package org.infinispan.server.test.junit5;
import org.junit.jupiter.api.Disabled;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
/**
* Hack to ensure that {@link InfinispanServerExtension} instances can be shared against test classes executed across a
* {@link org.junit.platform.suite.api.Suite}. A no-op test is required in the Suite class to ensure that calls to
* {@link org.junit.jupiter.api.extension.RegisterExtension} are respected. The {@link InfinispanServerExtension} can
* then register the {@link org.junit.platform.suite.api.SelectClasses} values so that the server resources are only
* cleaned up on the final call to {@link org.junit.jupiter.api.extension.AfterAllCallback}.
* <p>
* All test Suites requiring {@link InfinispanServerExtension} should extend this class.
* <p>
* This can be removed when JUnit provides native support for <a href="https://github.com/junit-team/junit5/issues/456">@BeforeSuite and @AfterSuite annotations</a>.
*/
public abstract class InfinispanSuite {
@Disabled("No-op test to ensure InfinispanServerExtension at the suite level is registered")
@DisplayName("Suite Initializer")
@Test()
public void ignore() {
// no-op
}
}
| 1,233
| 46.461538
| 165
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/main/java/org/infinispan/server/test/junit5/InfinispanServerTestListener.java
|
package org.infinispan.server.test.junit5;
import org.infinispan.server.test.core.ContainerInfinispanServerDriver;
import org.junit.platform.launcher.TestExecutionListener;
import org.junit.platform.launcher.TestPlan;
public class InfinispanServerTestListener implements TestExecutionListener {
@Override
public void testPlanExecutionFinished(TestPlan testPlan) {
ContainerInfinispanServerDriver.cleanup();
}
}
| 428
| 32
| 76
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/main/java/org/infinispan/server/test/junit5/InfinispanServerExtension.java
|
package org.infinispan.server.test.junit5;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.server.test.api.HotRodTestClientDriver;
import org.infinispan.server.test.api.MemcachedTestClientDriver;
import org.infinispan.server.test.api.RespTestClientDriver;
import org.infinispan.server.test.api.RestTestClientDriver;
import org.infinispan.server.test.api.TestClientDriver;
import org.infinispan.server.test.core.ContainerInfinispanServerDriver;
import org.infinispan.server.test.core.InfinispanServerDriver;
import org.infinispan.server.test.core.InfinispanServerTestConfiguration;
import org.infinispan.server.test.core.TestClient;
import org.infinispan.server.test.core.TestServer;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.extension.AfterAllCallback;
import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
/**
* JUnit 5 {@link 'https://junit.org/junit5'} extension. <br/>
*
* The extension can be used in the most simple way that will work in container mode with a standalone server running.
*
* {@code
*
* @RegisterExtension
* static InfinispanServerExtension SERVER = InfispanServerExtensionBuilder.server();
* }
*
* {@code
*
* @RegisterExtension
* static InfinispanServerExtension SERVER = InfispanServerExtensionBuilder.config("infinispan.xml")
* .numServers(1)
* .runMode(ServerRunMode.EMBEDDED)
* .build();
* }
*
* @author Katia Aresti
* @since 11
*/
public class InfinispanServerExtension extends AbstractServerExtension implements
TestClientDriver,
BeforeAllCallback,
BeforeEachCallback,
AfterEachCallback,
AfterAllCallback {
private final TestServer testServer;
private TestClient testClient;
public InfinispanServerExtension(InfinispanServerTestConfiguration configuration) {
testServer = new TestServer(configuration);
}
@Override
public void beforeAll(ExtensionContext extensionContext) {
initSuiteClasses(extensionContext);
startTestServer(extensionContext, testServer);
}
@Override
public void beforeEach(ExtensionContext extensionContext) {
this.testClient = new TestClient(testServer);
startTestClient(extensionContext, testClient);
}
@Override
public void afterEach(ExtensionContext extensionContext) {
testClient.clearResources();
}
@Override
public void afterAll(ExtensionContext extensionContext) {
cleanupSuiteClasses(extensionContext);
// Only stop the extension resources when all tests in a Suite have been completed
if (suiteTestClasses.isEmpty() && testServer.isDriverInitialized()) {
stopTestServer(extensionContext, testServer);
}
}
public void assumeContainerMode() {
Assumptions.assumeTrue(getServerDriver() instanceof ContainerInfinispanServerDriver, "Requires CONTAINER mode");
}
@Override
public HotRodTestClientDriver hotrod() {
return testClient.hotrod();
}
@Override
public RestTestClientDriver rest() {
return testClient.rest();
}
@Override
public RespTestClientDriver resp() {
return testClient.resp();
}
@Override
public MemcachedTestClientDriver memcached() {
return testClient.memcached();
}
@Override
public String getMethodName() {
return testClient.getMethodName();
}
@Override
public String getMethodName(String qualifier) {
return testClient.getMethodName(qualifier);
}
@Override
public CounterManager getCounterManager() {
return testClient.getCounterManager();
}
public TestServer getTestServer() {
return testServer;
}
public InfinispanServerDriver getServerDriver() {
return testServer.getDriver();
}
public String addScript(RemoteCacheManager remoteCacheManager, String script) {
return testClient.addScript(remoteCacheManager, script);
}
}
| 4,158
| 30.037313
| 118
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/main/java/org/infinispan/server/test/junit5/AbstractServerExtension.java
|
package org.infinispan.server.test.junit5;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Consumer;
import org.infinispan.server.test.core.TestClient;
import org.infinispan.server.test.core.TestServer;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.platform.suite.api.SelectClasses;
import org.junit.platform.suite.api.Suite;
public class AbstractServerExtension {
protected final List<Consumer<File>> configurationEnhancers = new ArrayList<>();
protected final Set<Class<?>> suiteTestClasses = new HashSet<>();
protected String testName(ExtensionContext extensionContext) {
// We need to replace the $ for subclasses as it causes issues with the testcontainers docker client
return extensionContext.getRequiredTestClass().getName().replaceAll("\\$", "-");
}
protected void initSuiteClasses(ExtensionContext extensionContext) {
if (!suiteTestClasses.isEmpty())
return;
Class<?> testClass = extensionContext.getRequiredTestClass();
addSuiteTestClasses(testClass);
// Add SelectClasses from outer class definition
addSuiteTestClasses(testClass.getDeclaringClass());
}
private void addSuiteTestClasses(Class<?> clazz) {
if (clazz == null)
return;
SelectClasses selectClasses = clazz.getAnnotation(SelectClasses.class);
if (selectClasses != null)
Collections.addAll(suiteTestClasses, selectClasses.value());
}
protected boolean isSuiteClass(ExtensionContext extensionContext) {
return extensionContext.getRequiredTestClass().isAnnotationPresent(Suite.class);
}
protected void cleanupSuiteClasses(ExtensionContext extensionContext) {
suiteTestClasses.remove(extensionContext.getRequiredTestClass());
}
protected void startTestServer(ExtensionContext extensionContext, TestServer testServer) {
String testName = testName(extensionContext);
// Don't manage the server when a test is using the same InfinispanServerExtension instance as the parent suite
boolean manageServer = !isSuiteClass(extensionContext) && !testServer.isDriverInitialized();
if (manageServer) {
testServer.initServerDriver();
testServer.getDriver().prepare(testName);
testServer.beforeListeners();
configurationEnhancers.forEach(c -> c.accept(testServer.getDriver().getConfDir()));
testServer.getDriver().start(testName);
}
}
protected void startTestClient(ExtensionContext extensionContext, TestClient testClient) {
// Include getDisplayName to ensure ParameterizedTest uniqueness
String methodName = String.format("%s.%s.%s", extensionContext.getRequiredTestClass().getSimpleName(), extensionContext.getRequiredTestMethod(), extensionContext.getDisplayName());
testClient.initResources();
testClient.setMethodName(methodName);
}
protected void stopTestServer(ExtensionContext extensionContext, TestServer testServer) {
String testName = testName(extensionContext);
testServer.stopServerDriver(testName);
testServer.afterListeners();
}
}
| 3,241
| 40.564103
| 186
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/main/java/org/infinispan/server/test/junit5/InfinispanServerExtensionBuilder.java
|
package org.infinispan.server.test.junit5;
import static org.infinispan.server.test.core.AbstractInfinispanServerDriver.DEFAULT_CLUSTERED_INFINISPAN_CONFIG_FILE_NAME;
import org.infinispan.server.test.core.AbstractServerConfigBuilder;
import org.infinispan.server.test.core.ServerRunMode;
/**
* Infinispan Server Extension Builder
*
* @author Katia Aresti
* @since 11
*/
public class InfinispanServerExtensionBuilder extends AbstractServerConfigBuilder<InfinispanServerExtensionBuilder> {
/**
* Use this method to instantiate a single clustered server in a container, using the default configuration.
*/
public static InfinispanServerExtension server() {
return new InfinispanServerExtensionBuilder(DEFAULT_CLUSTERED_INFINISPAN_CONFIG_FILE_NAME, true)
.numServers(1)
.runMode(ServerRunMode.CONTAINER)
.parallelStartup(false)
.build();
}
/**
* Use this method to instantiate a single clustered server in a container, using a custom configuration.
*/
public static InfinispanServerExtension server(String configurationFile) {
return new InfinispanServerExtensionBuilder(configurationFile, false)
.numServers(1)
.runMode(ServerRunMode.CONTAINER)
.parallelStartup(false)
.build();
}
public static InfinispanServerExtensionBuilder config(String configurationFile) {
return new InfinispanServerExtensionBuilder(configurationFile, false);
}
private InfinispanServerExtensionBuilder(String configurationFile, boolean defaultFile) {
super(configurationFile, defaultFile);
}
public InfinispanServerExtension build() {
return new InfinispanServerExtension(createServerTestConfiguration());
}
}
| 1,773
| 35.204082
| 123
|
java
|
null |
infinispan-main/server/testdriver/junit5/src/main/java/org/infinispan/server/test/junit5/InfinispanXSiteServerExtension.java
|
package org.infinispan.server.test.junit5;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.infinispan.client.hotrod.multimap.MultimapCacheManager;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.server.test.api.HotRodTestClientDriver;
import org.infinispan.server.test.api.MemcachedTestClientDriver;
import org.infinispan.server.test.api.RestTestClientDriver;
import org.infinispan.server.test.api.TestClientXSiteDriver;
import org.infinispan.server.test.core.TestClient;
import org.infinispan.server.test.core.TestServer;
import org.junit.jupiter.api.extension.AfterAllCallback;
import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;
/**
* JUnit 5 {@link 'https://junit.org/junit5'} extension. <br/>
*
* * Creates a cluster of sites to be used for running multiple tests for Cross-Site replication functionality
*
* {@code
*
* static final InfinispanServerExtensionBuilder LON_SERVER = InfinispanServerExtensionBuilder.config("XSiteServerTest.xml").numServers(NUM_SERVERS);
* static final InfinispanServerExtensionBuilder NYC_SERVER = InfinispanServerExtensionBuilder.config("XSiteServerTest.xml").numServers(NUM_SERVERS);
*
* @RegisterExtension
* static InfinispanXSiteServerExtension SERVER_TEST = new InfinispanXSiteServerExtensionBuilder()
* .addSite(LON, LON_SERVER)
* .addSite(NYC, NYC_SERVER)
* .build();
* }
*
* @author Gustavo Lira
* @since 12
*/
public class InfinispanXSiteServerExtension extends AbstractServerExtension implements
TestClientXSiteDriver,
BeforeAllCallback,
BeforeEachCallback,
AfterEachCallback,
AfterAllCallback {
private final List<TestServer> testServers;
private final Map<String, TestClient> testClients = new HashMap<>();
public InfinispanXSiteServerExtension(List<TestServer> testServers) {
this.testServers = testServers;
}
@Override
public void beforeAll(ExtensionContext extensionContext) {
initSuiteClasses(extensionContext);
testServers.forEach((it) -> startTestServer(extensionContext, it));
}
@Override
public void beforeEach(ExtensionContext extensionContext) {
testServers.forEach((it) -> {
TestClient testClient = new TestClient(it);
startTestClient(extensionContext, testClient);
testClients.put(it.getSiteName(), testClient);
});
}
@Override
public void afterEach(ExtensionContext extensionContext) {
testClients.values().forEach(TestClient::clearResources);
}
@Override
public void afterAll(ExtensionContext extensionContext) {
if (suiteTestClasses.isEmpty()) {
testServers.stream()
.filter(TestServer::isDriverInitialized)
.forEach(server -> stopTestServer(extensionContext, server));
}
}
@Override
public HotRodTestClientDriver hotrod(String siteName) {
return testClients.get(siteName).hotrod();
}
@Override
public RestTestClientDriver rest(String siteName) {
return testClients.get(siteName).rest();
}
@Override
public MemcachedTestClientDriver memcached(String siteName) {
return testClients.get(siteName).memcached();
}
@Override
//All of methodName will be the same
public String getMethodName() {
return testClients.values().iterator().next().getMethodName();
}
@Override
public CounterManager getCounterManager(String siteName) {
return testClients.get(siteName).getCounterManager();
}
@Override
public <K, V> MultimapCacheManager<K, V> getMultimapCacheManager(String siteName) {
return testClients.get(siteName).getRemoteMultimapCacheManager();
}
public List<TestServer> getTestServers() {
return testServers;
}
}
| 3,980
| 32.453782
| 152
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/InfinispanServerListener.java
|
package org.infinispan.server.test.core;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public interface InfinispanServerListener {
default void before(InfinispanServerDriver driver) {
}
default void after(InfinispanServerDriver driver) {
}
}
| 293
| 18.6
| 57
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/ForkedServer.java
|
package org.infinispan.server.test.core;
import static org.infinispan.commons.test.Exceptions.unchecked;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.util.OS;
import org.infinispan.commons.util.Util;
/**
* Forked server starts the server using batch scripts from the Infinispan Server distribution to start the server.
* The driver uses REST API to shutdown the server.
* Server log is cleaned before start and is not configurable.
* Appends random UUID for server process to identify the corresponding child Java process of the server.
*
* FIXME: The server.log file must be present before starting the server as the monitoring process is pointed to it -
* - groundwork for making the purging of the log directory optional.
*
* @author Gustavo Lira <glira@redhat.com>
* @author Radoslav Husar
* @since 11.0
**/
public class ForkedServer {
private static final Log log = LogFactory.getLog(ForkedInfinispanServerDriver.class);
private static final String START_PATTERN = "ISPN080001";
// Static driver configuration
public static final int TIMEOUT_SECONDS = Integer.getInteger(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_FORKED_TIMEOUT_SECONDS, 30);
public static final Integer DEFAULT_SINGLE_PORT = 11222;
public static final int OFFSET_FACTOR = 100;
// Dynamic server configuration
private final List<String> commands = new ArrayList<>();
private final String serverHome;
private final String serverLogDir;
private final String serverLog;
private String jvmOptions;
private String serverConfiguration;
// Runtime
private final UUID serverId;
private Process process;
private Thread logMonitor;
private final CountDownLatch isServerStarted = new CountDownLatch(1);
public ForkedServer(String serverHome) {
this.serverId = Util.threadLocalRandomUUID();
this.serverHome = serverHome;
this.serverLogDir = serverHome + File.separator + "server" + File.separator + "log";
this.serverLog = serverLogDir + File.separator + "server.log";
cleanServerLog();
callInitScript();
}
private void callInitScript() {
String extension = OS.getCurrentOs() == OS.WINDOWS ? ".bat" : ".sh";
commands.add(serverHome + File.separator + "bin" + File.separator + "server" + extension);
// Append random UUID for this server to be used in the case of forceful shutdown.
addSystemProperty(this.getClass().getName() + "-pid", this.serverId);
}
public ForkedServer setServerConfiguration(String serverConfiguration) {
commands.add("-c");
if (!new File(serverConfiguration).isAbsolute()) {
serverConfiguration = getClass().getClassLoader().getResource(serverConfiguration).getPath();
}
this.serverConfiguration = serverConfiguration;
commands.add(serverConfiguration);
return this;
}
public ForkedServer setPortsOffset(int numServer) {
if (numServer >= 1) {
commands.add("-o");
commands.add(String.valueOf(OFFSET_FACTOR * numServer));
}
return this;
}
public ForkedServer setJvmOptions(String jvmOptions) {
this.jvmOptions = jvmOptions;
return this;
}
public ForkedServer start() {
ProcessBuilder pb = new ProcessBuilder();
pb.command(commands);
if (jvmOptions != null) {
pb.environment().put("JAVA_OPTS", jvmOptions);
}
pb.redirectErrorStream(true);
try {
log.infof("Starting forked server %s", commands);
process = pb.start();
// Start a server monitoring thread which
// (1) prints out the server log to the test output, and
// (2) monitors whether server has started.
logMonitor = new Thread(getServerMonitorRunnable(process.getInputStream()));
logMonitor.start();
// Await server start
// FIXME The waiting should really be done in ForkedInfinispanServerDriver#start to support concurrent boot
if (!isServerStarted.await(TIMEOUT_SECONDS, TimeUnit.SECONDS)) {
throw new IllegalStateException(String.format("The server couldn't start within %d seconds!", TIMEOUT_SECONDS));
}
} catch (Exception e) {
log.error(e);
}
return this;
}
public Runnable getServerMonitorRunnable(InputStream outputStream) {
return () -> {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(outputStream));
String line;
while ((line = reader.readLine()) != null) {
log.info(line);
if (line.contains(START_PATTERN)) {
isServerStarted.countDown();
}
}
reader.close();
} catch (IOException ex) {
log.error(ex);
}
};
}
public void stopInternal() {
try {
process.destroy();
} catch (Exception ex) {
log.error(ex);
}
try {
logMonitor.interrupt();
} catch (Exception ex) {
log.error(ex);
}
}
private void cleanServerLog() {
unchecked(() -> {
Files.deleteIfExists(Paths.get(serverLog));
boolean isServerLogDirectoryExist = Files.exists(Paths.get(serverLogDir));
if (!isServerLogDirectoryExist) {
Files.createDirectory(Paths.get(serverLogDir));
}
Files.createFile(Paths.get(serverLog));
});
}
public File getServerLib() {
return Paths.get(serverHome + File.separator + "server" + File.separator + "lib").toFile();
}
/**
* Returns the process ID (PID) of the Java process as opposed to the PID of the parent shell script which started
* the actual Java process. The process is matched containing the randomized UUID which was passed on server start.
* This employs {@code jps} utility to list Java processes and thus requires the executable to be in the system path.
*
* @return process ID (pid) of the server's Java process.
* @throws IllegalStateException if PID cannot be determined; e.g. because the server is no longer running or jps utility is not available
*/
public long getPid() throws IllegalStateException {
try {
Process jpsProcess = Runtime.getRuntime().exec(String.format("jps%s -v", (OS.getCurrentOs() == OS.WINDOWS) ? ".exe" : ""));
BufferedReader input = new BufferedReader(new InputStreamReader(jpsProcess.getInputStream()));
String jpsLine;
while ((jpsLine = input.readLine()) != null) {
if (jpsLine.contains(this.serverId.toString())) {
jpsProcess.destroyForcibly();
long pid = Long.parseLong(jpsLine.trim().split("\\s+")[0]);
log.infof("Obtained pid is %d for process with UUID %s.", pid, this.serverId);
return pid;
}
}
input.close();
jpsProcess.destroyForcibly();
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
throw new IllegalStateException("Unable to determine PID of the running Infinispan server.");
}
public String getServerConfiguration() {
return serverConfiguration;
}
public void addSystemProperty(String key, Object value) {
commands.add(String.format("-D%s=%s", key, value));
}
}
| 7,789
| 35.232558
| 141
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/TestSystemPropertyNames.java
|
package org.infinispan.server.test.core;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class TestSystemPropertyNames {
public static final String PREFIX = "org.infinispan.test.server.";
/**
* Specifies the name of the base image to use for the server container
*/
public static final String INFINISPAN_TEST_SERVER_BASE_IMAGE_NAME = PREFIX + "container.baseImageName";
/**
* Specifies whether the base image contains a prebuilt server to use instead of using the one built locally
*/
public static final String INFINISPAN_TEST_SERVER_PRESERVE_IMAGE = PREFIX + "container.preserveImage";
/**
* Specifies a comma-separated list of extra libraries (jars) to deploy into the server/lib directory
*/
public static final String INFINISPAN_TEST_SERVER_EXTRA_LIBS = PREFIX + "extension.libs";
/**
* The driver to use for running the server tests. Will override the default driver. Can be either EMBEDDED or CONTAINER
*/
public static final String INFINISPAN_TEST_SERVER_DRIVER = PREFIX + "driver";
/**
* The timeout in seconds to wait for the embedded driver servers to start
*/
public static final String INFINISPAN_TEST_SERVER_EMBEDDED_TIMEOUT_SECONDS = PREFIX + "embedded.timeoutSeconds";
/**
* The timeout in seconds to wait for the container driver servers to start
*/
public static final String INFINISPAN_TEST_SERVER_CONTAINER_TIMEOUT_SECONDS = PREFIX + "container.timeoutSeconds";
/**
* The timeout in seconds to wait for the container driver servers to start
*/
public static final String INFINISPAN_TEST_SERVER_FORKED_TIMEOUT_SECONDS = PREFIX + "container.timeoutSeconds";
/**
* The path to a local installation of the server
*/
public static final String INFINISPAN_TEST_SERVER_DIR = PREFIX + "dir";
/**
* The log file for the container server driver
* It should be a file name located in the module server/tests/src/test/resources/configuration or a full path
*/
public static final String INFINISPAN_TEST_SERVER_LOG_FILE = PREFIX + "container.logFile";
/**
* The maximum amount of memory the container can use.
*/
public static final String INFINISPAN_TEST_SERVER_CONTAINER_MEMORY = PREFIX + "container.memory";
/**
* The amount of memory this container is allowed to swap to disk
*/
public static final String INFINISPAN_TEST_SERVER_CONTAINER_MEMORY_SWAP = PREFIX + "container.memorySwap";
/**
* LogMessageWaitStrategy pattern to use during container initialization
*/
public static final String INFINISPAN_TEST_CONTAINER_DATABASE_LOG_MESSAGE = "org.infinispan.test.database.container.log.regex";
/**
* Specifies a different set of databases, default is H2, MySQL and PostgreSQL
*/
public static final String INFINISPAN_TEST_CONTAINER_DATABASE_TYPES = "org.infinispan.test.database.types";
/**
* Specifies an external database configuration, default is src/test/resources/database/id.properties
*/
public static final String INFINISPAN_TEST_CONTAINER_DATABASE_PROPERTIES = "org.infinispan.test.database.properties.path";
/**
* JDBC drivers to the servers in order to run tests against specific databases. Default is H2, MySQL and PostgreSQL
*/
public static final String INFINISPAN_TEST_CONTAINER_DATABASE_LIBS = "org.infinispan.test.database.jdbc.drivers";
/**
* Convenient way to set GAV jdbc drivers from a file
*/
public static final String INFINISPAN_TEST_CONTAINER_DATABASE_DRIVERS_FILE = "org.infinispan.test.database.jdbc.drivers.file";
/**
* Specifies external JDBC drivers which is not find into maven repo
*/
public static final String INFINISPAN_TEST_CONTAINER_DATABASE_EXTERNAL_DRIVERS = "org.infinispan.test.database.jdbc.drivers.external";
/**
* Specifies the number of the container to start with JVM debug options (port 5005)
*/
public static final String INFINISPAN_TEST_SERVER_CONTAINER_DEBUG = PREFIX + "container.debug";
/**
* Specifies whether a docker volume should be created and mounted to the container
*/
public static final String INFINISPAN_TEST_SERVER_CONTAINER_VOLUME_REQUIRED= PREFIX + "container.volume";
/**
* Specifies the name of the keycloak base image
*/
public static final String KEYCLOAK_IMAGE = "org.infinispan.test.keycloakImage";
/**
* Specifies the keycloak user
*/
public static final String KEYCLOAK_USER = "org.infinispan.test.keycloakUser";
/**
* Specifies the keycloak user password
*/
public static final String KEYCLOAK_PASSWORD = "org.infinispan.test.keycloakPassword";
/**
* Specifies the keycloak realm
*/
public static final String KEYCLOAK_REALM = "org.infinispan.test.keycloakRealm";
/**
* Specifies the name of the Jaeger image
*/
public static final String JAEGER_IMAGE = "org.infinispan.test.jaegerImage";
/**
* Specifies the type of the ldap server
*/
public static final String LDAP_SERVER = "org.infinispan.test.ldapServer";
/**
* Specifies the type of sasl mechanism for the Hot Rod client. Not all tests are using it.
*/
public static final String HOTROD_CLIENT_SASL_MECHANISM = "org.infinispan.test.hotrod.client.salsmechanism";
}
| 5,322
| 43.731092
| 137
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/TestClient.java
|
package org.infinispan.server.test.core;
import java.io.Closeable;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.RemoteCounterManagerFactory;
import org.infinispan.client.hotrod.exceptions.HotRodClientException;
import org.infinispan.client.hotrod.multimap.MultimapCacheManager;
import org.infinispan.client.hotrod.multimap.RemoteMultimapCacheManagerFactory;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.test.Eventually;
import org.infinispan.commons.util.Util;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.scripting.ScriptingManager;
import org.infinispan.server.test.api.HotRodTestClientDriver;
import org.infinispan.server.test.api.MemcachedTestClientDriver;
import org.infinispan.server.test.api.RespTestClientDriver;
import org.infinispan.server.test.api.RestTestClientDriver;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
/**
* Holds the client part of the testing utilities
*
* @author Katia Aresti
* @since 11
*/
public class TestClient {
protected InfinispanServerTestConfiguration configuration;
protected TestServer testServer;
protected List<Closeable> resources;
private String methodName;
public TestClient(TestServer testServer) {
this.testServer = testServer;
}
public <T extends Closeable> T registerResource(T resource) {
resources.add(resource);
return resource;
}
public InfinispanServerDriver getServerDriver() {
if (!testServer.isDriverInitialized()) {
throw new IllegalStateException("Operation not supported before test starts");
}
return testServer.getDriver();
}
public HotRodTestClientDriver hotrod() {
return new HotRodTestClientDriver(testServer, this);
}
public RestTestClientDriver rest() {
return new RestTestClientDriver(testServer, this);
}
public RespTestClientDriver resp() {
return new RespTestClientDriver(testServer, this);
}
public MemcachedTestClientDriver memcached() {
return new MemcachedTestClientDriver(testServer, this);
}
public CounterManager getCounterManager() {
RemoteCacheManager remoteCacheManager = registerResource(testServer.newHotRodClient());
return RemoteCounterManagerFactory.asCounterManager(remoteCacheManager);
}
public <K, V> MultimapCacheManager<K, V> getRemoteMultimapCacheManager() {
RemoteCacheManager remoteCacheManager = registerResource(testServer.newHotRodClient());
return RemoteMultimapCacheManagerFactory.from(remoteCacheManager);
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
public void clearResources() {
if (resources != null) {
ExecutorService executor = Executors.newSingleThreadExecutor();
try {
CompletableFuture
.allOf(
resources.stream()
.map(resource -> CompletableFuture.runAsync(() -> Util.close(resource), executor))
.toArray(i -> new CompletableFuture<?>[i])
)
.get(Eventually.DEFAULT_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
} catch (ExecutionException | InterruptedException | TimeoutException e) {
throw new IllegalStateException("Unable to close resources for " + methodName, e);
} finally {
resources.clear();
executor.shutdown();
}
}
}
public void initResources() {
resources = new ArrayList<>();
}
public String addScript(RemoteCacheManager remoteCacheManager, String script) {
RemoteCache<String, String> scriptCache = remoteCacheManager.getCache(ScriptingManager.SCRIPT_CACHE);
try (InputStream in = this.getClass().getClassLoader().getResourceAsStream(script)) {
scriptCache.put(getMethodName(), CommonsTestingUtil.loadFileAsString(in));
} catch (HotRodClientException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
return getMethodName();
}
public RestClient newRestClient(RestClientConfigurationBuilder restClientConfigurationBuilder) {
RestClient restClient = testServer.newRestClient(restClientConfigurationBuilder);
registerResource(restClient);
return restClient;
}
public MemcachedClient getMemcachedClient(ConnectionFactoryBuilder builder) {
TestServer.CloseableMemcachedClient memcachedClient = testServer.newMemcachedClient(builder);
return registerResource(memcachedClient).getClient();
}
public String getMethodName() {
return getMethodName((Object) null);
}
public String getMethodName(Object... qualifiers) {
StringBuilder sb = new StringBuilder("C").append(methodName);
if (qualifiers != null) {
for (Object q : qualifiers) {
if (q != null)
sb.append(q);
}
}
String cacheName = sb.toString();
try {
MessageDigest sha1 = MessageDigest.getInstance("SHA-1");
byte[] digest = sha1.digest(cacheName.getBytes(StandardCharsets.UTF_8));
return Util.toHexString(digest);
} catch (NoSuchAlgorithmException e) {
// Won't happen
return null;
}
}
}
| 6,032
| 35.343373
| 112
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/AeshTestShell.java
|
package org.infinispan.server.test.core;
import java.util.concurrent.TimeUnit;
import org.aesh.command.shell.Shell;
import org.aesh.readline.Prompt;
import org.aesh.readline.terminal.Key;
import org.aesh.readline.util.Parser;
import org.aesh.terminal.tty.Size;
import org.aesh.terminal.utils.Config;
import org.infinispan.commons.test.Eventually;
import org.junit.ComparisonFailure;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class AeshTestShell implements Shell {
private StringBuilder bufferBuilder = new StringBuilder();
@Override
public void write(String msg, boolean paging) {
bufferBuilder.append(msg);
}
@Override
public void writeln(String msg, boolean paging) {
bufferBuilder.append(msg).append(Config.getLineSeparator());
}
@Override
public void write(int[] out) {
bufferBuilder.append(Parser.fromCodePoints(out));
}
@Override
public void write(char out) {
bufferBuilder.append(out);
}
@Override
public String readLine() throws InterruptedException {
return null;
}
@Override
public String readLine(Prompt prompt) throws InterruptedException {
return null;
}
@Override
public Key read() throws InterruptedException {
return null;
}
@Override
public Key read(Prompt prompt) throws InterruptedException {
return null;
}
@Override
public boolean enableAlternateBuffer() {
return false;
}
@Override
public boolean enableMainBuffer() {
return false;
}
@Override
public Size size() {
return null;
}
@Override
public void clear() {
bufferBuilder.setLength(0);
}
public void assertEquals(String expected) {
Eventually.eventually(
() -> new ComparisonFailure("Expected output was not equal to expected string after timeout", expected, bufferBuilder.toString()),
() -> expected.equals(bufferBuilder.toString()), 10_000, 50, TimeUnit.MILLISECONDS);
}
public void assertContains(String expected) {
Eventually.eventually(
() -> new ComparisonFailure("Expected output did not contain expected string after timeout", expected, bufferBuilder.toString()),
() -> bufferBuilder.toString().contains(expected), 10_000, 50, TimeUnit.MILLISECONDS);
}
}
| 2,359
| 24.106383
| 142
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/ForkedInfinispanServerDriver.java
|
package org.infinispan.server.test.core;
import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.ConnectException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import javax.management.MBeanServerConnection;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.RestResponse;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.util.OS;
import org.infinispan.commons.util.Util;
import org.infinispan.server.Server;
/**
* @author Gustavo Lira <glira@redhat.com>
* @author Radoslav Husar
* @since 11.0
**/
public class ForkedInfinispanServerDriver extends AbstractInfinispanServerDriver {
private static final Log log = LogFactory.getLog(ForkedInfinispanServerDriver.class);
private static final int SHUTDOWN_TIMEOUT_SECONDS = 15;
private final List<ForkedServer> forkedServers = new ArrayList<>();
private final List<Path> serverHomes;
private final String serverDataPath;
protected ForkedInfinispanServerDriver(InfinispanServerTestConfiguration configuration) {
super(configuration, InetAddress.getLoopbackAddress());
String globalServerHome = configuration.properties().getProperty(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_DIR);
if (globalServerHome == null || globalServerHome.isEmpty()) {
throw new IllegalArgumentException("You must specify a " + TestSystemPropertyNames.INFINISPAN_TEST_SERVER_DIR + " property.");
}
serverDataPath = System.getProperty(Server.INFINISPAN_SERVER_ROOT_PATH);
if (serverDataPath != null && !serverDataPath.trim().isEmpty() && !serverDataPath.contains("%d")) {
throw new IllegalStateException("Server root path should have the index. Add the %d regex to the path. Example: /path/to/server_%d");
}
this.serverHomes = new ArrayList<>();
Path src = Paths.get(globalServerHome).normalize();
copyServer(src, serverDataPath != null ? 1 : configuration.numServers());
}
private void copyServer(Path src, int maxServers) {
for (int i = 0; i < maxServers; i++) {
Path dest = Paths.get(CommonsTestingUtil.tmpDirectory(), Util.threadLocalRandomUUID().toString());
try {
Files.createDirectory(dest);
Files.walkFileTree(src, new CommonsTestingUtil.CopyFileVisitor(dest, true));
} catch (IOException e) {
throw new UncheckedIOException("Cannot copy the server to temp folder", e);
}
serverHomes.add(dest);
}
}
private Path getServerConfDir(String home) {
return Paths.get(home,"server", "conf");
}
@Override
public void prepare(String name) {
//do nothing
}
@Override
protected void start(String name, File rootDir, File configurationFile) {
for (int i = 0; i < configuration.numServers(); i++) {
ForkedServer server;
Path destConfDir;
if (serverDataPath != null) {
String serverHome = serverHomes.get(0).toString();
File serverRootPath = new File(String.format(serverDataPath, i));
createServerStructure(serverHome, serverRootPath);
destConfDir = getServerConfDir(serverRootPath.getAbsolutePath());
server = new ForkedServer(serverHome);
server.addSystemProperty(Server.INFINISPAN_SERVER_ROOT_PATH, serverRootPath);
} else {
String serverHome = serverHomes.get(i).toString();
destConfDir = getServerConfDir(serverHome);
server = new ForkedServer(serverHome);
}
server
.setServerConfiguration(configurationFile.getPath())
.setPortsOffset(i);
server.addSystemProperty(Server.INFINISPAN_CLUSTER_STACK, System.getProperty(Server.INFINISPAN_CLUSTER_STACK));
if (i == 0 && configuration.site() == null) {
server.addSystemProperty(JOIN_TIMEOUT, "0");
}
try {
File sourceServerConfiguration = new File(server.getServerConfiguration());
Files.copy(Paths.get(server.getServerConfiguration()), destConfDir.resolve(sourceServerConfiguration.getName()));
} catch (IOException e) {
throw new UncheckedIOException("Cannot copy the server to temp directory", e);
}
// Replace 99 with index of server to debug
if (i == 99) {
server.setJvmOptions(debugJvmOption());
}
copyArtifactsToUserLibDir(server.getServerLib());
forkedServers.add(server.start());
}
}
private void createServerStructure(String serverHome, File serverRootPath) {
// copy required files
try {
Util.recursiveFileRemove(serverRootPath);
Util.recursiveDirectoryCopy(getServerConfDir(serverHome).getParent(), serverRootPath.toPath());
} catch (IOException e) {
throw new UncheckedIOException("Cannot copy the default values", e);
}
}
/**
* Stop whole cluster.
*/
@Override
protected void stop() {
try {
// check if the server is running
try (RestClient restClient = getRestClient(0)) {
RestResponse response = sync(restClient.cluster().stop());
// Ensure non-error response code from the REST endpoint.
if (response.getStatus() >= 400) {
throw new IllegalStateException(String.format("Failed to shutdown the cluster gracefully, got status %d.", response.getStatus()));
} else {
// Ensure that the server process has really quit
// - if it has; the getPid will throw an exception
boolean javaProcessQuit = false;
long endTime = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(SHUTDOWN_TIMEOUT_SECONDS);
while (!(javaProcessQuit || endTime < System.currentTimeMillis())) {
try {
forkedServers.get(0).getPid();
Thread.sleep(500);
} catch (IllegalStateException ignore) {
// The process has quit.
javaProcessQuit = true;
}
}
if (!javaProcessQuit) {
throw new IllegalStateException("Server Java process has not gracefully quit within " + SHUTDOWN_TIMEOUT_SECONDS + " seconds.");
}
}
} catch (RuntimeException e) {
log.warn("Server is not running", e);
}
} catch (Exception e) {
// kill the servers
log.error("Got exception while gracefully shutting down the cluster. Killing the servers.", e);
for (int i = 0; i < configuration.numServers(); i++) {
try {
kill(i);
} catch (Exception exception) {
log.errorf("Failed to kill server #%d, exception was: %s", i, exception);
}
}
} finally {
for (int i = 0; i < configuration.numServers(); i++) {
// Do an internal stop - e.g. stops the log monitoring process.
if (i < forkedServers.size()) {
forkedServers.get(i).stopInternal();
}
}
}
}
/**
* Stop a specific server
*/
@Override
public void stop(int server) {
sync(getRestClient(server).server().stop());
}
@Override
public boolean isRunning(int server) {
try {
sync(getRestClient(server).server().configuration());
} catch (RuntimeException r) {
return !(Util.getRootCause(r) instanceof ConnectException);
}
return true;
}
@Override
public InetSocketAddress getServerSocket(int server, int port) {
return new InetSocketAddress(getServerAddress(server), getServerPort(server, port));
}
@Override
public InetAddress getServerAddress(int server) {
return Exceptions.unchecked(() -> InetAddress.getByName("localhost"));
}
@Override
public void pause(int server) {
if (OS.getCurrentOs() == OS.WINDOWS) {
throw new UnsupportedOperationException("Forked mode does not support pause on Windows!");
} else {
Exceptions.unchecked(() -> new ProcessBuilder("kill", "-SIGSTOP", String.valueOf(forkedServers.get(server).getPid())).start().waitFor(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS));
}
}
@Override
public void resume(int server) {
if (OS.getCurrentOs() == OS.WINDOWS) {
throw new UnsupportedOperationException("Forked mode does not support resume on Windows!");
} else {
Exceptions.unchecked(() -> new ProcessBuilder("kill", "-SIGCONT", String.valueOf(forkedServers.get(server).getPid())).start().waitFor(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS));
}
}
@Override
public void kill(int server) {
String pid = String.valueOf(forkedServers.get(server).getPid());
if (OS.getCurrentOs() == OS.WINDOWS) {
Exceptions.unchecked(() -> new ProcessBuilder("TASKKILL", "/PID", pid, "/F", "/T").start().waitFor(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS));
} else {
Exceptions.unchecked(() -> new ProcessBuilder("kill", "-9", pid).start().waitFor(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS));
}
}
@Override
public void restart(int server) {
throw new UnsupportedOperationException("Forked mode does not support restart!");
}
@Override
public void restartCluster() {
throw new UnsupportedOperationException("Forked mode does not support cluster restart!");
}
@Override
public MBeanServerConnection getJmxConnection(int server) {
return null;
}
@Override
public int getTimeout() {
return ForkedServer.TIMEOUT_SECONDS;
}
private RestClient getRestClient(int server) {
RestClientConfigurationBuilder builder = new RestClientConfigurationBuilder();
// Filter driver properties for REST client configuration properties, e.g. security configuration
// and apply them before applying rest of the dynamically created configuration, e.g. port.
Properties securityConfigurationProperties = new Properties();
configuration.properties().entrySet().stream()
// Filters for org.infinispan.client.rest.configuration.RestClientConfigurationProperties#ICR field value.
.filter(entry -> entry.getKey().toString().startsWith("infinispan.client.rest."))
.forEach(entry -> securityConfigurationProperties.put(entry.getKey(), entry.getValue()));
builder.withProperties(securityConfigurationProperties);
// Ensure to not print out the *values*!!!
log.debugf("Configured client with the following properties: %s", securityConfigurationProperties.keySet().toString());
builder.addServer().host("localhost").port(getServerPort(server, ForkedServer.DEFAULT_SINGLE_PORT));
return RestClient.forConfiguration(builder.build());
}
private int getServerPort(int server, int port) {
return port + ForkedServer.OFFSET_FACTOR * server;
}
private static <T> T sync(CompletionStage<T> stage) {
return Exceptions.unchecked(() -> stage.toCompletableFuture().get(SHUTDOWN_TIMEOUT_SECONDS, TimeUnit.SECONDS));
}
@Override
public String syncFilesFromServer(int server, String dir) {
//NO-OP
return getRootDir().toPath().resolve(Integer.toString(server)).toString();
}
@Override
public String syncFilesToServer(int server, String path) {
//NO-OP
return path;
}
}
| 12,052
| 39.719595
| 188
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/InfinispanServerTestConfiguration.java
|
package org.infinispan.server.test.core;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class InfinispanServerTestConfiguration {
//site names must match the same names defined in xsite-stacks.xml
public static final String LON = "LON";
public static final String NYC = "NYC";
//each site needs a different discovery port otherwise they will be merged
private static final Map<String, Integer> SITE_DISCOVER_PORTS_OFFSET;
private static final int DEFAULT_DISCOVER_PORT = 46655;
static {
Map<String, Integer> ports = new HashMap<>();
//46655 is the default! don't use it!
ports.put(LON, 1000);
ports.put(NYC, 2000);
SITE_DISCOVER_PORTS_OFFSET = Collections.unmodifiableMap(ports);
}
private final String configurationFile;
private final int numServers;
private final ServerRunMode runMode;
private final Properties properties;
private final String[] mavenArtifacts;
private final JavaArchive[] archives;
private final boolean jmx;
private final boolean parallelStartup;
private final List<InfinispanServerListener> listeners;
private boolean defaultFile;
private final String site;
private final int portOffset;
private final String[] features;
public InfinispanServerTestConfiguration(String configurationFile, int numServers, ServerRunMode runMode,
Properties properties, String[] mavenArtifacts, JavaArchive[] archives,
boolean jmx, boolean parallelStartup, boolean defaultFile,
List<InfinispanServerListener> listeners, String site, int portOffset,
String[] features) {
this.configurationFile = configurationFile;
this.numServers = numServers;
this.runMode = runMode;
this.properties = properties;
this.mavenArtifacts = mavenArtifacts;
this.archives = archives;
this.jmx = jmx;
this.parallelStartup = parallelStartup;
this.defaultFile = defaultFile;
this.listeners = Collections.unmodifiableList(listeners);
this.site = site;
this.portOffset = portOffset;
this.features = features;
}
public String configurationFile() {
return configurationFile;
}
public int numServers() {
return numServers;
}
public ServerRunMode runMode() {
return runMode;
}
public Properties properties() {
return properties;
}
public JavaArchive[] archives() {
return archives;
}
public boolean isJMXEnabled() {
return jmx;
}
public String[] mavenArtifacts() {
return mavenArtifacts;
}
public boolean isParallelStartup() {
return parallelStartup;
}
public boolean isDefaultFile() {
return defaultFile;
}
public List<InfinispanServerListener> listeners() {
return listeners;
}
public String site() {
return site;
}
public int siteDiscoveryPort() {
return DEFAULT_DISCOVER_PORT + sitePortOffset();
}
public int sitePortOffset() {
return SITE_DISCOVER_PORTS_OFFSET.get(site);
}
public int getPortOffset() {
return portOffset;
}
public String[] getFeatures() {
return features;
}
}
| 3,532
| 26.818898
| 115
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/AeshTestConnection.java
|
package org.infinispan.server.test.core;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import org.aesh.readline.util.Parser;
import org.aesh.terminal.Attributes;
import org.aesh.terminal.BaseDevice;
import org.aesh.terminal.Connection;
import org.aesh.terminal.Device;
import org.aesh.terminal.tty.Capability;
import org.aesh.terminal.tty.Signal;
import org.aesh.terminal.tty.Size;
import org.aesh.terminal.utils.Config;
import org.infinispan.commons.test.Eventually;
import org.junit.ComparisonFailure;
/**
* @author <a href="mailto:stale.pedersen@jboss.org">Ståle W. Pedersen</a>
*/
public class AeshTestConnection implements Connection, AutoCloseable {
private Consumer<Size> sizeHandler;
private Consumer<Signal> signalHandler;
private Consumer<int[]> stdinHandler;
private Consumer<int[]> stdOutHandler;
private Consumer<Void> closeHandler;
private StringBuilder bufferBuilder;
private Size size;
private Attributes attributes;
private volatile boolean reading = false;
public AeshTestConnection() {
this(new Size(80, 20), true);
}
public AeshTestConnection(boolean stripAnsiCodes) {
this(new Size(80, 20), stripAnsiCodes);
}
public AeshTestConnection(Size size) {
this(size, true);
}
public AeshTestConnection(Size size, boolean stripAnsiCodes) {
bufferBuilder = new StringBuilder();
stdOutHandler = ints -> {
if (stripAnsiCodes)
bufferBuilder.append(Parser.stripAwayAnsiCodes(Parser.fromCodePoints(ints)));
else
bufferBuilder.append(Parser.fromCodePoints(ints));
};
if (size == null)
this.size = new Size(80, 20);
else
this.size = size;
attributes = new Attributes();
}
public void clear() {
if (bufferBuilder.length() > 0)
bufferBuilder.delete(0, bufferBuilder.length());
}
public String getOutputBuffer() {
return bufferBuilder.toString();
}
@Override
public Device device() {
return new BaseDevice() {
@Override
public String type() {
return "vt100";
}
@Override
public boolean getBooleanCapability(Capability capability) {
return false;
}
@Override
public Integer getNumericCapability(Capability capability) {
return null;
}
@Override
public String getStringCapability(Capability capability) {
return null;
}
};
}
@Override
public Size size() {
return size;
}
@Override
public Consumer<Size> getSizeHandler() {
return sizeHandler;
}
@Override
public void setSizeHandler(Consumer<Size> handler) {
this.sizeHandler = handler;
}
@Override
public Consumer<Signal> getSignalHandler() {
return signalHandler;
}
@Override
public void setSignalHandler(Consumer<Signal> handler) {
signalHandler = handler;
}
@Override
public Consumer<int[]> getStdinHandler() {
return stdinHandler;
}
@Override
public void setStdinHandler(Consumer<int[]> handler) {
stdinHandler = handler;
}
@Override
public Consumer<int[]> stdoutHandler() {
return stdOutHandler;
}
@Override
public void setCloseHandler(Consumer<Void> closeHandler) {
this.closeHandler = closeHandler;
}
@Override
public Consumer<Void> getCloseHandler() {
return closeHandler;
}
@Override
public void close() {
if (reading) { //close() can be invoked multiple times.
//send a disconnect just in case the connection was left open
send("disconnect");
}
reading = false;
if (closeHandler != null)
closeHandler.accept(null);
}
public boolean closed() {
return !reading;
}
@Override
public void openBlocking() {
//we're not doing anything here, all input will come from the read(..) methods
reading = true;
}
@Override
public void openNonBlocking() {
}
private void doSend(String input) {
doSend(Parser.toCodePoints(input));
}
private void doSend(int[] input) {
if (reading) {
if (stdinHandler != null) {
stdinHandler.accept(input);
} else {
try {
Thread.sleep(10);
doSend(input);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
} else
throw new RuntimeException("Got input when not reading: " + Arrays.toString(input));
}
@Override
public boolean put(Capability capability, Object... params) {
return false;
}
@Override
public Attributes getAttributes() {
return attributes;
}
@Override
public void setAttributes(Attributes attributes) {
this.attributes = attributes;
}
@Override
public Charset inputEncoding() {
return Charset.defaultCharset();
}
@Override
public Charset outputEncoding() {
return Charset.defaultCharset();
}
@Override
public boolean supportsAnsi() {
return true;
}
public void assertEquals(String expected) {
Eventually.eventually(
() -> new ComparisonFailure("Expected output was not equal to expected string after timeout", expected, bufferBuilder.toString()),
() -> expected.equals(bufferBuilder.toString()), 10_000, 50, TimeUnit.MILLISECONDS);
}
public void send(String data) {
doSend(data + Config.getLineSeparator());
}
public void assertContains(String expected) {
Eventually.eventually(
() -> new ComparisonFailure("Expected output did not contain expected string after timeout", expected, bufferBuilder.toString()),
() -> bufferBuilder.toString().contains(expected), 10_000, 50, TimeUnit.MILLISECONDS);
}
public void assertNotContains(String unexpected) {
Eventually.eventually(
() -> new ComparisonFailure("Expected output should not contain expected string after timeout", unexpected, bufferBuilder.toString()),
() -> !bufferBuilder.toString().contains(unexpected), 10_000, 50, TimeUnit.MILLISECONDS);
}
}
| 6,326
| 24.512097
| 146
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/ServerRunMode.java
|
package org.infinispan.server.test.core;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public enum ServerRunMode {
EMBEDDED {
@Override
public AbstractInfinispanServerDriver newDriver(InfinispanServerTestConfiguration configuration) {
return new EmbeddedInfinispanServerDriver(configuration);
}
},
CONTAINER {
@Override
public AbstractInfinispanServerDriver newDriver(InfinispanServerTestConfiguration configuration) {
return new ContainerInfinispanServerDriver(configuration);
}
},
FORKED {
@Override
public AbstractInfinispanServerDriver newDriver(InfinispanServerTestConfiguration configuration) {
return new ForkedInfinispanServerDriver(configuration);
}
},
DEFAULT {
@Override
public AbstractInfinispanServerDriver newDriver(InfinispanServerTestConfiguration configuration) {
ServerRunMode driver;
if (configuration.properties().containsKey(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_BASE_IMAGE_NAME)) {
driver = CONTAINER;
} else {
String driverName = configuration.properties().getProperty(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_DRIVER, EMBEDDED.name());
driver = ServerRunMode.valueOf(driverName);
}
return driver.newDriver(configuration);
}
};
public abstract AbstractInfinispanServerDriver newDriver(InfinispanServerTestConfiguration configuration);
}
| 1,519
| 35.190476
| 143
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/EmbeddedInfinispanServerDriver.java
|
package org.infinispan.server.test.core;
import static org.infinispan.server.test.core.TestSystemPropertyNames.INFINISPAN_TEST_SERVER_EMBEDDED_TIMEOUT_SECONDS;
import java.io.File;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import javax.management.MBeanServerConnection;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.util.StringPropertyReplacer;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.server.DefaultExitHandler;
import org.infinispan.server.ExitStatus;
import org.infinispan.server.Server;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class EmbeddedInfinispanServerDriver extends AbstractInfinispanServerDriver {
public static final int OFFSET_FACTOR = 100;
private static final int TIMEOUT_SECONDS = Integer.getInteger(INFINISPAN_TEST_SERVER_EMBEDDED_TIMEOUT_SECONDS, 30);
List<Server> servers;
List<CompletableFuture<ExitStatus>> serverFutures;
protected EmbeddedInfinispanServerDriver(InfinispanServerTestConfiguration configuration) {
super(configuration, InetAddress.getLoopbackAddress());
System.setProperty(Server.INFINISPAN_ELYTRON_NONCE_SHUTDOWN, "false");
}
protected int clusterPortOffset() {
return configuration.site() == null ? configuration.getPortOffset() : configuration.sitePortOffset();
}
@Override
protected void start(String name, File rootDir, File configurationFile) {
if ((configuration.archives() != null && configuration.archives().length > 0) || (configuration.mavenArtifacts() != null && configuration.mavenArtifacts().length > 0)) {
throw new IllegalArgumentException("EmbeddedInfinispanServerDriver doesn't support server artifacts.");
}
servers = new ArrayList<>();
serverFutures = new ArrayList<>();
for (int i = 0; i < configuration.numServers(); i++) {
File serverRoot = createServerHierarchy(rootDir, Integer.toString(i));
Server server = createServerInstance(name, rootDir, configurationFile, i, serverRoot);
serverFutures.add(server.run());
servers.add(server);
}
// Ensure that the cluster has formed if we start more than one server
List<EmbeddedCacheManager> cacheManagers = servers.stream().map(Server::getCacheManager).collect(Collectors.toList());
if(cacheManagers.size() > 1) {
blockUntilViewsReceived(cacheManagers);
}
}
private Server createServerInstance(String name, File rootDir, File configurationFile, int serverIndex, File serverRoot) {
Properties properties = new Properties();
properties.setProperty(Server.INFINISPAN_SERVER_HOME_PATH, serverRoot.getAbsolutePath());
properties.setProperty(Server.INFINISPAN_SERVER_CONFIG_PATH, new File(rootDir, Server.DEFAULT_SERVER_CONFIG).getAbsolutePath());
properties.setProperty(Server.INFINISPAN_PORT_OFFSET, Integer.toString(clusterPortOffset() + serverIndex * OFFSET_FACTOR));
properties.setProperty(Server.INFINISPAN_CLUSTER_NAME, name);
properties.setProperty(Server.INFINISPAN_CLUSTER_STACK, System.getProperty(Server.INFINISPAN_CLUSTER_STACK));
properties.setProperty(TEST_HOST_ADDRESS, testHostAddress.getHostName());
properties.setProperty(Server.INFINISPAN_LOG4J_SHUTDOWN, "false");
if (serverIndex == 0 && configuration.site() == null) {
properties.setProperty(JOIN_TIMEOUT, "0");
}
configureSite(properties);
configuration.properties().forEach((k, v) -> {
String value = StringPropertyReplacer.replaceProperties((String) v, properties);
properties.put(k, value);
System.setProperty(k.toString(), value);
});
Server server = new Server(serverRoot, new File(configurationFile.getName()), properties);
server.setExitHandler(new DefaultExitHandler());
return server;
}
@Override
protected void stop() {
RuntimeException aggregate = new RuntimeException();
if (servers != null) {
for (int i = 0; i < servers.size(); i++) {
try {
stop(i);
} catch (Throwable e) {
aggregate.addSuppressed(e.getCause());
}
}
if (aggregate.getSuppressed().length > 0) {
throw aggregate;
}
}
}
@Override
public InetSocketAddress getServerSocket(int serverIndex, int port) {
return new InetSocketAddress("127.0.0.1", port + clusterPortOffset() + serverIndex * OFFSET_FACTOR);
}
@Override
public InetAddress getServerAddress(int serverIndex) {
return Exceptions.unchecked(() -> InetAddress.getByName("127.0.0.1"));
}
@Override
public void pause(int serverIndex) {
throw new UnsupportedOperationException();
}
@Override
public void resume(int serverIndex) {
throw new UnsupportedOperationException();
}
@Override
public void stop(int serverIndex) {
try {
Server server = servers.get(serverIndex);
if (server == null)
return;
server.getExitHandler().exit(ExitStatus.SERVER_SHUTDOWN);
serverFutures.get(serverIndex).get();
serverFutures.set(serverIndex, null);
servers.set(serverIndex, null);
} catch (Throwable t) {
throw new RuntimeException("Cannot stop the server: " + serverIndex, t);
}
}
@Override
public void kill(int serverIndex) {
throw new UnsupportedOperationException();
}
@Override
public void restart(int serverIndex) {
assert !isRunning(serverIndex);
File serverRoot = serverRoot(getRootDir(), Integer.toString(serverIndex));
Server server = createServerInstance(getName(), getRootDir(), new File(configuration.configurationFile()),
serverIndex, serverRoot);
servers.set(serverIndex, server);
serverFutures.set(serverIndex, server.run());
}
@Override
public void restartCluster() {
throw new UnsupportedOperationException();
}
@Override
public boolean isRunning(int serverIndex) {
Server server = servers.get(serverIndex);
return server != null && server.getStatus().allowInvocations();
}
@Override
public MBeanServerConnection getJmxConnection(int server) {
DefaultCacheManager cacheManager = servers.get(server).getCacheManager();
return cacheManager.getCacheManagerConfiguration().jmx().mbeanServerLookup().getMBeanServer();
}
@Override
public int getTimeout() {
return TIMEOUT_SECONDS;
}
private void configureSite(Properties properties) {
if (configuration.site() == null) {
return; //nothing to configure
}
//we need to replace the properties in xsite-stacks.xml
properties.setProperty("relay.site_name", configuration.site());
properties.setProperty("jgroups.cluster.mcast_port", Integer.toString(configuration.siteDiscoveryPort()));
properties.setProperty("jgroups.tcp.port", Integer.toString(7800 + clusterPortOffset()));
}
private static void blockUntilViewsReceived(List<EmbeddedCacheManager> cacheManagers) {
long failTime = System.currentTimeMillis() + TimeUnit.SECONDS.toMillis(TIMEOUT_SECONDS);
while (System.currentTimeMillis() < failTime) {
if (areCacheViewsComplete(cacheManagers, false)) {
return;
}
try {
//noinspection BusyWait
Thread.sleep(100);
} catch (InterruptedException ie) {
Thread.currentThread().interrupt();
return;
}
}
//throws exception when "fail=true"
areCacheViewsComplete(cacheManagers, true);
}
public static boolean areCacheViewsComplete(List<EmbeddedCacheManager> cacheManagers, boolean fail) {
final int memberCount = cacheManagers.size();
for (EmbeddedCacheManager manager : cacheManagers) {
if (!isCacheViewComplete(manager.getMembers(), manager.getAddress(), memberCount, fail)) {
return false;
}
}
return true;
}
private static boolean isCacheViewComplete(List<Address> members, Address address, int memberCount, boolean fail) {
if (members == null || memberCount > members.size()) {
if (fail) {
if (members == null) {
throw new IllegalStateException("Member " + address + " is not connected yet!");
} else {
failMissingMembers(members, address, memberCount);
}
}
return false;
} else if (memberCount < members.size()) {
failMissingMembers(members, address, memberCount);
}
return true;
}
private static void failMissingMembers(List<Address> members, Address address, int memberCount) {
// This is an exceptional condition
StringBuilder sb = new StringBuilder("Cache at address ");
sb.append(address);
sb.append(" had ");
sb.append(members.size());
sb.append(" members; expecting ");
sb.append(memberCount);
sb.append(". Members were (");
for (int j = 0; j < members.size(); j++) {
if (j > 0) {
sb.append(", ");
}
sb.append(members.get(j));
}
sb.append(')');
throw new IllegalStateException(sb.toString());
}
@Override
public String syncFilesFromServer(int server, String dir) {
//NO-OP
return getRootDir().toPath().resolve(Integer.toString(server)).toString();
}
@Override
public String syncFilesToServer(int server, String path) {
//NO-OP
return path;
}
}
| 9,976
| 36.507519
| 175
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/InfinispanContainer.java
|
package org.infinispan.server.test.core;
import static java.net.HttpURLConnection.HTTP_OK;
import static java.net.HttpURLConnection.HTTP_UNAUTHORIZED;
import java.time.Duration;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.commons.util.Version;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.containers.wait.strategy.HttpWaitStrategy;
import org.testcontainers.utility.Base58;
import org.testcontainers.utility.DockerImageName;
/**
* InfinispanContainer is an easy way to manage an Infinispan Server container.
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class InfinispanContainer extends GenericContainer<InfinispanContainer> {
public static final String IMAGE_BASENAME = "quay.io/infinispan/server";
public static final String DEFAULT_USERNAME = "admin";
public static final String DEFAULT_PASSWORD = "secret";
public InfinispanContainer() {
this(IMAGE_BASENAME + ":" + Version.getMajorMinor());
}
/**
* Create an Infinispan Container by passing the full docker image name
*
* @param dockerImageName Full docker image name as a {@link String}, like: quay.io/infinispan/server:13.0
*/
public InfinispanContainer(String dockerImageName) {
this(DockerImageName.parse(dockerImageName));
withUser(DEFAULT_USERNAME);
withPassword(DEFAULT_PASSWORD);
}
/**
* Create an Infinispan Container by passing the full docker image name
*
* @param dockerImageName Full docker image name as a {@link DockerImageName}, like: DockerImageName.parse("quay.io/infinispan/server:13.0")
*/
public InfinispanContainer(final DockerImageName dockerImageName) {
super(dockerImageName);
logger().info("Starting an Infinispan container using [{}]", dockerImageName);
withNetworkAliases("infinispan-" + Base58.randomString(6));
addExposedPorts(
11222, // HTTP/Hot Rod
7800 // JGroups TCP
);
setWaitStrategy(new HttpWaitStrategy()
.forPort(11222)
.forStatusCodeMatching(response -> response == HTTP_OK || response == HTTP_UNAUTHORIZED)
.withStartupTimeout(Duration.ofMinutes(2)));
}
/**
* Define the Infinispan username to set.
*
* @param user username to set
* @return this
*/
public InfinispanContainer withUser(String user) {
withEnv("USER", user);
return this;
}
/**
* Define the Infinispan password to set.
*
* @param password Password to set
* @return this
*/
public InfinispanContainer withPassword(String password) {
withEnv("PASS", password);
return this;
}
/**
* One or more artifacts to deploy in Infinispan Server's <tt>server/lib</tt> directory.
* Artifacts can be specified as URLs or as Maven coordinates (e.g. org.postgresql:postgresql:42.3.1)
*
* @param artifacts
* @return
*/
public InfinispanContainer withArtifacts(String... artifacts) {
if (artifacts != null || artifacts.length > 0) {
withEnv("SERVER_LIBS", String.join(" ", artifacts));
}
return this;
}
/**
* Creates a {@link RemoteCacheManager} configured to connect to the containerized server
* @return
*/
public RemoteCacheManager getRemoteCacheManager() {
return getRemoteCacheManager(new ConfigurationBuilder());
}
public RemoteCacheManager getRemoteCacheManager(ConfigurationBuilder builder) {
builder.addServer().host(getHost()).port(getMappedPort(11222))
.security().authentication().username(getEnvMap().get("USER")).password(getEnvMap().get("PASS"));
return new RemoteCacheManager(builder.build());
}
}
| 3,842
| 32.417391
| 143
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/AbstractServerConfigBuilder.java
|
package org.infinispan.server.test.core;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
/**
* Common code for JUnit 4 and Junit 5 Extension
*
* @param <T> type of builder
* @author Katia Aresti
* @since 11
*/
public abstract class AbstractServerConfigBuilder<T extends AbstractServerConfigBuilder<T>> {
private final String configurationFile;
private final boolean defaultFile;
private final Properties properties;
private String[] mavenArtifacts;
private int numServers = 2;
private ServerRunMode runMode = ServerRunMode.DEFAULT;
private JavaArchive[] archives;
private String[] features;
private boolean jmx;
private boolean parallelStartup = true;
private final List<InfinispanServerListener> listeners = new ArrayList<>();
private String siteName;
private int portOffset = 0;
protected AbstractServerConfigBuilder(String configurationFile, boolean defaultFile) {
this.configurationFile = configurationFile;
this.defaultFile = defaultFile;
this.properties = new Properties();
Properties sysProps = System.getProperties();
for (String prop : sysProps.stringPropertyNames()) {
if (prop.startsWith("org.infinispan")) {
properties.put(prop, sysProps.getProperty(prop));
}
}
}
public InfinispanServerTestConfiguration createServerTestConfiguration() {
return new InfinispanServerTestConfiguration(configurationFile, numServers, runMode, this.properties, mavenArtifacts,
archives, jmx, parallelStartup, defaultFile, listeners, siteName, portOffset, features);
}
public T mavenArtifacts(String... mavenArtifacts) {
this.mavenArtifacts = mavenArtifacts;
return (T) this;
}
public T numServers(int numServers) {
this.numServers = numServers;
return (T) this;
}
public T runMode(ServerRunMode serverRunMode) {
this.runMode = serverRunMode;
return (T) this;
}
public T featuresEnabled(String... features) {
this.features = features;
return (T) this;
}
public T addListener(InfinispanServerListener listener) {
listeners.add(listener);
return (T) this;
}
/**
* Deployments
*/
public T artifacts(JavaArchive... archives) {
this.archives = archives;
return (T) this;
}
/**
* Define a system property
*/
public T property(String name, String value) {
this.properties.setProperty(name, value);
return (T) this;
}
public T enableJMX() {
this.jmx = true;
return (T) this;
}
/**
* If false servers are started individually, waiting until they become available, before subsequent servers are started.
*/
public T parallelStartup(boolean parallel) {
this.parallelStartup = parallel;
return (T) this;
}
/**
* Sets the current site name
*/
public T site(String site) {
this.siteName = site;
return (T) this;
}
public T portOffset(int port) {
this.portOffset = port;
return (T) this;
}
}
| 3,157
| 26.224138
| 124
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/TestServer.java
|
package org.infinispan.server.test.core;
import java.io.Closeable;
import java.io.File;
import java.net.InetSocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.test.Exceptions;
import net.spy.memcached.ClientMode;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
/**
* Class that contains all the logic related to the server driver
*
* @author Katia Aresti
* @since 11
*/
public class TestServer {
protected InfinispanServerDriver serverDriver;
protected final List<Consumer<File>> configurationEnhancers = new ArrayList<>();
protected InfinispanServerTestConfiguration configuration;
public TestServer(InfinispanServerTestConfiguration configuration) {
this.configuration = configuration;
}
public boolean isDriverInitialized() {
return serverDriver != null;
}
public InfinispanServerDriver getDriver() {
if (serverDriver == null) {
throw new IllegalStateException("ServerDriver is null. Server driver not initialized");
}
return serverDriver;
}
public void stopServerDriver(String testName) {
getDriver().stop(testName);
serverDriver = null;
}
/**
* @return a client configured against the Hot Rod endpoint exposed by the server
*/
public RemoteCacheManager newHotRodClient() {
return newHotRodClient(new ConfigurationBuilder());
}
public RemoteCacheManager newHotRodClient(ConfigurationBuilder builder) {
return newHotRodClient(builder, getDefaultPortNumber());
}
/**
* @return a client configured against the Hot Rod endpoint exposed by the server
*/
public RemoteCacheManager newHotRodClient(ConfigurationBuilder builder, int port) {
if (builder.servers().isEmpty()) {
for (int i = 0; i < getDriver().getConfiguration().numServers(); i++) {
configureHotRodClient(builder, port, i);
}
}
return getDriver().createRemoteCacheManager(builder);
}
/**
* @return a client configured against the Hot Server index
*/
public RemoteCacheManager newHotRodClient(ConfigurationBuilder builder, int port, int index) {
configureHotRodClient(builder, port, index);
return getDriver().createRemoteCacheManager(builder);
}
private void configureHotRodClient(ConfigurationBuilder builder, int port, int i) {
InetSocketAddress serverAddress = getDriver().getServerSocket(i, port);
builder.addServer().host(serverAddress.getHostString()).port(serverAddress.getPort());
}
public RestClient newRestClient(RestClientConfigurationBuilder builder) {
return newRestClient(builder, getDefaultPortNumber());
}
public RestClient newRestClient(RestClientConfigurationBuilder builder, int port) {
// Add all known server addresses, unless there are some already
if (builder.servers().isEmpty()) {
for (int i = 0; i < getDriver().getConfiguration().numServers(); i++) {
InetSocketAddress serverAddress = getDriver().getServerSocket(i, port);
builder.addServer().host(serverAddress.getHostString()).port(serverAddress.getPort());
}
}
return RestClient.forConfiguration(builder.build());
}
public CloseableMemcachedClient newMemcachedClient(ConnectionFactoryBuilder builder) {
return newMemcachedClient(builder, getDefaultPortNumber());
}
public CloseableMemcachedClient newMemcachedClient(ConnectionFactoryBuilder builder, int port) {
List<InetSocketAddress> addresses = new ArrayList<>();
for (int i = 0; i < getDriver().getConfiguration().numServers(); i++) {
InetSocketAddress unresolved = getDriver().getServerSocket(i, port);
addresses.add(new InetSocketAddress(unresolved.getHostString(), unresolved.getPort()));
}
builder.setClientMode(ClientMode.Static); // Legacy memcached mode
MemcachedClient memcachedClient = Exceptions.unchecked(() -> new MemcachedClient(builder.build(), addresses));
return new CloseableMemcachedClient(memcachedClient);
}
public void beforeListeners() {
configuration.listeners().forEach(l -> l.before(serverDriver));
}
public void afterListeners() {
configuration.listeners().forEach(l -> l.after(serverDriver));
}
public boolean isContainerRunWithDefaultServerConfig() {
return configuration.isDefaultFile() && configuration.runMode() == ServerRunMode.CONTAINER;
}
public static class CloseableMemcachedClient implements Closeable {
final MemcachedClient client;
public CloseableMemcachedClient(MemcachedClient client) {
this.client = client;
}
public MemcachedClient getClient() {
return client;
}
@Override
public void close() {
client.shutdown();
}
}
/**
* Create a new REST client to connect to the server
*
* @param builder client configuration
* @param n the server number
*
* @return a client configured against the nth server
*/
public RestClient newRestClientForServer(RestClientConfigurationBuilder builder, int port, int n) {
InetSocketAddress serverAddress = getDriver().getServerSocket(n, port);
builder.addServer().host(serverAddress.getHostString()).port(serverAddress.getPort());
return RestClient.forConfiguration(builder.build());
}
public void add(Consumer<File> enhancer) {
configurationEnhancers.add(enhancer);
}
public void initServerDriver() {
serverDriver = configuration.runMode().newDriver(configuration);
}
public void enhanceConfiguration() {
configurationEnhancers.forEach(c -> c.accept(serverDriver.getConfDir()));
}
public boolean hasCrossSiteEnabled() {
return configuration.site() != null;
}
public String getSiteName() {
return configuration.site();
}
public int getDefaultPortNumber() {
return 11222;
}
}
| 6,291
| 33.010811
| 116
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/Containers.java
|
package org.infinispan.server.test.core;
import java.net.InetAddress;
import org.infinispan.commons.test.Exceptions;
import org.testcontainers.DockerClientFactory;
import org.testcontainers.containers.GenericContainer;
import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.api.model.Network;
/**
* Container utilities
*
* @author Dan Berindei
* @since 12.0
*/
public class Containers {
public static final DockerClient DOCKER_CLIENT = DockerClientFactory.instance().client();
public static String ipAddress(GenericContainer<?> container) {
return container.getContainerInfo().getNetworkSettings().getNetworks().values().iterator().next().getIpAddress();
}
public static InetAddress getDockerBridgeAddress() {
DockerClient dockerClient = DockerClientFactory.instance().client();
Network bridge = dockerClient.inspectNetworkCmd().withNetworkId("bridge").exec();
String gateway = bridge.getIpam().getConfig().get(0).getGateway();
return Exceptions.unchecked(() -> InetAddress.getByName(gateway));
}
public static String imageArchitecture() {
switch (System.getProperty("os.arch")) {
case "amd64":
return "amd64";
case "aarch64":
return "arm64";
default:
throw new IllegalArgumentException("Unknown architecture");
}
}
}
| 1,377
| 31.046512
| 119
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/ContainerInfinispanServerDriver.java
|
package org.infinispan.server.test.core;
import static org.infinispan.commons.test.Eventually.eventually;
import static org.infinispan.server.Server.DEFAULT_SERVER_CONFIG;
import static org.infinispan.server.test.core.Containers.DOCKER_CLIENT;
import static org.infinispan.server.test.core.Containers.getDockerBridgeAddress;
import static org.infinispan.server.test.core.Containers.imageArchitecture;
import static org.infinispan.server.test.core.TestSystemPropertyNames.INFINISPAN_TEST_SERVER_CONTAINER_VOLUME_REQUIRED;
import static org.infinispan.server.test.core.TestSystemPropertyNames.INFINISPAN_TEST_SERVER_LOG_FILE;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.URI;
import java.net.URL;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import java.nio.file.FileVisitor;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Properties;
import java.util.concurrent.TimeUnit;
import java.util.function.Consumer;
import java.util.stream.IntStream;
import javax.management.MBeanServerConnection;
import javax.management.remote.JMXConnector;
import javax.management.remote.JMXConnectorFactory;
import javax.management.remote.JMXServiceURL;
import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
import org.apache.commons.compress.archivers.tar.TarArchiveInputStream;
import org.apache.commons.compress.archivers.tar.TarArchiveOutputStream;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.test.Ansi;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.test.ThreadLeakChecker;
import org.infinispan.commons.util.StringPropertyReplacer;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.Version;
import org.infinispan.server.Server;
import org.infinispan.util.logging.LogFactory;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.containers.output.OutputFrame;
import org.testcontainers.images.builder.ImageFromDockerfile;
import org.testcontainers.images.builder.dockerfile.statement.RawStatement;
import com.github.dockerjava.api.command.InspectImageResponse;
import com.github.dockerjava.api.exception.NotFoundException;
import com.github.dockerjava.api.model.ContainerNetwork;
import com.github.dockerjava.api.model.Mount;
import com.github.dockerjava.api.model.MountType;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ContainerInfinispanServerDriver extends AbstractInfinispanServerDriver {
private static final Log log = org.infinispan.commons.logging.LogFactory.getLog(ContainerInfinispanServerDriver.class);
private static final String STARTUP_MESSAGE_REGEX = ".*ISPN080001.*";
private static final String SHUTDOWN_MESSAGE_REGEX = ".*ISPN080003.*";
private static final String CLUSTER_VIEW_REGEX = ".*ISPN000094.*(?<=\\()(%d)(?=\\)).*";
private static final int TIMEOUT_SECONDS = Integer.getInteger(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_CONTAINER_TIMEOUT_SECONDS, 45);
private static final Long IMAGE_MEMORY = Long.getLong(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_CONTAINER_MEMORY, null);
private static final Long IMAGE_MEMORY_SWAP = Long.getLong(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_CONTAINER_MEMORY_SWAP, null);
public static final String INFINISPAN_SERVER_HOME = "/opt/infinispan";
public static final int JMX_PORT = 9999;
public static final String JDK_BASE_IMAGE_NAME = "registry.access.redhat.com/ubi8/openjdk-17-runtime";
public static final String IMAGE_USER = "185";
public static final Integer[] EXPOSED_PORTS = {
11222, // Protocol endpoint
11221, // Memcached endpoint
11223, // Alternate Hot Rod endpoint
11224, // Alternate REST endpoint
11225, // Alternate single port endpoint
7800, // JGroups TCP
46655, // JGroups UDP
9999
};
public static final String SNAPSHOT_IMAGE = "localhost/infinispan/server-snapshot";
private final InfinispanGenericContainer[] containers;
private final String[] volumes;
private String name;
ImageFromDockerfile image;
private static final List<String> sites = new ArrayList<>();
static {
// Ensure there are no left-overs from previous runs
cleanup();
}
protected ContainerInfinispanServerDriver(InfinispanServerTestConfiguration configuration) {
super(
configuration,
getDockerBridgeAddress()
);
this.containers = new InfinispanGenericContainer[configuration.numServers()];
this.volumes = new String[configuration.numServers()];
}
public static void cleanup() {
try {
log.infof("Removing temporary image %s", SNAPSHOT_IMAGE);
DOCKER_CLIENT.removeImageCmd(SNAPSHOT_IMAGE).exec();
log.infof("Removed temporary image %s", SNAPSHOT_IMAGE);
} catch (Exception e) {
// Ignore
}
}
@Override
protected void start(String fqcn, File rootDir, File configurationFile) {
this.name = abbreviate(fqcn);
String jGroupsStack = System.getProperty(Server.INFINISPAN_CLUSTER_STACK);
// Build a skeleton server layout
createServerHierarchy(rootDir);
// Build the command-line that launches the server
List<String> args = new ArrayList<>();
args.add("bin/server.sh");
args.add("-c");
args.add(configurationFile.getName());
args.add("-b");
args.add("SITE_LOCAL");
args.add("-Djgroups.bind.address=SITE_LOCAL");
if (jGroupsStack != null) {
args.add("-j");
args.add(jGroupsStack);
}
args.add("-Dinfinispan.cluster.name=" + name);
args.add("-D" + TEST_HOST_ADDRESS + "=" + testHostAddress.getHostAddress());
if (configuration.isJMXEnabled()) {
args.add("-Dcom.sun.management.jmxremote.port=" + JMX_PORT);
args.add("-Dcom.sun.management.jmxremote.authenticate=false");
args.add("-Dcom.sun.management.jmxremote.ssl=false");
}
String logFile = System.getProperty(INFINISPAN_TEST_SERVER_LOG_FILE);
if (logFile != null) {
Path logPath = Paths.get(logFile);
String logFileName = logPath.getFileName().toString();
if (logPath.isAbsolute()) {
try {
// we need to copy the log file to the conf dir because the withFileFromPath("test"..) will overwrite
// everything
Files.copy(logPath, new File(getConfDir(), logFileName).toPath(), StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
throw new IllegalStateException("Cannot copy the log file", e);
}
}
args.add("-l");
args.add(logFileName);
}
Properties properties = new Properties();
properties.setProperty(Server.INFINISPAN_SERVER_CONFIG_PATH, Paths.get(INFINISPAN_SERVER_HOME, DEFAULT_SERVER_CONFIG).toString());
properties.setProperty(Server.INFINISPAN_CLUSTER_NAME, name);
properties.setProperty(TEST_HOST_ADDRESS, testHostAddress.getHostName());
configuration.properties().forEach((k, v) -> args.add("-D" + k + "=" + StringPropertyReplacer.replaceProperties((String) v, properties)));
configureSite(args);
boolean preserveImageAfterTest = Boolean.parseBoolean(configuration.properties().getProperty(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_PRESERVE_IMAGE, "false"));
Path tmp = Paths.get(CommonsTestingUtil.tmpDirectory(this.getClass()));
File libDir = new File(rootDir, "lib");
libDir.mkdirs();
copyArtifactsToUserLibDir(libDir);
// Copy the resources to a location from where they can be added to the image
try {
URL resource = ContainerInfinispanServerDriver.class.getResource("/overlay");
if (resource != null) {
URI overlayUri = resource.toURI();
if ("jar".equals(overlayUri.getScheme())) {
try (FileSystem fileSystem = FileSystems.newFileSystem(overlayUri, Collections.emptyMap())) {
Files.walkFileTree(fileSystem.getPath("/overlay"), new CommonsTestingUtil.CopyFileVisitor(tmp, true, f -> {
f.setExecutable(true, false);
}));
}
} else {
Files.walkFileTree(Paths.get(overlayUri), new CommonsTestingUtil.CopyFileVisitor(tmp, true, f -> {
f.setExecutable(true, false);
}));
}
}
} catch (Exception e) {
throw new RuntimeException(e);
}
log.infof("Creating image %s", name);
final String imageName;
String baseImageName = configuration.properties().getProperty(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_BASE_IMAGE_NAME);
if (baseImageName == null) {
String serverOutputDir = configuration.properties().getProperty(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_DIR);
if (serverOutputDir == null) {
// We try to use the latest public image for this major.minor version
imageName = "quay.io/infinispan/server:" + Version.getMajorMinor();
log.infof("Using prebuilt image '%s'", imageName);
} else {
imageName = createServerImage(serverOutputDir);
}
} else {
imageName = baseImageName;
log.infof("Using prebuilt image '%s'", imageName);
}
image = new ImageFromDockerfile("localhost/infinispan/server-" + name.toLowerCase(), !preserveImageAfterTest)
.withFileFromPath("test", rootDir.toPath())
.withFileFromPath("tmp", tmp)
.withFileFromPath("lib", libDir.toPath())
.withDockerfileFromBuilder(builder -> {
builder
.from(imageName)
.env("INFINISPAN_SERVER_HOME", INFINISPAN_SERVER_HOME)
.env("INFINISPAN_VERSION", Version.getVersion())
.label("name", "Infinispan Server")
.label("version", Version.getVersion())
.label("release", Version.getVersion())
.label("architecture", imageArchitecture());
builder
.user(IMAGE_USER)
.withStatement(new RawStatement("COPY", "--chown=" + IMAGE_USER + ":" + IMAGE_USER + " test " + INFINISPAN_SERVER_HOME + "/server"))
.withStatement(new RawStatement("COPY", "--chown=" + IMAGE_USER + ":" + IMAGE_USER + " tmp " + INFINISPAN_SERVER_HOME))
.withStatement(new RawStatement("COPY", "--chown=" + IMAGE_USER + ":" + IMAGE_USER + " lib " + serverPathFrom("lib")))
.workDir(INFINISPAN_SERVER_HOME)
.entryPoint(args.toArray(new String[]{}))
.expose(
EXPOSED_PORTS // JMX Remoting
)
;
});
image.get();
log.infof("Created image %s", name);
int numServers = configuration.numServers();
CountdownLatchLoggingConsumer clusterLatch = new CountdownLatchLoggingConsumer(numServers, String.format(CLUSTER_VIEW_REGEX, numServers));
if (configuration.isParallelStartup()) {
CountdownLatchLoggingConsumer startupLatch = new CountdownLatchLoggingConsumer(numServers, STARTUP_MESSAGE_REGEX);
IntStream.range(0, configuration.numServers()).forEach(i -> createContainer(i, startupLatch, clusterLatch));
Exceptions.unchecked(() -> startupLatch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
} else {
for (int i = 0; i < configuration.numServers(); i++) {
CountdownLatchLoggingConsumer startupLatch = new CountdownLatchLoggingConsumer(1, STARTUP_MESSAGE_REGEX);
createContainer(i, startupLatch, clusterLatch);
Exceptions.unchecked(() -> startupLatch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
}
}
// Ensure that a cluster of numServers has actually formed before proceeding
Exceptions.unchecked(() -> clusterLatch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
}
private void configureSite(List<String> args) {
if (configuration.site() == null) {
return;
}
args.add("-Drelay.site_name=" + configuration.site());
args.add("-Djgroups.cluster.mcast_port=" + configuration.siteDiscoveryPort());
}
/*
* Removing the `server/data` and `server/log` directories from the local server directory to prevent issues with
* the tests
*/
private static Path cleanServerDirectory(Path serverOutputPath) {
Util.recursiveFileRemove(serverOutputPath.resolve("server").resolve("data").toString());
Util.recursiveFileRemove(serverOutputPath.resolve("server").resolve("log").toString());
return serverOutputPath;
}
private GenericContainer<?> createContainer(int i, Consumer<OutputFrame>... logConsumers) {
boolean volumesRequired = Boolean.parseBoolean(configuration.properties().getProperty(INFINISPAN_TEST_SERVER_CONTAINER_VOLUME_REQUIRED));
if (volumesRequired && this.volumes[i] == null) {
String volumeName = Util.threadLocalRandomUUID().toString();
DOCKER_CLIENT.createVolumeCmd().withName(volumeName).exec();
this.volumes[i] = volumeName;
}
GenericContainer<?> container = new GenericContainer<>(image)
.withCreateContainerCmdModifier(cmd -> {
if (volumesRequired) {
cmd.getHostConfig().withMounts(
Collections.singletonList(new Mount().withSource(this.volumes[i]).withTarget(serverPath()).withType(MountType.VOLUME))
);
}
if (IMAGE_MEMORY != null) {
cmd.getHostConfig().withMemory(IMAGE_MEMORY);
}
if (IMAGE_MEMORY_SWAP != null) {
cmd.getHostConfig().withMemorySwap(IMAGE_MEMORY_SWAP);
}
});
String debug = configuration.properties().getProperty(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_CONTAINER_DEBUG);
String javaOpts = null;
String site = configuration.site();
if (site != null) {
if (!sites.contains(site)) {
sites.add(site);
}
}
if (i == 0 && site == null) {
javaOpts = "-D" + JOIN_TIMEOUT + "=0";
}
if (debug != null && Integer.parseInt(debug) == i) {
javaOpts = javaOpts == null ? debugJvmOption() : javaOpts + " " + debugJvmOption();
log.infof("Container debug enabled with options '%s'%n", javaOpts);
}
if (javaOpts != null) {
container.withEnv("JAVA_OPTS", javaOpts);
}
// Process any enhancers
final String color;
final String reset;
if (Ansi.useColor) {
final int offset;
if (site == null) {
offset = 0;
} else {
offset = 4 * sites.indexOf(site);
}
color = Ansi.DISTINCT_COLORS[(offset + i) % Ansi.DISTINCT_COLORS.length];
reset = Ansi.RESET;
} else {
color = "";
reset = "";
}
String logPrefix = site == null ? name + "#" + i : name + "#" + site + "#" + i;
container.withLogConsumer(new JBossLoggingConsumer(LogFactory.getLogger("CONTAINER")).withPrefix(color + "[" + logPrefix + "]").withSuffix(reset));
for (Consumer<OutputFrame> consumer : logConsumers)
container.withLogConsumer(consumer);
log.infof("Starting container %d", i);
container.start();
containers[i] = new InfinispanGenericContainer(container);
log.infof("Started container %d", i);
return container;
}
@Override
protected void stop() {
for (int i = 0; i < containers.length; i++) {
log.infof("Stopping container %d", i);
stop(i);
log.infof("Stopped container %d", i);
}
// See https://github.com/testcontainers/testcontainers-java/issues/2276
ThreadLeakChecker.ignoreThreadsContaining("docker-java-stream-");
}
@Override
public boolean isRunning(int server) {
return containers[server].isRunning();
}
@Override
public InetSocketAddress getServerSocket(int server, int port) {
return new InetSocketAddress(getServerAddress(server), port);
}
@Override
public InetAddress getServerAddress(int server) {
InfinispanGenericContainer container = containers[server];
return container.getIpAddress();
}
@Override
public void pause(int server) {
InfinispanGenericContainer container = containers[server];
container.pause();
eventually("Container wasn't paused.", container::isPaused);
System.out.printf("[%d] PAUSE %n", server);
}
@Override
public void resume(int server) {
InfinispanGenericContainer container = containers[server];
container.resume();
eventually("Container didn't resume.", () -> isRunning(server));
System.out.printf("[%d] RESUME %n", server);
}
@Override
public void stop(int server) {
InfinispanGenericContainer container = containers[server];
// can fail during the startup
if (container != null) {
CountdownLatchLoggingConsumer latch = new CountdownLatchLoggingConsumer(1, SHUTDOWN_MESSAGE_REGEX);
container.withLogConsumer(latch);
container.stop();
eventually("Container wasn't stopped.", () -> !isRunning(server));
System.out.printf("[%d] STOP %n", server);
}
}
@Override
public void kill(int server) {
InfinispanGenericContainer container = containers[server];
// can fail during the startup
if (container != null) {
container.kill();
eventually("Container wasn't killed.", () -> !isRunning(server));
System.out.printf("[%d] KILL %n", server);
}
}
@Override
public void restart(int server) {
if (isRunning(server)) {
throw new IllegalStateException("Server " + server + " is still running");
}
CountdownLatchLoggingConsumer startupLatch = new CountdownLatchLoggingConsumer(1, STARTUP_MESSAGE_REGEX);
// We can stop the server by doing a rest call. TestContainers has a state about each container. We clean that state
stop(server);
log.infof("Restarting container %d", server);
createContainer(server, startupLatch);
Exceptions.unchecked(() -> startupLatch.await(TIMEOUT_SECONDS, TimeUnit.SECONDS));
}
@Override
public void restartCluster() {
for (int i = 0; i < configuration.numServers(); i++) {
restart(i);
}
}
@Override
public MBeanServerConnection getJmxConnection(int server) {
return Exceptions.unchecked(() -> {
InfinispanGenericContainer container = containers[server];
ContainerNetwork network = container.getContainerNetwork();
JMXServiceURL url = new JMXServiceURL(String.format("service:jmx:rmi:///jndi/rmi://%s:%d/jmxrmi", network.getIpAddress(), JMX_PORT));
JMXConnector jmxConnector = JMXConnectorFactory.connect(url);
return jmxConnector.getMBeanServerConnection();
});
}
@Override
public int getTimeout() {
return TIMEOUT_SECONDS;
}
private String serverPath() {
return String.format("%s/server", INFINISPAN_SERVER_HOME);
}
private String serverPathFrom(String path) {
return String.format("%s/%s", serverPath(), path);
}
@Override
public String syncFilesFromServer(int server, String path) {
String serverPath = Paths.get(path).isAbsolute() ? path : INFINISPAN_SERVER_HOME + "/server/" + path;
try (InputStream is = DOCKER_CLIENT.copyArchiveFromContainerCmd(containers[server].getContainerId(), serverPath).exec()) {
TarArchiveInputStream tar = new TarArchiveInputStream(is);
Path basePath = getRootDir().toPath().resolve(Integer.toString(server));
Util.recursiveFileRemove(basePath.resolve(path));
for (TarArchiveEntry entry = tar.getNextTarEntry(); entry != null; entry = tar.getNextTarEntry()) {
Path entryPath = basePath.resolve(entry.getName());
if (entry.isDirectory()) {
entryPath.toFile().mkdirs();
} else {
OutputStream os = Files.newOutputStream(entryPath);
for (int b = tar.read(); b >= 0; b = tar.read()) {
os.write(b);
}
Util.close(os);
}
}
return basePath.toString();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public String syncFilesToServer(int server, String path) {
Path local = Paths.get(path);
Path parent = local.getParent();
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
TarArchiveOutputStream tar = new TarArchiveOutputStream(bos)) {
Files.walkFileTree(local, new FileVisitor<Path>() {
@Override
public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) throws IOException {
Path relativize = parent.relativize(dir);
TarArchiveEntry entry = new TarArchiveEntry(dir.toFile(), relativize.toString());
entry.setMode(040777);
tar.putArchiveEntry(entry);
tar.closeArchiveEntry();
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
Path relativize = parent.relativize(file);
TarArchiveEntry entry = new TarArchiveEntry(file.toFile(), relativize.toString());
entry.setMode(0100666);
tar.putArchiveEntry(entry);
try (InputStream is = Files.newInputStream(file)) {
for (int b = is.read(); b >= 0; b = is.read()) {
tar.write(b);
}
}
tar.closeArchiveEntry();
return FileVisitResult.CONTINUE;
}
@Override
public FileVisitResult visitFileFailed(Path file, IOException exc) {
return FileVisitResult.SKIP_SUBTREE;
}
@Override
public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
return FileVisitResult.CONTINUE;
}
});
tar.close();
DOCKER_CLIENT.copyArchiveToContainerCmd(containers[server].getContainerId())
.withTarInputStream(new ByteArrayInputStream(bos.toByteArray()))
.withRemotePath("/tmp").exec();
return Paths.get("/tmp").resolve(local.getFileName()).toString();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
static String createServerImage(String serverOutputDir) {
try {
InspectImageResponse response = DOCKER_CLIENT.inspectImageCmd(SNAPSHOT_IMAGE).exec();
log.infof("Reusing existing image");
return response.getConfig().getImage();
} catch (NotFoundException e) {
// We build our local image based on the supplied server directory
Path serverOutputPath = Paths.get(serverOutputDir).normalize();
if (Files.notExists(serverOutputPath)) {
throw new RuntimeException("Cannot create server image: no server at " + serverOutputPath);
}
ImageFromDockerfile image = new ImageFromDockerfile(SNAPSHOT_IMAGE, false)
.withFileFromPath("build", cleanServerDirectory(serverOutputPath))
.withDockerfileFromBuilder(builder -> builder
.from(JDK_BASE_IMAGE_NAME)
.env("INFINISPAN_SERVER_HOME", INFINISPAN_SERVER_HOME)
.env("INFINISPAN_VERSION", Version.getVersion())
.label("name", "Infinispan Server")
.label("version", Version.getVersion())
.label("release", Version.getVersion())
.label("architecture", imageArchitecture())
.withStatement(new RawStatement("COPY", "--chown=" + IMAGE_USER + ":" + IMAGE_USER + " build " + INFINISPAN_SERVER_HOME))
.user("root")
.run("microdnf install tar")
.user(IMAGE_USER));
log.infof("Building server snapshot image from %s", serverOutputPath);
image.get();
return image.getDockerImageName();
}
}
}
| 25,131
| 43.091228
| 172
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/JBossLoggingConsumer.java
|
package org.infinispan.server.test.core;
import org.jboss.logging.BasicLogger;
import org.testcontainers.containers.output.BaseConsumer;
import org.testcontainers.containers.output.OutputFrame;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class JBossLoggingConsumer extends BaseConsumer<JBossLoggingConsumer> {
private final BasicLogger logger;
private String prefix = "";
private String suffix = "";
public JBossLoggingConsumer(BasicLogger logger) {
this.logger = logger;
}
public JBossLoggingConsumer withPrefix(String prefix) {
this.prefix = prefix;
return this;
}
public JBossLoggingConsumer withSuffix(String suffix) {
this.suffix = suffix;
return this;
}
@Override
public void accept(OutputFrame outputFrame) {
OutputFrame.OutputType outputType = outputFrame.getType();
String utf8String = outputFrame.getUtf8String();
utf8String = utf8String.replaceAll("((\\r?\\n)|(\\r))$", "");
switch (outputType) {
case STDOUT:
this.logger.infof("%s%s: %s%s", prefix, outputType, utf8String, suffix);
break;
case STDERR:
this.logger.errorf("%s%s: %s%s", prefix, outputType, utf8String, suffix);
break;
case END:
break;
default:
throw new IllegalArgumentException("Unexpected outputType " + outputType);
}
}
}
| 1,457
| 28.755102
| 86
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/InfinispanServerDriver.java
|
package org.infinispan.server.test.core;
import java.io.File;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import javax.management.MBeanServerConnection;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.lifecycle.ComponentStatus;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import net.spy.memcached.ConnectionFactoryBuilder;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public interface InfinispanServerDriver {
Log log = LogFactory.getLog(InfinispanServerDriver.class);
ComponentStatus getStatus();
InfinispanServerTestConfiguration getConfiguration();
/**
* Prepares a named server configuration
* @param name the name of the server configuration
*/
void prepare(String name);
/**
* Starts a prepared server configuration
* @param name the name of the server configuration
*/
void start(String name);
/**
* Stops a running server configuration
* @param name the name of the server configuration
*/
void stop(String name);
/**
* Determines whether a specific server is running as part of a server configuration
* @param server the
* @return true if the server is running, false otherwise
*/
boolean isRunning(int server);
/**
* Returns an InetSocketAddress for connecting to a specific port on a specific server. The implementation will need
* to provide a specific mapping (e.g. port offset).
*
* @param server the index of the server
* @param port the service port
* @return an unresolved InetSocketAddress pointing to the actual running service
*/
InetSocketAddress getServerSocket(int server, int port);
/**
* Returns an InetAddress that points to a specific server.
*
* @param server the index of the server
* @return an InetAddress pointing to the server's address
*/
InetAddress getServerAddress(int server);
File getCertificateFile(String name);
File getRootDir();
File getConfDir();
void applyKeyStore(ConfigurationBuilder builder, String certificateName);
void applyKeyStore(ConfigurationBuilder builder, String certificateName, String type, String provider);
void applyKeyStore(RestClientConfigurationBuilder builder, String certificateName);
void applyKeyStore(RestClientConfigurationBuilder builder, String certificateName, String type, String provider);
void applyTrustStore(ConfigurationBuilder builder, String certificateName);
void applyTrustStore(ConfigurationBuilder builder, String certificateName, String type, String provider);
void applyTrustStore(RestClientConfigurationBuilder builder, String certificateName);
void applyTrustStore(RestClientConfigurationBuilder builder, String certificateName, String type, String provider);
void applyTrustStore(ConnectionFactoryBuilder builder, String certificateName);
void applyTrustStore(ConnectionFactoryBuilder builder, String certificateName, String type, String provider);
/**
* Pauses a server. Equivalent to kill -SIGSTOP
*
* @param server the index of the server
*/
void pause(int server);
/**
* Resumes a paused server. Equivalent to kill -SIGCONT
*
* @param server the index of the server
*/
void resume(int server);
/**
* Gracefully stops a running server
*
* @param server the index of the server
*/
void stop(int server);
/**
* Forcefully stops a server. Equivalent to kill -SIGKILL
*
* @param server the index of the server
*/
void kill(int server);
/**
* Restarts a previously stopped server.
*
* @param server the index of the server
*/
void restart(int server);
/**
* Restarts all of the nodes
*/
void restartCluster();
/**
* Returns a {@link MBeanServerConnection} to the specified server
*
* @param server the index of the server
*/
MBeanServerConnection getJmxConnection(int server);
RemoteCacheManager createRemoteCacheManager(ConfigurationBuilder builder);
/**
* Returns the amount of time in seconds that we should wait for a server start/stop operation. This may vary
* depending on the type of driver (embedded, container)
*
* @return the number of seconds after which a server start/stop is considered to timeout
*/
int getTimeout();
/**
* Synchronizes files from the server to the local filesystem
* @param server the server
* @param dir if relative, the path relative to the server root, otherwise an absolute path
* @return the path where the data has been synced to
*/
String syncFilesFromServer(int server, String dir);
String syncFilesToServer(int server, String path);
}
| 4,976
| 29.163636
| 119
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/CountdownLatchLoggingConsumer.java
|
package org.infinispan.server.test.core;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.regex.Pattern;
import org.testcontainers.containers.output.BaseConsumer;
import org.testcontainers.containers.output.OutputFrame;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CountdownLatchLoggingConsumer extends BaseConsumer<CountdownLatchLoggingConsumer> {
private final CountDownLatch latch;
private final Pattern pattern;
public CountdownLatchLoggingConsumer(int count, String regex) {
this.latch = new CountDownLatch(count);
this.pattern = Pattern.compile(regex, Pattern.DOTALL);
}
@Override
public void accept(OutputFrame outputFrame) {
String log = outputFrame.getUtf8String();
if (pattern.matcher(log).matches()) {
latch.countDown();
}
}
public void await(long timeout, TimeUnit unit) throws InterruptedException, TimeoutException {
if (!latch.await(timeout, unit)) {
throw new TimeoutException(String.format("After the await period %d %s the count down should be 0 and is %d", timeout, unit, latch.getCount()));
}
}
}
| 1,257
| 31.25641
| 153
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/InfinispanGenericContainer.java
|
package org.infinispan.server.test.core;
import java.net.InetAddress;
import org.infinispan.commons.test.Exceptions;
import org.testcontainers.DockerClientFactory;
import org.testcontainers.containers.GenericContainer;
import com.github.dockerjava.api.DockerClient;
import com.github.dockerjava.api.command.InspectContainerResponse;
import com.github.dockerjava.api.exception.NotFoundException;
import com.github.dockerjava.api.model.ContainerNetwork;
/**
* We can stop a container by doing rest calls. In this case, the TestContainers will have a wrong state.
* Also, the TestContainers stop method is killing the container. See: https://github.com/testcontainers/testcontainers-java/issues/2608
*/
public class InfinispanGenericContainer {
private GenericContainer genericContainer;
private String containerId;
public InfinispanGenericContainer(GenericContainer genericContainer) {
this.containerId = genericContainer.getContainerId();
this.genericContainer = genericContainer;
}
public String getContainerId() {
return containerId;
}
public void pause() {
dockerClient().pauseContainerCmd(this.containerId).exec();
}
public void resume() {
dockerClient().unpauseContainerCmd(this.containerId).exec();
}
public void stop() {
// it could be stopped by the rest call and then NotModifiedException will be throw
if (isRunning()) {
dockerClient().stopContainerCmd(this.containerId).exec();
}
}
public void kill() {
dockerClient().killContainerCmd(this.containerId).exec();
genericContainer.stop(); // we need clean the TestContainers resources
}
public boolean isRunning() {
InspectContainerResponse containerInfo = containerInfo();
return containerInfo != null ? containerInfo.getState().getRunning() : false;
}
public boolean isPaused() {
InspectContainerResponse containerInfo = containerInfo();
return containerInfo != null ? containerInfo.getState().getPaused() : false;
}
public ContainerNetwork getContainerNetwork() {
InspectContainerResponse containerInfo = containerInfo();
if (containerInfo == null) {
throw new NullPointerException(String.format("The requested container %s have an invalid state", this.containerId));
}
return containerInfo.getNetworkSettings().getNetworks().values().iterator().next();
}
public InetAddress getIpAddress() {
// We talk directly to the container, and not through forwarded addresses on localhost because of
// https://github.com/testcontainers/testcontainers-java/issues/452
return Exceptions.unchecked(() -> InetAddress.getByName(getNetworkIpAddress()));
}
public String getNetworkIpAddress() {
InspectContainerResponse containerInfo = containerInfo();
if (containerInfo == null) {
throw new NullPointerException(String.format("The requested container %s have an invalid state", this.containerId));
}
/*
* when the container is not running it will return an empty string
* an empty string will be translated to localhost/127.0.0.1:11222
* everything will fail because this is a test that is running in a container
* failing fast with the error message can help you to not waste time
*/
if (!containerInfo.getState().getRunning()) {
throw new IllegalStateException("Server must be running");
}
ContainerNetwork network = containerInfo.getNetworkSettings().getNetworks().values().iterator().next();
return network.getIpAddress();
}
public InspectContainerResponse containerInfo() {
InspectContainerResponse containerInfo;
try {
containerInfo = dockerClient().inspectContainerCmd(this.containerId).exec();
} catch (NotFoundException e) { // the container could be removed or not available
containerInfo = null;
}
return containerInfo;
}
public String getLogs() {
return this.genericContainer.getLogs();
}
public int getMappedPort(int port) {
return this.genericContainer.getMappedPort(port);
}
public void withLogConsumer(CountdownLatchLoggingConsumer latch) {
genericContainer.withLogConsumer(latch);
}
private DockerClient dockerClient() {
return DockerClientFactory.instance().client();
}
}
| 4,378
| 35.491667
| 136
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/AbstractInfinispanServerDriver.java
|
package org.infinispan.server.test.core;
import static org.wildfly.security.provider.util.ProviderUtil.findProvider;
import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.URI;
import java.net.URL;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.PrivateKey;
import java.security.Provider;
import java.security.PublicKey;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.Arrays;
import java.util.Base64;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Consumer;
import javax.net.ssl.SSLContext;
import javax.security.auth.x500.X500Principal;
import org.infinispan.cli.user.UserTool;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.maven.Artifact;
import org.infinispan.commons.maven.MavenSettings;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.util.Features;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.commons.util.Util;
import org.infinispan.lifecycle.ComponentStatus;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.server.Server;
import org.infinispan.server.network.NetworkAddress;
import org.infinispan.server.test.api.TestUser;
import org.jboss.shrinkwrap.api.exporter.ZipExporter;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.junit.Assume;
import org.wildfly.security.x500.cert.BasicConstraintsExtension;
import org.wildfly.security.x500.cert.SelfSignedX509CertificateAndSigningKey;
import org.wildfly.security.x500.cert.X509CertificateBuilder;
import net.spy.memcached.ConnectionFactoryBuilder;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public abstract class AbstractInfinispanServerDriver implements InfinispanServerDriver {
public static final String DEFAULT_CLUSTERED_INFINISPAN_CONFIG_FILE_NAME = "infinispan.xml";
public static final String TEST_HOST_ADDRESS = "org.infinispan.test.host.address";
public static final String JOIN_TIMEOUT = "jgroups.join_timeout";
public static final String BASE_DN = "CN=%s,OU=Infinispan,O=JBoss,L=Red Hat";
public static final String KEY_PASSWORD = "secret";
public static final String KEY_ALGORITHM = "RSA";
public static final String KEY_SIGNATURE_ALGORITHM = "SHA256withRSA";
protected final InfinispanServerTestConfiguration configuration;
protected final InetAddress testHostAddress;
private File rootDir;
private File confDir;
private ComponentStatus status;
private final AtomicLong certSerial = new AtomicLong(1);
private String name;
private final Provider[] ALL_PROVIDERS;
protected AbstractInfinispanServerDriver(InfinispanServerTestConfiguration configuration, InetAddress testHostAddress) {
this.configuration = configuration;
this.testHostAddress = testHostAddress;
this.status = ComponentStatus.INSTANTIATED;
ALL_PROVIDERS = SslContextFactory.discoverSecurityProviders(this.getClass().getClassLoader());
}
@Override
public ComponentStatus getStatus() {
return status;
}
@Override
public InfinispanServerTestConfiguration getConfiguration() {
return configuration;
}
protected abstract void start(String name, File rootDir, File configurationFile);
protected String debugJvmOption() {
String nonLoopbackAddress;
try {
nonLoopbackAddress = NetworkAddress.nonLoopback("").getAddress().getHostAddress();
} catch (IOException e) {
throw new IllegalStateException("Could not find a non-loopback address");
}
return String.format("-agentlib:jdwp=transport=dt_socket,server=n,address=%s:5005", nonLoopbackAddress);
}
protected abstract void stop();
/**
* Prepare a server layout
*/
@Override
public void prepare(String name) {
this.name = name;
if (configuration.getFeatures() != null) {
// if the feature isn't enabled, the test will be skipped
Features features = new Features(this.getClass().getClassLoader());
for (String feature : configuration.getFeatures()) {
Assume.assumeTrue(String.format("%s is disabled", feature), features.isAvailable(feature));
}
}
String siteName = configuration.site() == null ? "" : configuration.site();
String testDir = CommonsTestingUtil.tmpDirectory(siteName + name);
Util.recursiveFileRemove(testDir);
rootDir = new File(testDir);
confDir = new File(rootDir, Server.DEFAULT_SERVER_CONFIG);
if (!confDir.mkdirs()) {
throw new RuntimeException("Failed to create server configuration directory " + confDir);
}
// if the file is not a default file, we need to copy the file from the resources folder to the server conf dir
if (!configuration.isDefaultFile()) {
copyProvidedServerConfigurationFile();
}
createUserFile("default");
createKeyStores(".pfx", "pkcs12", null);
// Only create BCFKS certs if BCFIPS is on the classpath
if (findProvider(ALL_PROVIDERS, "BC", KeyStore.class, "BCFKS") != null) {
createKeyStores(".bcfks", "BCFKS", "BC");
}
}
@Override
public void start(String name) {
status = ComponentStatus.INITIALIZING;
try {
log.infof("Starting servers %s", name);
start(name, rootDir, new File(configuration.configurationFile()));
log.infof("Started servers %s", name);
status = ComponentStatus.RUNNING;
} catch (Throwable t) {
log.errorf(t, "Unable to start server %s", name);
status = ComponentStatus.FAILED;
throw t;
}
}
@Override
public final void stop(String name) {
if (status != ComponentStatus.INSTANTIATED) {
status = ComponentStatus.STOPPING;
log.infof("Stopping servers %s", name);
stop();
log.infof("Stopped servers %s", name);
}
status = ComponentStatus.TERMINATED;
}
private void copyProvidedServerConfigurationFile() {
ClassLoader classLoader = getClass().getClassLoader();
File configFile = new File(configuration.configurationFile());
if (configFile.isAbsolute()) {
Path source = Paths.get(configFile.getParentFile().getAbsolutePath());
Exceptions.unchecked(() -> Util.recursiveDirectoryCopy(source, confDir.toPath()));
return;
}
URL resourceUrl = classLoader.getResource(configuration.configurationFile());
if (resourceUrl == null) {
throw new RuntimeException("Cannot find test configuration file: " + configuration.configurationFile());
}
Exceptions.unchecked(() -> {
if (resourceUrl.getProtocol().equals("jar")) {
Map<String, String> env = new HashMap<>();
env.put("create", "true");
// If the resourceUrl is a path in a JAR, we must create a filesystem to avoid a FileSystemNotFoundException
String[] parts = resourceUrl.toString().split("!");
URI jarUri = new URI(parts[0]);
try (FileSystem fs = FileSystems.newFileSystem(jarUri, env)) {
String configJarPath = new File(parts[1]).getParentFile().toString();
Path source = fs.getPath(configJarPath);
Util.recursiveDirectoryCopy(source, confDir.toPath());
}
} else {
Path source = Paths.get(resourceUrl.toURI().resolve("."));
Util.recursiveDirectoryCopy(source, confDir.toPath());
}
});
}
protected static File createServerHierarchy(File baseDir) {
return createServerHierarchy(baseDir, null);
}
protected static File createServerHierarchy(File baseDir, String name) {
File rootDir = serverRoot(baseDir, name);
for (String dir : Arrays.asList(
Server.DEFAULT_SERVER_DATA,
Server.DEFAULT_SERVER_LOG,
Server.DEFAULT_SERVER_LIB)
) {
File d = new File(rootDir, dir);
if (!d.exists()) {
if (!d.mkdirs()) {
throw new IllegalStateException("Unable to create directory " + d);
}
}
}
return rootDir;
}
protected static File serverRoot(File baseDir, String name) {
return name == null ? baseDir : new File(baseDir, name);
}
protected void createUserFile(String realm) {
// Create users and groups for individual permissions
UserTool userTool = new UserTool(rootDir.getAbsolutePath());
for (AuthorizationPermission permission : AuthorizationPermission.values()) {
String name = permission.name().toLowerCase();
userTool.createUser(name + "_user", name, realm, UserTool.Encryption.DEFAULT, Collections.singletonList(name), null);
}
// Create users with composite roles
for (TestUser user : TestUser.values()) {
if (user != TestUser.ANONYMOUS) {
userTool.createUser(user.getUser(), user.getPassword(), realm, UserTool.Encryption.DEFAULT, user.getRoles(), null);
}
}
}
protected void copyArtifactsToUserLibDir(File libDir) {
// Maven artifacts
String propertyArtifacts = configuration.properties().getProperty(TestSystemPropertyNames.INFINISPAN_TEST_SERVER_EXTRA_LIBS);
String[] artifacts = propertyArtifacts != null ? propertyArtifacts.replaceAll("\\s+", "").split(",") : configuration.mavenArtifacts();
if (artifacts != null && artifacts.length > 0) {
try {
MavenSettings.init();
for (String artifact : artifacts) {
Path resolved = Artifact.fromString(artifact).resolveArtifact();
Files.copy(resolved, libDir.toPath().resolve(resolved.getFileName()), StandardCopyOption.REPLACE_EXISTING);
}
} catch (IOException e) {
throw new RuntimeException(e);
}
}
// Supplied artifacts
if (configuration.archives() != null) {
for (JavaArchive artifact : configuration.archives()) {
File jar = libDir.toPath().resolve(artifact.getName()).toFile();
jar.setWritable(true, false);
artifact.as(ZipExporter.class).exportTo(jar, true);
}
}
}
@Override
public File getCertificateFile(String name) {
return new File(confDir, name);
}
@Override
public File getRootDir() {
return rootDir;
}
@Override
public File getConfDir() {
return confDir;
}
public String getName() {
return name;
}
/**
* Creates a number of certificates:
* <ul>
* <li><b>ca.pfx</b> A self-signed CA used as the main trust</li>
* <li><b>server.pfx</b> A server certificate signed by the CA</li>
* <li><b>user1.pfx</b> A client certificate signed by the CA</li>
* <li><b>user2.pfx</b> A client certificate signed by the CA</li>
* </ul>
*/
protected void createKeyStores(String extension, String type, String providerName) {
try {
Provider provider = findProvider(ALL_PROVIDERS, providerName, KeyPairGenerator.class, KEY_ALGORITHM);
KeyPairGenerator keyPairGenerator = provider != null ? KeyPairGenerator.getInstance(KEY_ALGORITHM, provider) : KeyPairGenerator.getInstance(KEY_ALGORITHM);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
PrivateKey signingKey = keyPair.getPrivate();
PublicKey publicKey = keyPair.getPublic();
X500Principal CA_DN = dn("CA");
provider = findProvider(ALL_PROVIDERS, providerName, KeyStore.class, type);
KeyStore trustStore = provider != null ? KeyStore.getInstance(type, provider) : KeyStore.getInstance(type);
trustStore.load(null, null);
SelfSignedX509CertificateAndSigningKey ca = createSelfSignedCertificate(CA_DN, true, "ca", extension, type, providerName);
trustStore.setCertificateEntry("ca", ca.getSelfSignedCertificate());
createSignedCertificate(signingKey, publicKey, ca, CA_DN, "server", extension, trustStore);
for (TestUser user : TestUser.values()) {
if (user != TestUser.ANONYMOUS) {
createSignedCertificate(signingKey, publicKey, ca, CA_DN, user.getUser(), extension, trustStore);
}
}
createSignedCertificate(signingKey, publicKey, ca, CA_DN, "supervisor", extension, trustStore);
try (FileOutputStream os = new FileOutputStream(getCertificateFile("trust" + extension))) {
trustStore.store(os, KEY_PASSWORD.toCharArray());
}
createSelfSignedCertificate(CA_DN, true, "untrusted", extension, type, providerName);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
protected static X500Principal dn(String cn) {
return new X500Principal(String.format(BASE_DN, cn));
}
protected SelfSignedX509CertificateAndSigningKey createSelfSignedCertificate(X500Principal dn, boolean isCA, String name, String extension, String type, String providerName) {
SelfSignedX509CertificateAndSigningKey.Builder certificateBuilder = SelfSignedX509CertificateAndSigningKey.builder()
.setDn(dn)
.setSignatureAlgorithmName(KEY_SIGNATURE_ALGORITHM)
.setKeyAlgorithmName(KEY_ALGORITHM);
if (isCA) {
certificateBuilder.addExtension(false, "BasicConstraints", "CA:true,pathlen:2147483647");
}
SelfSignedX509CertificateAndSigningKey certificate = certificateBuilder.build();
X509Certificate issuerCertificate = certificate.getSelfSignedCertificate();
writeKeyStore(getCertificateFile(name + extension), type, providerName, ks -> {
try {
ks.setCertificateEntry(name, issuerCertificate);
} catch (KeyStoreException e) {
throw new RuntimeException(e);
}
});
try (FileWriter w = new FileWriter(new File(confDir, name + extension + ".crt"))) {
w.write("-----BEGIN CERTIFICATE-----\n");
w.write(Base64.getEncoder().encodeToString(issuerCertificate.getEncoded()));
w.write("\n-----END CERTIFICATE-----\n");
} catch (Exception e) {
throw new RuntimeException(e);
}
try (FileWriter w = new FileWriter(new File(confDir, name + extension + ".key"))) {
w.write("-----BEGIN PRIVATE KEY-----\n");
w.write(Base64.getEncoder().encodeToString(certificate.getSigningKey().getEncoded()));
w.write("\n-----END PRIVATE KEY-----\n");
} catch (Exception e) {
throw new RuntimeException(e);
}
return certificate;
}
protected void createSignedCertificate(PrivateKey signingKey, PublicKey publicKey,
SelfSignedX509CertificateAndSigningKey ca,
X500Principal issuerDN,
String name, String extension, KeyStore trustStore) throws CertificateException {
X509Certificate caCertificate = ca.getSelfSignedCertificate();
X509Certificate certificate = new X509CertificateBuilder()
.setIssuerDn(issuerDN)
.setSubjectDn(dn(name))
.setSignatureAlgorithmName(KEY_SIGNATURE_ALGORITHM)
.setSigningKey(ca.getSigningKey())
.setPublicKey(publicKey)
.setSerialNumber(BigInteger.valueOf(certSerial.getAndIncrement()))
.addExtension(new BasicConstraintsExtension(false, false, -1))
.build();
try {
trustStore.setCertificateEntry(name, certificate);
} catch (KeyStoreException e) {
throw new RuntimeException(e);
}
writeKeyStore(getCertificateFile(name + extension), trustStore.getType(), trustStore.getProvider().getName(), ks -> {
try {
ks.setCertificateEntry("ca", caCertificate);
ks.setKeyEntry(name, signingKey, KEY_PASSWORD.toCharArray(), new X509Certificate[]{certificate, caCertificate});
} catch (KeyStoreException e) {
throw new RuntimeException(e);
}
});
}
private void writeKeyStore(File file, String type, String providerName, Consumer<KeyStore> consumer) {
try (FileOutputStream os = new FileOutputStream(file)) {
Provider provider = findProvider(ALL_PROVIDERS, providerName, KeyStore.class, type);
KeyStore keyStore = provider != null ? KeyStore.getInstance(type, provider) : KeyStore.getInstance(type);
keyStore.load(null, null);
consumer.accept(keyStore);
keyStore.store(os, KEY_PASSWORD.toCharArray());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Override
public void applyKeyStore(ConfigurationBuilder builder, String certificateName) {
applyKeyStore(builder, certificateName, "pkcs12", null);
}
@Override
public void applyKeyStore(ConfigurationBuilder builder, String certificateName, String type, String provider) {
builder.security().ssl()
.keyStoreFileName(getCertificateFile(certificateName).getAbsolutePath())
.keyStorePassword(KEY_PASSWORD.toCharArray())
.keyStoreType(type)
.provider(provider);
}
@Override
public void applyKeyStore(RestClientConfigurationBuilder builder, String certificateName) {
applyKeyStore(builder, certificateName, "pkcs12", null);
}
@Override
public void applyKeyStore(RestClientConfigurationBuilder builder, String certificateName, String type, String provider) {
builder.security().ssl()
.keyStoreFileName(getCertificateFile(certificateName).getAbsolutePath())
.keyStorePassword(KEY_PASSWORD.toCharArray())
.keyStoreType(type)
.provider(provider);
}
@Override
public void applyTrustStore(ConfigurationBuilder builder, String certificateName) {
applyTrustStore(builder, certificateName, "pkcs12", null);
}
@Override
public void applyTrustStore(ConfigurationBuilder builder, String certificateName, String type, String provider) {
builder.security().ssl()
.trustStoreFileName(getCertificateFile(certificateName).getAbsolutePath())
.trustStorePassword(KEY_PASSWORD.toCharArray())
.trustStoreType(type)
.provider(provider);
}
@Override
public void applyTrustStore(RestClientConfigurationBuilder builder, String certificateName) {
applyTrustStore(builder, certificateName, "pkcs12", null);
}
@Override
public void applyTrustStore(RestClientConfigurationBuilder builder, String certificateName, String type, String provider) {
builder.security().ssl()
.trustStoreFileName(getCertificateFile(certificateName).getAbsolutePath())
.trustStorePassword(KEY_PASSWORD.toCharArray())
.trustStoreType(type)
.provider(provider);
}
@Override
public void applyTrustStore(ConnectionFactoryBuilder builder, String certificateName) {
applyTrustStore(builder, certificateName, "pkcs12", null);
}
@Override
public void applyTrustStore(ConnectionFactoryBuilder builder, String certificateName, String type, String provider) {
SslContextFactory factory = new SslContextFactory();
SSLContext context = factory.trustStoreFileName(getCertificateFile(certificateName).getAbsolutePath())
.trustStorePassword(KEY_PASSWORD.toCharArray())
.trustStoreType(type)
.provider(provider).getContext();
builder.setSSLContext(context).setSkipTlsHostnameVerification(true);
}
/**
* Pauses the server. Equivalent to kill -SIGSTOP
*
* @param server the index of the server
*/
@Override
public void pause(int server) {
}
@Override
public RemoteCacheManager createRemoteCacheManager(ConfigurationBuilder builder) {
return new RemoteCacheManager(builder.build());
}
public static String abbreviate(String name) {
String[] split = name.split("\\.");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < split.length - 1; i++) {
sb.append(split[i].charAt(0));
sb.append('.');
}
sb.append(split[split.length - 1]);
return sb.toString();
}
}
| 21,008
| 39.093511
| 178
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/persistence/Database.java
|
package org.infinispan.server.test.core.persistence;
import java.util.Properties;
/**
* @author Gustavo Lira <glira@redhat.com>
* @since 10.0
**/
public abstract class Database {
public static final String ENV_PREFIX = "database.container.env.";
private final String type;
protected Properties properties;
protected Database(String type, Properties properties) {
this.type = type;
this.properties = properties;
}
public String getType() {
return type;
}
public String getDataColumnType() {
return properties.getProperty("data.column.type");
}
public String getTimeStampColumnType() {
return properties.getProperty("timestamp.column.type");
}
public String getSegmentColumnType() {
return properties.getProperty("segment.column.type");
}
public String getIdColumType() {
return properties.getProperty("id.column.type");
}
public String jdbcUrl() {
return properties.getProperty("database.jdbc.url");
}
public String username() {
return properties.getProperty("database.jdbc.username");
}
public String password() {
return properties.getProperty("database.jdbc.password");
}
public String driverClassName() {
return properties.getProperty("database.jdbc.driver");
}
public String testQuery() {
return properties.getProperty("database.test.query");
}
public static Database fromProperties(String type, Properties properties) {
String mode = properties.getProperty("database.mode");
switch (mode) {
case "CONTAINER":
return new ContainerDatabase(type, properties);
case "EXTERNAL":
return new ExternalDatabase(type, properties);
default:
throw new IllegalArgumentException(mode);
}
}
public abstract void start();
public abstract void stop();
@Override
public String toString() {
return "Database{" +
"type='" + type + '\'' +
'}';
}
}
| 2,036
| 23.841463
| 78
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/persistence/ContainerDatabase.java
|
package org.infinispan.server.test.core.persistence;
import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.Map;
import java.util.Properties;
import java.util.stream.Collectors;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.util.StringPropertyReplacer;
import org.infinispan.server.test.core.Containers;
import org.infinispan.server.test.core.TestSystemPropertyNames;
import org.testcontainers.containers.GenericContainer;
import org.testcontainers.containers.wait.strategy.LogMessageWaitStrategy;
import org.testcontainers.containers.wait.strategy.Wait;
import org.testcontainers.images.builder.ImageFromDockerfile;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ContainerDatabase extends Database {
private final static Log log = LogFactory.getLog(ContainerDatabase.class);
private final static String ENV_PREFIX = "database.container.env.";
private final GenericContainer container;
private final int port;
ContainerDatabase(String type, Properties properties) {
super(type, properties);
Map<String, String> env = properties.entrySet().stream().filter(e -> e.getKey().toString().startsWith(ENV_PREFIX))
.collect(Collectors.toMap(e -> e.getKey().toString().substring(ENV_PREFIX.length()), e -> e.getValue().toString()));
port = Integer.parseInt(properties.getProperty("database.container.port"));
ImageFromDockerfile image = new ImageFromDockerfile()
.withDockerfileFromBuilder(builder -> {
builder
.from(properties.getProperty("database.container.name") + ":" + properties.getProperty("database.container.tag"))
.expose(port)
.env(env)
.build();
});
container = new GenericContainer(image)
.withExposedPorts(port)
.withPrivilegedMode(true)
.waitingFor(Wait.forListeningPort());
String logMessageWaitStrategy = properties.getProperty(TestSystemPropertyNames.INFINISPAN_TEST_CONTAINER_DATABASE_LOG_MESSAGE);
if (logMessageWaitStrategy != null) {
container.waitingFor(new LogMessageWaitStrategy()
.withRegEx(logMessageWaitStrategy)
.withStartupTimeout(Duration.of(10, ChronoUnit.MINUTES)));
}
}
@Override
public void start() {
log.infof("Starting database %s", getType());
container.start();
}
@Override
public void stop() {
log.infof("Stopping database %s", getType());
container.stop();
log.infof("Stopped database %s", getType());
}
public int getPort() {
return container.getMappedPort(port);
}
@Override
public String jdbcUrl() {
String address = Containers.ipAddress(container);
Properties props = new Properties();
props.setProperty("container.address", address);
return StringPropertyReplacer.replaceProperties(super.jdbcUrl(), props);
}
@Override
public String username() {
Properties props = new Properties();
return StringPropertyReplacer.replaceProperties(super.username(), props);
}
@Override
public String password() {
Properties props = new Properties();
return StringPropertyReplacer.replaceProperties(super.password(), props);
}
}
| 3,422
| 36.206522
| 134
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/persistence/ExternalDatabase.java
|
package org.infinispan.server.test.core.persistence;
import java.util.Properties;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ExternalDatabase extends Database {
public ExternalDatabase(String type, Properties properties) {
super(type, properties);
}
@Override
public void start() {
// Do nothing
}
@Override
public void stop() {
// Do nothing
}
}
| 445
| 17.583333
| 64
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/core/persistence/DatabaseServerListener.java
|
package org.infinispan.server.test.core.persistence;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Properties;
import org.infinispan.server.test.core.InfinispanServerDriver;
import org.infinispan.server.test.core.InfinispanServerListener;
import org.jboss.logging.Logger;
import static org.infinispan.server.test.core.TestSystemPropertyNames.INFINISPAN_TEST_CONTAINER_DATABASE_PROPERTIES;
import static org.infinispan.server.test.core.TestSystemPropertyNames.INFINISPAN_TEST_CONTAINER_DATABASE_TYPES;
/**
* @author Gustavo Lira <glira@redhat.com>
* @since 10.0
**/
public class DatabaseServerListener implements InfinispanServerListener {
private static final Logger log = Logger.getLogger(DatabaseServerListener.class);
private static final String DATABASE_PROPERTIES = "org.infinispan.server.test.database.%s.%s";
private final String[] databaseTypes;
public Map<String, Database> databases;
public DatabaseServerListener(String... databaseTypes) {
String property = System.getProperty(INFINISPAN_TEST_CONTAINER_DATABASE_TYPES);
if (property != null) {
this.databaseTypes = property.split(",");
log.infof("Overriding databases: %s", this.databaseTypes);
} else {
this.databaseTypes = databaseTypes;
}
}
@Override
public void before(InfinispanServerDriver driver) {
databases = new LinkedHashMap<>(databaseTypes.length);
for (String dbType : databaseTypes) {
Database database = initDatabase(dbType);
log.infof("Starting database: %s", database.getType());
database.start();
log.infof("Started database: %s", database.getType());
if (databases.putIfAbsent(dbType, database) != null) {
throw new RuntimeException("Duplicate database type " + dbType);
}
addDbProperty(driver, database,"jdbcUrl", database.jdbcUrl());
addDbProperty(driver, database,"username", database.username());
addDbProperty(driver, database,"password", database.password());
addDbProperty(driver, database,"driver", database.driverClassName());
}
}
@Override
public void after(InfinispanServerDriver driver) {
log.info("Stopping databases");
databases.values().forEach(Database::stop);
log.info("Stopped databases");
}
public Database getDatabase(String databaseType) {
return databases.get(databaseType);
}
public String[] getDatabaseTypes() {
return databaseTypes;
}
private Database initDatabase(String databaseType) {
String property = System.getProperty(INFINISPAN_TEST_CONTAINER_DATABASE_PROPERTIES);
try (InputStream inputStream = property != null ? Files.newInputStream(Paths.get(property).resolve(databaseType + ".properties")) : getClass().getResourceAsStream(String.format("/database/%s.properties", databaseType))) {
Properties properties = new Properties();
properties.load(inputStream);
return Database.fromProperties(databaseType, properties);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private void addDbProperty(InfinispanServerDriver driver, Database database, String parameterProperty, String dbProperty) {
driver.getConfiguration().properties().put(String.format(DATABASE_PROPERTIES, database.getType(), parameterProperty),dbProperty);
}
}
| 3,503
| 40.223529
| 227
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/BaseTestClientDriver.java
|
package org.infinispan.server.test.api;
import java.util.EnumSet;
import org.infinispan.commons.api.CacheContainerAdmin;
import org.infinispan.commons.configuration.BasicConfiguration;
import org.infinispan.commons.configuration.Self;
import org.infinispan.commons.configuration.StringConfiguration;
import org.infinispan.configuration.cache.CacheMode;
/**
* Base class for the driver API
*
* @since 10
* @param <S>
* @author Tristan Tarrant
*/
abstract class BaseTestClientDriver<S extends BaseTestClientDriver<S>> implements Self<S> {
protected BasicConfiguration serverConfiguration = null;
protected EnumSet<CacheContainerAdmin.AdminFlag> flags = EnumSet.noneOf(CacheContainerAdmin.AdminFlag.class);
protected CacheMode mode = null;
protected Object[] qualifiers;
public S withServerConfiguration(org.infinispan.configuration.cache.ConfigurationBuilder serverConfiguration) {
if (mode != null) {
throw new IllegalStateException("Cannot set server configuration and cache mode");
}
this.serverConfiguration = serverConfiguration.build();
return self();
}
public S withServerConfiguration(StringConfiguration configuration) {
if (mode != null) {
throw new IllegalStateException("Cannot set server configuration and cache mode");
}
this.serverConfiguration = configuration;
return self();
}
public S withCacheMode(CacheMode mode) {
if (serverConfiguration != null) {
throw new IllegalStateException("Cannot set server configuration and cache mode");
}
this.mode = mode;
return self();
}
public S withQualifier(String qualifier) {
return withQualifiers(qualifier);
}
public S withQualifiers(Object... qualifiers) {
this.qualifiers = qualifiers;
return self();
}
public S makeVolatile() {
this.flags = EnumSet.of(CacheContainerAdmin.AdminFlag.VOLATILE);
return self();
}
}
| 1,964
| 30.693548
| 114
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/RespTestClientDriver.java
|
package org.infinispan.server.test.api;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.infinispan.server.test.core.TestClient;
import org.infinispan.server.test.core.TestServer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.lettuce.core.ClientOptions;
import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.resource.ClientResources;
public class RespTestClientDriver extends BaseTestClientDriver<RespTestClientDriver> {
private static final Logger log = LoggerFactory.getLogger(RespTestClientDriver.class);
private final TestServer testServer;
private final TestClient testClient;
private LettuceConfiguration configuration;
public RespTestClientDriver(TestServer testServer, TestClient testClient) {
this.testServer = testServer;
this.testClient = testClient;
}
@Override
public RespTestClientDriver self() {
return this;
}
public RespTestClientDriver withConfiguration(LettuceConfiguration configuration) {
this.configuration = configuration;
return self();
}
public RedisClient get() {
ClientResources resources = configuration.clientResources.build();
RedisClient client = RedisClient.create(resources, configuration.redisURI);
client.setOptions(configuration.clientOptions);
testClient.registerResource(() -> {
try {
resources.shutdown(0, 15, TimeUnit.SECONDS).getNow();
client.shutdownAsync(0, 15, TimeUnit.SECONDS).get(15, TimeUnit.SECONDS);
} catch (InterruptedException | TimeoutException | ExecutionException e) {
log.error("Timed out waiting RESP client to shutdown", e);
}
});
return client;
}
public StatefulRedisConnection<String, String> connect(RedisClient client) {
StatefulRedisConnection<String, String> connection = client.connect();
testClient.registerResource(connection::close);
return connection;
}
public StatefulRedisConnection<String, String> getConnection() {
return connect(get());
}
public static class LettuceConfiguration {
private final ClientResources.Builder clientResources;
private final ClientOptions clientOptions;
private final RedisURI redisURI;
public LettuceConfiguration(ClientResources.Builder clientResourcesBuilder, ClientOptions clientOptions, RedisURI redisURI) {
this.clientResources = clientResourcesBuilder;
this.clientOptions = clientOptions;
this.redisURI = redisURI;
}
}
}
| 2,715
| 33.820513
| 131
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/RestTestClientDriver.java
|
package org.infinispan.server.test.api;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.RestEntity;
import org.infinispan.client.rest.RestResponse;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.api.CacheContainerAdmin;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.TestClient;
import org.infinispan.server.test.core.TestServer;
/**
* REST operations for the testing framework
*
* @author Tristan Tarrant
* @since 10
*/
public class RestTestClientDriver extends BaseTestClientDriver<RestTestClientDriver> {
public static final int TIMEOUT = Integer.getInteger("org.infinispan.test.server.http.timeout", 10);
private RestClientConfigurationBuilder clientConfiguration = new RestClientConfigurationBuilder();
private TestServer testServer;
private TestClient testClient;
private int port = 11222;
public RestTestClientDriver(TestServer testServer, TestClient testClient) {
this.testServer = testServer;
this.testClient = testClient;
}
/**
* Provide a custom client configuration to connect to the server via REST
*
* @param clientConfiguration
* @return the current {@link RestTestClientDriver} instance with the rest client configuration override
*/
public RestTestClientDriver withClientConfiguration(RestClientConfigurationBuilder clientConfiguration) {
this.clientConfiguration = clientConfiguration;
return this;
}
public RestTestClientDriver withPort(int port) {
this.port = port;
return this;
}
/**
* Create and get a REST client.
*
* @return a new instance of the {@link RestClient}
*/
public RestClient get() {
return testClient.registerResource(testServer.newRestClient(clientConfiguration, port));
}
/**
* Create and get a REST client that is connected to the Nth server of the cluster.
*
* @return a new instance of the {@link RestClient}
*/
public RestClient get(int n) {
return testClient.registerResource(testServer.newRestClientForServer(clientConfiguration, port, n));
}
/**
* Create a new REST client and create a cache whose name will be the test name where this method
* is called from.
*
* @return new {@link RestClient} instance
*/
public RestClient create() {
RestClient restClient = get();
String name = testClient.getMethodName(qualifiers);
CompletionStage<RestResponse> future;
if (serverConfiguration != null) {
RestEntity configEntity = RestEntity.create(MediaType.APPLICATION_XML, serverConfiguration.toStringConfiguration(name));
future = restClient.cache(name).createWithConfiguration(configEntity, flags.toArray(new CacheContainerAdmin.AdminFlag[0]));
} else if (mode != null) {
future = restClient.cache(name).createWithTemplate("org.infinispan." + mode.name(), flags.toArray(new CacheContainerAdmin.AdminFlag[0]));
} else {
future = restClient.cache(name).createWithTemplate("org.infinispan." + CacheMode.DIST_SYNC.name(), flags.toArray(new CacheContainerAdmin.AdminFlag[0]));
}
try (RestResponse response = Exceptions.unchecked(() -> future.toCompletableFuture().get(TIMEOUT, TimeUnit.SECONDS))) {
if (response.getStatus() != 200) {
switch (response.getStatus()) {
case 400:
throw new IllegalArgumentException("Bad request while attempting to obtain rest client: " + response.getStatus());
case 401:
case 403:
throw new SecurityException("Authentication error while attempting to obtain rest client = " + response.getStatus());
default:
throw new RuntimeException("Could not obtain rest client = " + response.getStatus());
}
} else {
// If the request succeeded without authn but we were expecting to authenticate, it's an error
if (restClient.getConfiguration().security().authentication().enabled() && !response.usedAuthentication()) {
throw new SecurityException("Authentication expected but anonymous access succeeded");
}
return restClient;
}
}
}
@Override
public RestTestClientDriver self() {
return this;
}
}
| 4,608
| 39.429825
| 161
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/TestClientXSiteDriver.java
|
package org.infinispan.server.test.api;
import org.infinispan.client.hotrod.multimap.MultimapCacheManager;
import org.infinispan.counter.api.CounterManager;
/**
* Test client driver interface contains the methods we want to expose to be used from test methods
*
* @author Gustavo Lira
* @since 12
*/
public interface TestClientXSiteDriver {
/**
* Get the HotRod instance for hotrod api operations
*
* @return {@link HotRodTestClientDriver} instance
*/
HotRodTestClientDriver hotrod(String siteName);
/**
* Get the REST instance for hotrod api operations
*
* @return {@link RestTestClientDriver} instance}
*/
RestTestClientDriver rest(String siteName);
MemcachedTestClientDriver memcached(String siteName);
/**
* Provides the current method name
*
* @return String, the method name
*/
String getMethodName();
/**
* Access to the {@link CounterManager} to perform counters operations on tests
*
* @return the {@link CounterManager} instance
*/
CounterManager getCounterManager(String siteName);
/**
* Access to the {@link MultimapCacheManager} to perform multimap operations on tests.
*
* @return the {@link MultimapCacheManager} instance.
*/
<K, V> MultimapCacheManager<K, V> getMultimapCacheManager(String siteName);
}
| 1,345
| 25.392157
| 99
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/MemcachedTestClientDriver.java
|
package org.infinispan.server.test.api;
import org.infinispan.server.test.core.TestClient;
import org.infinispan.server.test.core.TestServer;
import net.spy.memcached.ClientMode;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.auth.AuthDescriptor;
/**
* Memcached operations for the testing framework
*
* @author Tristan Tarrant
* @since 15
*/
public class MemcachedTestClientDriver extends BaseTestClientDriver<MemcachedTestClientDriver> {
private final TestServer testServer;
private final TestClient testClient;
private ConnectionFactoryBuilder builder;
private int port = 11222; // single port
public MemcachedTestClientDriver(TestServer testServer, TestClient testClient) {
this.testServer = testServer;
this.testClient = testClient;
ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
applyDefaultConfiguration(builder);
this.builder = builder;
}
public MemcachedTestClientDriver withClientConfiguration(ConnectionFactoryBuilder builder) {
this.builder = applyDefaultConfiguration(builder);
return this;
}
public MemcachedTestClientDriver withPort(int port) {
this.port = port;
return this;
}
public MemcachedClient get() {
return testClient.registerResource(testServer.newMemcachedClient(builder, port)).getClient();
}
@Override
public MemcachedTestClientDriver self() {
return this;
}
private ConnectionFactoryBuilder applyDefaultConfiguration(ConnectionFactoryBuilder builder) {
if (testServer.isContainerRunWithDefaultServerConfig()) {
// Configure admin user by default
builder.setAuthDescriptor(AuthDescriptor.typical(TestUser.ADMIN.getUser(), TestUser.ADMIN.getPassword()));
}
builder.setClientMode(ClientMode.Static);
return builder;
}
}
| 1,912
| 30.883333
| 115
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/HotRodTestClientDriver.java
|
package org.infinispan.server.test.api;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ClientIntelligence;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.TestClient;
import org.infinispan.server.test.core.TestServer;
/**
* REST operations for the testing framework
*
* @author Tristan Tarrant
* @since 10
*/
public class HotRodTestClientDriver extends BaseTestClientDriver<HotRodTestClientDriver> {
private final TestServer testServer;
private final TestClient testClient;
private ConfigurationBuilder clientConfiguration;
private int port = 11222;
public HotRodTestClientDriver(TestServer testServer, TestClient testClient) {
this.testServer = testServer;
this.testClient = testClient;
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.maxRetries(1).connectionPool().maxActive(1);
applyDefaultConfiguration(builder);
this.clientConfiguration = builder;
}
/**
* Provide a custom client configuration to connect to the server.
*
* @param clientConfiguration
* @return the current {@link HotRodTestClientDriver} instance with the client configuration override
*/
public HotRodTestClientDriver withClientConfiguration(ConfigurationBuilder clientConfiguration) {
this.clientConfiguration = applyDefaultConfiguration(clientConfiguration);
return this;
}
/**
* Provide the Client Intelligence override
*
* @param clientIntelligence
* @return the current {@link HotRodTestClientDriver} instance with the client intelligence override
*/
public HotRodTestClientDriver withClientConfiguration(ClientIntelligence clientIntelligence) {
clientConfiguration.clientIntelligence(clientIntelligence);
return this;
}
/**
* The {@link Marshaller} to be used by the client.
*
* @param marshallerClass
* @return the current {@link HotRodTestClientDriver} instance with the Marshaller configuration override
*/
public HotRodTestClientDriver withMarshaller(Class<? extends Marshaller> marshallerClass) {
this.clientConfiguration.marshaller(marshallerClass);
return this;
}
public HotRodTestClientDriver withPort(int port) {
this.port = port;
return this;
}
/**
* Gets a cache with the name of the method where this method is being called from
*
* @return {@link RemoteCache}, the cache is such exist
*/
public <K, V> RemoteCache<K, V> get() {
RemoteCacheManager remoteCacheManager = createRemoteCacheManager();
String name = testClient.getMethodName(qualifiers);
return remoteCacheManager.getCache(name);
}
/**
* Gets a cache with the provided name
*
* @return {@link RemoteCache}, the cache is such exist
*/
public <K, V> RemoteCache<K, V> get(String name) {
RemoteCacheManager remoteCacheManager = createRemoteCacheManager();
return remoteCacheManager.getCache(name);
}
/**
* Created a cache with the name of the method where this method is being called from.
* If the cache already exists, retrieves the existing cache
*
* @return {@link RemoteCache}, the cache
*/
public <K, V> RemoteCache<K, V> create() {
return create(-1);
}
/**
* Create a cache adding in the initial server list the server address given by the index
* @param index the server index, -1 for all
* @return {@link RemoteCache}, the cache
*/
public <K, V> RemoteCache<K, V> create(int index) {
RemoteCacheManager remoteCacheManager;
if (index >= 0) {
remoteCacheManager = createRemoteCacheManager(index);
} else {
remoteCacheManager = createRemoteCacheManager();
}
String name = testClient.getMethodName(qualifiers);
if (serverConfiguration != null) {
return remoteCacheManager.administration().withFlags(flags).getOrCreateCache(name, serverConfiguration);
} else if (mode != null) {
return remoteCacheManager.administration().withFlags(flags).getOrCreateCache(name, "org.infinispan." + mode.name());
} else {
return remoteCacheManager.administration().withFlags(flags).getOrCreateCache(name, "org.infinispan." + CacheMode.DIST_SYNC.name());
}
}
public RemoteCacheManager createRemoteCacheManager() {
return testClient.registerResource(testServer.newHotRodClient(clientConfiguration, port));
}
public RemoteCacheManager createRemoteCacheManager(int index) {
return testClient.registerResource(testServer.newHotRodClient(clientConfiguration, port, index));
}
@Override
public HotRodTestClientDriver self() {
return this;
}
private ConfigurationBuilder applyDefaultConfiguration(ConfigurationBuilder builder) {
if (testServer.isContainerRunWithDefaultServerConfig()) {
// Configure admin user by default
builder.security().authentication().username(TestUser.ADMIN.getUser()).password(TestUser.ADMIN.getPassword());
}
return builder;
}
}
| 5,314
| 35.156463
| 140
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/TestUser.java
|
package org.infinispan.server.test.api;
import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
/**
* Users and Roles generated by the testing driver
*
* @see {@link org.infinispan.server.test.core.AbstractInfinispanServerDriver}
*
* @author Katia Aresti
* @since 11
*/
public enum TestUser {
ADMIN("admin", "strongPassword", Arrays.asList("admin", "___schema_manager", "___script_manager")),
OBSERVER("observer", "password", Collections.singletonList("observer")),
APPLICATION("application", "somePassword", Collections.singletonList("application")),
DEPLOYER("deployer", "lessStrongPassword", Collections.singletonList("deployer")),
MONITOR("monitor", "weakPassword", Collections.singletonList("monitor")),
READER("reader", "readerPassword", Collections.singletonList("reader")),
WRITER("writer", "writerPassword", Collections.singletonList("writer")),
ANONYMOUS(null, null, null);
public static final EnumSet<TestUser> NON_ADMINS = EnumSet.complementOf(EnumSet.of(TestUser.ADMIN, TestUser.ANONYMOUS));
public static final EnumSet<TestUser> ALL = EnumSet.complementOf(EnumSet.of(TestUser.ANONYMOUS));
private final String user;
private final String password;
private final List<String> roles;
TestUser(String user, String password, List<String> roles) {
this.user = user;
this.password = password;
this.roles = roles;
}
public String getUser() {
return user;
}
public String getPassword() {
return password;
}
public List<String> getRoles() {
return roles;
}
}
| 1,625
| 30.882353
| 123
|
java
|
null |
infinispan-main/server/testdriver/core/src/main/java/org/infinispan/server/test/api/TestClientDriver.java
|
package org.infinispan.server.test.api;
import org.infinispan.counter.api.CounterManager;
/**
* Test client driver interface contains the methods we want to expose to be used from test methods
*
* @author Katia Aresti
* @since 11
*/
public interface TestClientDriver {
/**
* Get the HotRod instance for hotrod api operations
*
* @return {@link HotRodTestClientDriver} instance
*/
HotRodTestClientDriver hotrod();
/**
* Get the REST instance
* @return {@link RestTestClientDriver} instance}
*/
RestTestClientDriver rest();
/**
* Get the RESP instance.
* @return {@link RespTestClientDriver} instance.
*/
RespTestClientDriver resp();
/**
* Get the Memcached instance
* @return {@link MemcachedTestClientDriver} instance}
*/
MemcachedTestClientDriver memcached();
/**
* Returns a unique identifier for the current test method
*
* @return String, the identifier
*/
String getMethodName();
/**
* Returns a unique identifier for the current test method
*
* @param qualifier an additional qualifier
* @return String, the identifier
*/
String getMethodName(String qualifier);
/**
* Access to the {@link CounterManager} to perform counters operations on tests
*
* @return the {@link CounterManager} instance
*/
CounterManager getCounterManager();
}
| 1,400
| 22.35
| 99
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/test/java/org/infinispan/server/test/junit4/InfinispanRuleBasicTest.java
|
package org.infinispan.server.test.junit4;
import static org.junit.Assert.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.configuration.cache.CacheMode;
import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
public class InfinispanRuleBasicTest {
@ClassRule
public static final InfinispanServerRule SERVER = InfinispanServerRuleBuilder.server();
@Rule
public InfinispanServerTestMethodRule SERVER_TEST = new InfinispanServerTestMethodRule(SERVER);
@Test
public void testSingleServer() {
RemoteCache<String, String> cache = SERVER_TEST
.hotrod()
.withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
}
| 817
| 27.206897
| 98
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/main/java/org/infinispan/server/test/junit4/InfinispanXSiteServerRuleBuilder.java
|
package org.infinispan.server.test.junit4;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.server.test.core.TestServer;
/**
* Builder for {@link InfinispanXSiteServerRule}.
*
* @author Gustavo Lira <gliraesi@redhat.com>
* @since 12.0
*/
public class InfinispanXSiteServerRuleBuilder {
private final List<InfinispanServerRuleBuilder> sites = new ArrayList<>();
public InfinispanXSiteServerRuleBuilder addSite(String siteName, InfinispanServerRuleBuilder siteBuilder) {
siteBuilder.site(siteName);
sites.add(siteBuilder);
return this;
}
public InfinispanXSiteServerRule build() {
Set<String> uniqueSiteName = new HashSet<>();
List<TestServer> sitesTestServers = sites.stream()
.map(InfinispanServerRuleBuilder::build)
.map(InfinispanServerRule::getTestServer)
.peek(testServer -> {
if (!uniqueSiteName.add(testServer.getSiteName())) {
throw new IllegalStateException("Site name already set: " + testServer.getSiteName());
}
})
.collect(Collectors.toList());
return new InfinispanXSiteServerRule(sitesTestServers);
}
}
| 1,303
| 29.325581
| 110
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/main/java/org/infinispan/server/test/junit4/InfinispanServerTestMethodRule.java
|
package org.infinispan.server.test.junit4;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicInteger;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.server.test.api.HotRodTestClientDriver;
import org.infinispan.server.test.api.MemcachedTestClientDriver;
import org.infinispan.server.test.api.RespTestClientDriver;
import org.infinispan.server.test.api.RestTestClientDriver;
import org.infinispan.server.test.api.TestClientDriver;
import org.infinispan.server.test.core.TestClient;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class InfinispanServerTestMethodRule implements TestRule, TestClientDriver {
private final TestClient testClient;
private static final AtomicInteger KCOUNTER = new AtomicInteger(0);
public InfinispanServerTestMethodRule(InfinispanServerRule infinispanServerRule) {
Objects.requireNonNull(infinispanServerRule, "InfinispanServerRule class Rule is null");
this.testClient = new TestClient(infinispanServerRule.getTestServer());
}
@Override
public String getMethodName() {
return testClient.getMethodName();
}
@Override
public String getMethodName(String qualifier) {
return testClient.getMethodName(qualifier);
}
@Override
public HotRodTestClientDriver hotrod() {
return testClient.hotrod();
}
@Override
public RestTestClientDriver rest() {
return testClient.rest();
}
@Override
public RespTestClientDriver resp() {
return testClient.resp();
}
@Override
public MemcachedTestClientDriver memcached() {
return testClient.memcached();
}
@Override
public CounterManager getCounterManager() {
return testClient.getCounterManager();
}
@Override
public Statement apply(Statement base, Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
testClient.initResources();
try {
testClient.setMethodName(description.getTestClass().getSimpleName() + "." + description.getMethodName());
base.evaluate();
} finally {
testClient.clearResources();
}
}
};
}
public String addScript(RemoteCacheManager remoteCacheManager, String script) {
return testClient.addScript(remoteCacheManager, script);
}
public RestClient newRestClient(RestClientConfigurationBuilder restClientConfigurationBuilder) {
return testClient.newRestClient(restClientConfigurationBuilder);
}
public static final String k() {
return "k-" + KCOUNTER.incrementAndGet();
}
}
| 2,996
| 30.21875
| 120
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/main/java/org/infinispan/server/test/junit4/InfinispanServerTestListener.java
|
package org.infinispan.server.test.junit4;
import org.infinispan.server.test.core.ContainerInfinispanServerDriver;
import org.junit.runner.Result;
import org.junit.runner.notification.RunListener;
public class InfinispanServerTestListener extends RunListener {
@Override
public void testRunFinished(Result result) {
ContainerInfinispanServerDriver.cleanup();
}
}
| 380
| 28.307692
| 71
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/main/java/org/infinispan/server/test/junit4/InfinispanServerRuleBuilder.java
|
package org.infinispan.server.test.junit4;
import static org.infinispan.server.test.core.AbstractInfinispanServerDriver.DEFAULT_CLUSTERED_INFINISPAN_CONFIG_FILE_NAME;
import org.infinispan.server.test.core.AbstractServerConfigBuilder;
import org.infinispan.server.test.core.ServerRunMode;
/**
* Builder for {@link InfinispanServerRule}.
*
* @author Diego Lovison <dlovison@redhat.com>
* @author Dan Berindei
* @since 10.0
**/
public class InfinispanServerRuleBuilder extends AbstractServerConfigBuilder<InfinispanServerRuleBuilder> {
/**
* Use this method to instantiate a single clustered embedded server
*
* @return InfinispanServerRule
*/
public static InfinispanServerRule server() {
return server(true);
}
public static InfinispanServerRule server(boolean container) {
return new InfinispanServerRuleBuilder(DEFAULT_CLUSTERED_INFINISPAN_CONFIG_FILE_NAME, true)
.numServers(1)
.runMode(container? ServerRunMode.CONTAINER : ServerRunMode.EMBEDDED)
.parallelStartup(false)
.build();
}
public static InfinispanServerRule server(String configurationFile) {
return new InfinispanServerRuleBuilder(configurationFile, false)
.numServers(1)
.runMode(ServerRunMode.CONTAINER)
.parallelStartup(false)
.build();
}
public static InfinispanServerRuleBuilder config(String configurationFile) {
return new InfinispanServerRuleBuilder(configurationFile, false);
}
private InfinispanServerRuleBuilder(String configurationFile, boolean defaultFile) {
super(configurationFile, defaultFile);
}
public InfinispanServerRule build() {
return new InfinispanServerRule(createServerTestConfiguration());
}
}
| 1,793
| 32.849057
| 123
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/main/java/org/infinispan/server/test/junit4/InfinispanServerRule.java
|
package org.infinispan.server.test.junit4;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import org.infinispan.commons.logging.Log;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.server.test.core.InfinispanServerDriver;
import org.infinispan.server.test.core.InfinispanServerTestConfiguration;
import org.infinispan.server.test.core.TestServer;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.model.Statement;
/**
* Creates a cluster of servers to be used for running multiple tests It performs the following tasks:
* <ul>
* <li>It creates a temporary directory using the test name</li>
* <li>It creates a common configuration directory to be shared by all servers</li>
* <li>It creates a runtime directory structure for each server in the cluster (data, log, lib)</li>
* <li>It populates the configuration directory with multiple certificates (ca.pfx, server.pfx, user1.pfx, user2.pfx)</li>
* </ul>
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class InfinispanServerRule implements TestRule {
private static final Log log = LogFactory.getLog(InfinispanServerRule.class);
private final TestServer testServer;
protected final List<Consumer<File>> configurationEnhancers = new ArrayList<>();
public InfinispanServerRule(InfinispanServerTestConfiguration configuration) {
this.testServer = new TestServer(configuration);
}
public InfinispanServerDriver getServerDriver() {
return testServer.getDriver();
}
@Override
public Statement apply(Statement base, Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
String testName = description.getTestClass().getName().replaceAll("\\$", "-");
RunWith runWith = description.getTestClass().getAnnotation(RunWith.class);
boolean inSuite = runWith != null && Suite.class.isAssignableFrom(runWith.value());
boolean hasXsite = testServer.hasCrossSiteEnabled();
if (!inSuite && !hasXsite) {
TestResourceTracker.testStarted(testName);
}
// Don't manage the server when a test is using the same InfinispanServerRule instance as the parent suite
boolean manageServer = !testServer.isDriverInitialized();
try {
if (manageServer) {
testServer.initServerDriver();
testServer.getDriver().prepare(testName);
testServer.beforeListeners();
configurationEnhancers.forEach(c -> c.accept(testServer.getDriver().getConfDir()));
testServer.getDriver().start(testName);
}
InfinispanServerRule.this.before(testName);
base.evaluate();
} catch (Throwable e) {
log.error("Problem during the server initialization", e);
throw e;
} finally {
InfinispanServerRule.this.after(testName);
if (manageServer && testServer.isDriverInitialized()) {
testServer.stopServerDriver(testName);
testServer.afterListeners();
}
if (!inSuite && !hasXsite) {
TestResourceTracker.testFinished(testName);
}
}
}
};
}
private void before(String name) {
}
private void after(String name) {
}
public TestServer getTestServer() {
return testServer;
}
public static Log getLog() {
return log;
}
}
| 3,833
| 37.34
| 122
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/main/java/org/infinispan/server/test/junit4/InfinispanXSiteServerTestMethodRule.java
|
package org.infinispan.server.test.junit4;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import javax.management.MBeanServerConnection;
import org.infinispan.client.hotrod.multimap.MultimapCacheManager;
import org.infinispan.counter.api.CounterManager;
import org.infinispan.server.test.api.HotRodTestClientDriver;
import org.infinispan.server.test.api.MemcachedTestClientDriver;
import org.infinispan.server.test.api.RestTestClientDriver;
import org.infinispan.server.test.api.TestClientXSiteDriver;
import org.infinispan.server.test.core.TestClient;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
/**
* @author Gustavo Lira <glira@redhat.com>
* @since 12.0
**/
public class InfinispanXSiteServerTestMethodRule implements TestRule, TestClientXSiteDriver {
private final Map<String, TestClient> testClients = new HashMap<>();
public InfinispanXSiteServerTestMethodRule(InfinispanXSiteServerRule serverRule) {
Objects.requireNonNull(serverRule, "InfinispanServerRule class Rule is null");
serverRule.getTestServers().forEach((it) -> this.testClients.put(it.getSiteName(), new TestClient(it)));
}
@Override
public String getMethodName() {
return testClients.values().iterator().next().getMethodName();
}
@Override
public HotRodTestClientDriver hotrod(String siteName) {
return testClients.get(siteName).hotrod();
}
@Override
public RestTestClientDriver rest(String siteName) {
return testClients.get(siteName).rest();
}
@Override
public MemcachedTestClientDriver memcached(String siteName) {
return testClients.get(siteName).memcached();
}
@Override
public CounterManager getCounterManager(String siteName) {
return testClients.get(siteName).getCounterManager();
}
@Override
public <K, V> MultimapCacheManager<K, V> getMultimapCacheManager(String siteName) {
return testClients.get(siteName).getRemoteMultimapCacheManager();
}
public MBeanServerConnection getJmxConnection(String siteName, int server) {
return testClients.get(siteName).getServerDriver().getJmxConnection(server);
}
@Override
public Statement apply(Statement base, Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
try {
testClients.values().forEach((testClient) -> {
testClient.initResources();
testClient.setMethodName(description.getTestClass().getSimpleName() + "." + description.getMethodName());
});
base.evaluate();
} finally {
testClients.values().forEach(TestClient::clearResources);
}
}
};
}
}
| 2,841
| 32.833333
| 123
|
java
|
null |
infinispan-main/server/testdriver/junit4/src/main/java/org/infinispan/server/test/junit4/InfinispanXSiteServerRule.java
|
package org.infinispan.server.test.junit4;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.server.test.core.TestServer;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runners.model.Statement;
/**
* Creates a cluster of sites to be used for running multiple tests
* for Cross-Site replication functionality, It performs the following tasks
* <ul>
* <li>It creates a temporary directory using the test name</li>
* <li>It creates a runtime directory structure for each server in the cluster (data, log, lib)</li>
* <li>It populates the configuration directory with multiple certificates (ca.pfx, server.pfx, user1.pfx, user2.pfx)</li>
* </ul>
*
* @author Gustavo Lira <gliraesi@redhat.com>
* @since 12.0
**/
public class InfinispanXSiteServerRule implements TestRule {
private final List<TestServer> testServers;
public InfinispanXSiteServerRule(List<TestServer> testServers) {
this.testServers = testServers;
}
@Override
public Statement apply(Statement base, Description description) {
return new Statement() {
@Override
public void evaluate() throws Throwable {
List<TestServer> servers = new ArrayList<>();
String testName = description.getTestClass().getName();
try {
testServers.forEach((testServer) -> {
// Don't manage the server when a test is using the same InfinispanServerRule instance as the parent suite
if (!testServer.isDriverInitialized()) {
servers.add(testServer);
testServer.initServerDriver();
testServer.beforeListeners();
testServer.getDriver().prepare(testName);
testServer.getDriver().start(testName);
}
});
base.evaluate();
} finally {
servers.forEach((testServer) -> {
testServer.getDriver().stop(testName);
testServer.afterListeners();
});
}
}
};
}
public List<TestServer> getTestServers() {
return testServers;
}
}
| 2,234
| 34.47619
| 124
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/binary/MemcachedBinaryFunctionalTest.java
|
package org.infinispan.server.memcached.binary;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import java.lang.reflect.Method;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.test.MemcachedFunctionalTest;
import org.testng.annotations.Test;
import net.spy.memcached.CASValue;
/**
* @since 15.0
**/
@Test(groups = "functional", testName = "server.memcached.binary.MemcachedBinaryFunctionalTest")
public class MemcachedBinaryFunctionalTest extends MemcachedFunctionalTest {
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.BINARY;
}
@Override
protected boolean withAuthentication() {
return false;
}
public void testSetBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
String k = k(m);
String v = v(m);
wait(client.set(k, 0, v));
CASValue<Object> v1 = client.gets(k);
assertEquals(v, v1.getValue());
wait(client.set(k, 0, v + "+"));
CASValue<Object> v2 = client.gets(k);
assertEquals(v + "+", v2.getValue());
assertFalse(v1.getCas() == v2.getCas());
wait(client.delete(k));
}
}
| 1,456
| 30
| 105
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/binary/MemcachedBinaryAuthenticationTest.java
|
package org.infinispan.server.memcached.binary;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import java.lang.reflect.Method;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.test.MemcachedSingleNodeTest;
import org.testng.annotations.Test;
import net.spy.memcached.CASValue;
/**
* @since 15.0
**/
@Test(groups = "functional", testName = "server.memcached.binary.MemcachedBinaryAuthenticationTest")
public class MemcachedBinaryAuthenticationTest extends MemcachedSingleNodeTest {
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.BINARY;
}
@Override
protected boolean withAuthentication() {
return true;
}
public void testSetBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
String k = k(m);
String v = v(m);
wait(client.set(k, 0, v));
CASValue<Object> v1 = client.gets(k);
assertEquals(v, v1.getValue());
wait(client.set(k, 0, v + "+"));
CASValue<Object> v2 = client.gets(k);
assertEquals(v + "+", v2.getValue());
assertFalse(v1.getCas() == v2.getCas());
wait(client.delete(k));
}
}
| 1,462
| 30.804348
| 105
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/binary/MemcachedBinaryEncryptionTest.java
|
package org.infinispan.server.memcached.binary;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import java.lang.reflect.Method;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.test.MemcachedSingleNodeTest;
import org.testng.annotations.Test;
import net.spy.memcached.CASValue;
/**
* @since 15.0
**/
@Test(groups = "functional", testName = "server.memcached.binary.MemcachedBinaryEncryptionTest")
public class MemcachedBinaryEncryptionTest extends MemcachedSingleNodeTest {
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.BINARY;
}
@Override
protected boolean withAuthentication() {
return true;
}
@Override
protected boolean withEncryption() {
return true;
}
public void testSetBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
String k = k(m);
String v = v(m);
wait(client.set(k, 0, v));
CASValue<Object> v1 = client.gets(k);
assertEquals(v, v1.getValue());
wait(client.set(k, 0, v + "+"));
CASValue<Object> v2 = client.gets(k);
assertEquals(v + "+", v2.getValue());
assertFalse(v1.getCas() == v2.getCas());
wait(client.delete(k));
}
}
| 1,533
| 28.5
| 105
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/logging/MemcachedAccessLoggingTest.java
|
package org.infinispan.server.memcached.logging;
import static org.testng.AssertJUnit.assertTrue;
import java.util.concurrent.ExecutionException;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.layout.PatternLayout;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.test.skip.StringLogAppender;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.test.MemcachedSingleNodeTest;
import org.testng.annotations.Test;
@Test(groups = "functional", testName = "server.memcached.logging.MemcachedAccessLoggingTest")
public class MemcachedAccessLoggingTest extends MemcachedSingleNodeTest {
public static final String LOG_FORMAT = "%X{address} %X{user} [%d{dd/MMM/yyyy:HH:mm:ss Z}] \"%X{method} %m %X{protocol}\" %X{status} %X{requestSize} %X{responseSize} %X{duration}";
StringLogAppender logAppender;
private String testShortName;
@Override
protected void setup() throws Exception {
testShortName = TestResourceTracker.getCurrentTestShortName();
logAppender = new StringLogAppender(MemcachedAccessLogging.log.getName(),
Level.TRACE,
t -> t.getName().startsWith("non-blocking-thread-" + testShortName),
PatternLayout.newBuilder().withPattern(LOG_FORMAT).build());
logAppender.install();
assertTrue(MemcachedAccessLogging.isEnabled());
super.setup();
}
@Override
protected void teardown() {
logAppender.uninstall();
super.teardown();
}
public void testMemcacheddAccessLog() throws ExecutionException, InterruptedException {
client.set("key", 0, "value").get();
server.getTransport().stop();
String logline = logAppender.getLog(0);
assertTrue(logline, logline.matches(
"^127\\.0\\.0\\.1 - \\[\\d+/\\w+/\\d+:\\d+:\\d+:\\d+ [+-]?\\d*] \"set /key MCTXT\" OK \\d+ \\d+ \\d+$"));
}
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.TEXT;
}
}
| 2,052
| 36.327273
| 183
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/test/MemcachedTestingUtil.java
|
package org.infinispan.server.memcached.test;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Collections;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicInteger;
import javax.net.ssl.SSLContext;
import javax.security.auth.Subject;
import javax.security.sasl.Sasl;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.test.security.TestCertificates;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.server.core.security.simple.SimpleSaslAuthenticator;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.server.memcached.logging.Log;
import net.spy.memcached.ClientMode;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.auth.AuthDescriptor;
/**
* Utils for Memcached tests.
*
* @author Galder Zamarreño
* @since 4.1
*/
public class MemcachedTestingUtil {
private static final Log log = LogFactory.getLog(MemcachedTestingUtil.class, Log.class);
private static final String host = "127.0.0.1";
private static final String USERNAME = "user";
private static final String REALM = "default";
private static final String PASSWORD = "secret";
private static final long TIMEOUT = 10_000;
public static MemcachedClient createMemcachedClient(MemcachedServer server) throws IOException {
MemcachedServerConfiguration configuration = server.getConfiguration();
MemcachedProtocol protocol = configuration.protocol();
ConnectionFactoryBuilder.Protocol p = protocol == MemcachedProtocol.BINARY ? ConnectionFactoryBuilder.Protocol.BINARY : ConnectionFactoryBuilder.Protocol.TEXT;
ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder().setProtocol(p).setOpTimeout(TIMEOUT);
if (configuration.authentication().enabled()) { // && (protocol == MemcachedProtocol.BINARY)) {
builder.setAuthDescriptor(AuthDescriptor.typical(USERNAME, PASSWORD));
}
if (configuration.ssl().enabled()) {
SSLContext sslContext = new SslContextFactory().trustStoreFileName(TestCertificates.certificate("ca")).trustStorePassword(TestCertificates.KEY_PASSWORD).getContext();
builder.setSSLContext(sslContext).setSkipTlsHostnameVerification(true);
}
builder.setClientMode(ClientMode.Static); // Legacy memcached mode
MemcachedClient client = new MemcachedClient(builder.build(), Collections.singletonList(new InetSocketAddress(host, server.getPort())));
return client;
}
public static MemcachedServerConfigurationBuilder serverBuilder() {
String serverName = TestResourceTracker.getCurrentTestShortName();
return new MemcachedServerConfigurationBuilder().name(serverName).host(host).port(UniquePortThreadLocal.INSTANCE.get()).clientEncoding(MediaType.APPLICATION_OCTET_STREAM);
}
public static MemcachedServerConfigurationBuilder enableAuthentication(MemcachedServerConfigurationBuilder builder) {
SimpleSaslAuthenticator ssap = new SimpleSaslAuthenticator();
ssap.addUser(USERNAME, REALM, PASSWORD.toCharArray());
builder.authentication().enable().sasl().addAllowedMech("CRAM-MD5").authenticator(ssap)
.serverName("localhost").addMechProperty(Sasl.POLICY_NOANONYMOUS, "true");
builder.authentication().text().authenticator((username, password) -> {
if (username.equals(USERNAME) && new String(password).equals(PASSWORD)) {
return CompletableFuture.completedFuture(new Subject());
}
return CompletableFuture.failedFuture(new SecurityException());
});
return builder;
}
public static MemcachedServerConfigurationBuilder enableEncryption(MemcachedServerConfigurationBuilder builder) {
builder.ssl().enable()
.keyStoreFileName(TestCertificates.certificate("server"))
.keyStorePassword(TestCertificates.KEY_PASSWORD);
return builder;
}
public static void killMemcachedClient(MemcachedClient client) {
try {
if (client != null) client.shutdown();
} catch (Throwable t) {
log.error("Error stopping client", t);
}
}
public static void killMemcachedServer(MemcachedServer server) {
if (server != null) server.stop();
}
private static final class UniquePortThreadLocal extends ThreadLocal<Integer> {
static UniquePortThreadLocal INSTANCE = new UniquePortThreadLocal();
private static final AtomicInteger UNIQUE_ADDR = new AtomicInteger(16211);
@Override
protected Integer initialValue() {
return UNIQUE_ADDR.getAndAdd(100);
}
}
}
| 5,056
| 43.359649
| 177
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/test/MemcachedFunctionalTest.java
|
package org.infinispan.server.memcached.test;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.serverBuilder;
import static org.infinispan.test.TestingUtil.generateRandomString;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.sleepThread;
import static org.infinispan.test.TestingUtil.v;
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.lang.reflect.Method;
import java.net.SocketAddress;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.infinispan.Cache;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.StorageType;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import net.spy.memcached.CASResponse;
import net.spy.memcached.CASValue;
import net.spy.memcached.internal.OperationFuture;
/**
* Tests Memcached protocol functionality against Infinispan Memcached server.
*/
public abstract class MemcachedFunctionalTest extends MemcachedSingleNodeTest {
public void testSetBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m));
}
public void testSetWithExpirySeconds(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 1, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testSetWithExpiryUnixTime(Method m) throws InterruptedException, ExecutionException, TimeoutException {
int future = (int) TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime() + 1000);
OperationFuture<Boolean> f = client.set(k(m), future, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testSetWithExpiryUnixTimeInPast(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 60 * 60 * 24 * 30 + 1, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testSetWithUTF8Key(Method m) throws InterruptedException, ExecutionException, TimeoutException {
String key = "\u4f60\u597d-";
OperationFuture<Boolean> f = client.set(k(m, key), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(v(m), client.get(k(m, key)));
}
public void testGetMultipleKeys(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f1 = client.set(k(m, "k1-"), 0, v(m, "v1-"));
OperationFuture<Boolean> f2 = client.set(k(m, "k2-"), 0, v(m, "v2-"));
OperationFuture<Boolean> f3 = client.set(k(m, "k3-"), 0, v(m, "v3-"));
assertTrue(f1.get(timeout, TimeUnit.SECONDS));
assertTrue(f2.get(timeout, TimeUnit.SECONDS));
assertTrue(f3.get(timeout, TimeUnit.SECONDS));
List<String> keys = Arrays.asList(k(m, "k1-"), k(m, "k2-"), k(m, "k3-"));
Map<String, Object> ret = client.getBulk(keys);
assertEquals(v(m, "v1-"), ret.get(k(m, "k1-")));
assertEquals(v(m, "v2-"), ret.get(k(m, "k2-")));
assertEquals(v(m, "v3-"), ret.get(k(m, "k3-")));
}
public void testAddBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
}
public void testTouchWithExpiryUnixTime(Method m) throws InterruptedException, ExecutionException, TimeoutException {
int future = (int) TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime() + 1000);
OperationFuture<Boolean> f = client.set(k(m), future, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
f = client.touch(k(m), future + 1);
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertEquals(v(m), client.get(k(m)));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testTouchWithExpirySeconds(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 1, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
f = client.touch(k(m), 2);
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertEquals(v(m), client.get(k(m)));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testTouchMiss(Method m) throws ExecutionException, InterruptedException, TimeoutException {
OperationFuture<Boolean> f = client.touch(k(m), 1);
assertFalse(f.get(timeout, TimeUnit.SECONDS));
}
public void testGetAndTouchWithExpirySeconds(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 1, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(v(m), client.getAndTouch(k(m), 2).getValue());
timeService.advance(1100);
assertEquals(v(m), client.get(k(m)));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testGetAndTouchWithExpiryUnixTime(Method m) throws InterruptedException, ExecutionException, TimeoutException {
int future = (int) TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime() + 1000);
OperationFuture<Boolean> f = client.set(k(m), future, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(v(m), client.getAndTouch(k(m), future + 1).getValue());
timeService.advance(1100);
assertEquals(v(m), client.get(k(m)));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testGetAndTouchMiss(Method m) {
CASValue<Object> v = client.getAndTouch(k(m), 1);
assertNull(v);
}
public void testAddWithExpirySeconds(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.add(k(m), 1, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertNull(client.get(k(m)));
f = client.add(k(m), 0, v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m, "v1-"));
}
public void testAddWithExpiryUnixTime(Method m) throws InterruptedException, ExecutionException, TimeoutException {
int future = (int) TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime() + 1000);
OperationFuture<Boolean> f = client.add(k(m), future, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertNull(client.get(k(m)));
f = client.add(k(m), 0, v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m, "v1-"));
}
public void testNotAddIfPresent(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.add(k(m), 0, v(m, "v1-"));
assertFalse(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m));
}
public void testReplaceBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.replace(k(m), 0, v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m, "v1-"));
}
public void testNotReplaceIfNotPresent(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.replace(k(m), 0, v(m));
assertFalse(f.get(timeout, TimeUnit.SECONDS));
assertNull(client.get(k(m)));
}
public void testReplaceWithExpirySeconds(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.replace(k(m), 1, v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m, "v1-"));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testReplaceWithExpiryUnixTime(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
int future = (int) TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime() + 1000);
OperationFuture<Boolean> f = client.replace(k(m), future, v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m, "v1-"));
timeService.advance(1100);
assertNull(client.get(k(m)));
}
public void testAppendBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.append(0, k(m), v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
String expected = v(m) + v(m, "v1-");
assertEquals(client.get(k(m)), expected);
}
public void testAppendNotFound(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.append(0, k(m, "k2-"), v(m, "v1-"));
assertFalse(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m));
assertNull(client.get(k(m, "k2-")));
}
public void testPrependBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.prepend(0, k(m), v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
String expected = v(m, "v1-") + v(m);
assertEquals(client.get(k(m)), expected);
}
public void testPrependNotFound(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.prepend(0, k(m, "k2-"), v(m, "v1-"));
assertFalse(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m));
assertNull(client.get(k(m, "k2-")));
}
public void testGetsBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
CASValue value = client.gets(k(m));
assertEquals(value.getValue(), v(m));
assertTrue(value.getCas() != 0);
}
public void testCasBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
CASValue value = client.gets(k(m));
assertEquals(value.getValue(), v(m));
assertTrue(value.getCas() != 0);
CASResponse resp = client.cas(k(m), value.getCas(), v(m, "v1-"));
assertEquals(resp, CASResponse.OK);
}
public void testCasNotFound(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
CASValue value = client.gets(k(m));
assertEquals(value.getValue(), v(m));
assertTrue(value.getCas() != 0);
CASResponse resp = client.cas(k(m, "k1-"), value.getCas(), v(m, "v1-"));
assertEquals(resp, CASResponse.NOT_FOUND);
}
public void testCasExists(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
CASValue value = client.gets(k(m));
assertEquals(value.getValue(), v(m));
long old = value.getCas();
assertTrue(old != 0);
client.cas(k(m), old, v(m, "v1-"));
value = client.gets(k(m));
assertEquals(v(m, "v1-"), value.getValue());
assertTrue(value.getCas() != 0);
assertTrue(value.getCas() != old);
CASResponse resp = client.cas(k(m), old, v(m, "v2-"));
assertEquals(CASResponse.EXISTS, resp);
resp = client.cas(k(m), value.getCas(), v(m, "v2-"));
assertEquals(CASResponse.OK, resp);
}
public void testDeleteBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
addAndGet(m);
OperationFuture<Boolean> f = client.delete(k(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertNull(client.get(k(m)));
}
public void testDeleteDoesNotExist(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.delete(k(m));
assertFalse(f.get(timeout, TimeUnit.SECONDS));
}
public void testIncrementBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
long result = client.incr(k(m), 1);
assertEquals(result, 2);
}
public void testIncrementTriple(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.incr(k(m), 1), 2);
assertEquals(client.incr(k(m), 2), 4);
assertEquals(client.incr(k(m), 4), 8);
}
public void testIncrementNotExist(Method m) {
assertEquals(-1, client.incr(k(m), 1));
}
public void testIncrementIntegerMax(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, "0");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.incr(k(m), Integer.MAX_VALUE), Integer.MAX_VALUE);
}
public void testIncrementBeyondIntegerMax(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
long newValue = client.incr(k(m), Integer.MAX_VALUE);
assertEquals(newValue, (long) Integer.MAX_VALUE + 1);
}
public void testDecrementBasic(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.decr(k(m), 1), 0);
}
public void testDecrementTriple(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, "8");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.decr(k(m), 1), 7);
assertEquals(client.decr(k(m), 2), 5);
assertEquals(client.decr(k(m), 4), 1);
}
public void testDecrementNotExist(Method m) {
assertEquals(client.decr(k(m), 1), -1);
}
public void testDecrementBelowZero(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
long newValue = client.decr(k(m), 2);
assertEquals(newValue, 0);
}
public void testFlushAll(Method m) throws InterruptedException, ExecutionException, TimeoutException {
for (int i = 1; i < 5; ++i) {
String key = k(m, "k" + i + "-");
String value = v(m, "v" + i + "-");
OperationFuture<Boolean> f = client.set(key, 0, value);
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(key), value);
}
OperationFuture<Boolean> f = client.flush();
assertTrue(f.get(timeout, TimeUnit.SECONDS));
for (int i = 1; i < 5; ++i) {
String key = k(m, "k" + i + "-");
assertNull(client.get(key));
}
}
public void testFlushAllDelayed(Method m) throws InterruptedException, ExecutionException, TimeoutException {
flushAllDelayed(m, 2, 2200);
}
public void testFlushAllDelayedUnixTime(Method m) throws InterruptedException, ExecutionException, TimeoutException {
int delay = (int) TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime() + 2000);
flushAllDelayed(m, delay, 2200);
}
private void flushAllDelayed(Method m, int delay, long sleep) throws InterruptedException, ExecutionException, TimeoutException {
for (int i = 1; i < 5; ++i) {
String key = k(m, "k" + i + "-");
String value = v(m, "v" + i + "-");
OperationFuture<Boolean> f = client.set(key, 0, value);
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(key), value);
}
OperationFuture<Boolean> f = client.flush(delay);
assertTrue(f.get(timeout, TimeUnit.SECONDS));
// The underlying ScheduledExecutorService does not use the ControlledTimeService unfortunately, so we need to sleep
sleepThread(sleep);
timeService.advance(sleep);
for (int i = 1; i < 5; ++i) {
String key = k(m, "k" + i + "-");
assertNull(client.get(key));
}
}
private void testVersion() {
Map<SocketAddress, String> versions = client.getVersions();
assertEquals(versions.size(), 1);
String version = versions.values().iterator().next();
assertEquals(Version.getVersion(), version);
}
public void testSetBigSizeValue(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, generateRandomString(1024 * 1024).getBytes());
assertTrue(f.get(timeout, TimeUnit.SECONDS));
}
public void testStoreAsBinaryOverride() {
ConfigurationBuilder builder = TestCacheManagerFactory.getDefaultCacheConfiguration(false);
builder.memory().storageType(StorageType.BINARY);
EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(builder);
Configuration cfg = builder.build();
cm.defineConfiguration(new MemcachedServerConfigurationBuilder().build().defaultCacheName(), cfg);
assertEquals(StorageType.BINARY, cfg.memory().storageType());
MemcachedServerConfigurationBuilder serverBuilder = serverBuilder().protocol(MemcachedProtocol.TEXT).port(server.getPort() + 33);
MemcachedServer testServer = new MemcachedServer();
testServer.start(serverBuilder.build(), cm);
try {
Cache memcachedCache = cm.getCache(testServer.getConfiguration().defaultCacheName());
assertEquals(StorageType.BINARY, memcachedCache.getCacheConfiguration().memory().storageType());
} finally {
cm.stop();
testServer.stop();
}
}
private void addAndGet(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.add(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m));
}
}
| 19,388
| 43.267123
| 135
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/test/MemcachedMultiNodeTest.java
|
package org.infinispan.server.memcached.test;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.createMemcachedClient;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.serverBuilder;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.infinispan.Cache;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.test.ServerTestingUtil;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.test.MultipleCacheManagersTest;
import org.testng.annotations.AfterClass;
import net.spy.memcached.MemcachedClient;
/**
* @author Galder Zamarreño
*/
public abstract class MemcachedMultiNodeTest extends MultipleCacheManagersTest {
protected static String cacheName = "MemcachedReplSync";
protected int nodeCount = 2;
protected List<MemcachedServer> servers = new ArrayList<>(nodeCount);
protected List<MemcachedClient> clients = new ArrayList<>(nodeCount);
protected Map<Cache<String, byte[]>, MemcachedClient> cacheClient = new HashMap<>();
protected int timeout = 60;
@Override
protected void createCacheManagers() {
for (int i = 0; i < nodeCount; ++i) {
cacheManagers.add(createCacheManager(i));
}
waitForClusterToForm();
MemcachedServerConfigurationBuilder builder = serverBuilder().defaultCacheName(cacheName).protocol(getProtocol());
MemcachedServer server1 = new MemcachedServer();
server1.start(builder.build(), cacheManagers.get(0));
servers.add(server1);
MemcachedServer server2 = new MemcachedServer();
server2.start(builder.port(server1.getPort() + 50).build(), cacheManagers.get(1));
servers.add(server2);
servers.forEach(s -> {
MemcachedClient client;
try {
client = createMemcachedClient(s);
} catch (IOException e) {
throw new AssertionError(e);
}
clients.add(client);
Cache<String, byte[]> cache = s.getCacheManager().getCache(cacheName);
cacheClient.put(cache, client);
});
}
protected abstract EmbeddedCacheManager createCacheManager(int index);
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.TEXT;
}
@AfterClass(alwaysRun = true)
@Override
public void destroy() {
super.destroy();
log.debug("Test finished, close Hot Rod server");
clients.forEach(MemcachedTestingUtil::killMemcachedClient);
servers.forEach(ServerTestingUtil::killServer);
}
}
| 2,780
| 34.202532
| 120
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/test/MemcachedBlockHoundIntegration.java
|
package org.infinispan.server.memcached.test;
import org.kohsuke.MetaInfServices;
import reactor.blockhound.BlockHound;
import reactor.blockhound.integration.BlockHoundIntegration;
/**
* @since 14.0
*/
@MetaInfServices
public class MemcachedBlockHoundIntegration implements BlockHoundIntegration {
@Override
public void applyTo(BlockHound.Builder builder) {
}
}
| 377
| 20
| 78
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/test/DefaultLogger.java
|
/**
* Copyright (C) 2006-2009 Dustin Sallings Copyright (C) 2009-2013 Couchbase, Inc.
* <p>
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
* documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to the following conditions:
* <p>
* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
* Software.
* <p>
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALING IN THE SOFTWARE.
*/
package org.infinispan.server.memcached.test;
import java.text.SimpleDateFormat;
import java.util.Date;
import net.spy.memcached.compat.log.AbstractLogger;
import net.spy.memcached.compat.log.Level;
/**
* Default logger implementation.
*
* This logger is really primitive. It just logs everything to stderr if it's
* higher than INFO.
*/
public class DefaultLogger extends AbstractLogger {
private final SimpleDateFormat df;
/**
* Get an instance of DefaultLogger.
*/
public DefaultLogger(String name) {
super(name);
df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
}
/**
* Always returns false, trace is not enabled on the DefaultLogger.
*/
@Override
public boolean isTraceEnabled() {
return true;
}
/**
* Always returns false, debug is not enabled on the DefaultLogger.
*/
@Override
public boolean isDebugEnabled() {
return true;
}
/**
* Always returns true, info is always enabled on the DefaultLogger.
*/
@Override
public boolean isInfoEnabled() {
return true;
}
/**
* @see AbstractLogger
*/
@Override
public synchronized void log(Level level, Object message, Throwable e) {
System.err.printf("%s %s %s: %s\n", df.format(new Date()), level.name(),
getName(), message);
if (e != null) {
e.printStackTrace();
}
}
}
| 2,570
| 30.740741
| 120
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/test/MemcachedSingleNodeTest.java
|
package org.infinispan.server.memcached.test;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.createMemcachedClient;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.enableAuthentication;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.enableEncryption;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.killMemcachedServer;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.serverBuilder;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.infinispan.commons.time.ControlledTimeService;
import org.infinispan.commons.time.TimeService;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.DummyServerStateManager;
import org.infinispan.server.core.ServerStateManager;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.server.memcached.text.TextConstants;
import org.infinispan.test.SingleCacheManagerTest;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.AssertJUnit;
import org.testng.annotations.AfterClass;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.internal.OperationFuture;
/**
* Base class for single node tests.
*
* @author Galder Zamarreño
* @since 4.1
*/
public abstract class MemcachedSingleNodeTest extends SingleCacheManagerTest {
protected MemcachedClient client;
protected MemcachedServer server;
protected static final int timeout = 60;
final protected ControlledTimeService timeService = new ControlledTimeService("memcached", 1000L * TextConstants.MAX_EXPIRATION);
@Override
protected EmbeddedCacheManager createCacheManager() throws Exception {
cacheManager = createTestCacheManager();
cacheManager.getGlobalComponentRegistry().registerComponent(new DummyServerStateManager(), ServerStateManager.class);
TestingUtil.replaceComponent(cacheManager, TimeService.class, timeService, true);
MemcachedServerConfigurationBuilder builder = serverBuilder().protocol(getProtocol());
if (withAuthentication()) {
enableAuthentication(builder);
}
if (withEncryption()) {
enableEncryption(builder);
}
server = new MemcachedServer();
server.start(builder.build(), cacheManager);
client = createMemcachedClient(server);
cache = cacheManager.getCache(server.getConfiguration().defaultCacheName());
return cacheManager;
}
protected EmbeddedCacheManager createTestCacheManager() {
return TestCacheManagerFactory.createCacheManager(true);
}
protected abstract MemcachedProtocol getProtocol();
protected boolean withAuthentication() {
return false;
}
protected boolean withEncryption() {
return false;
}
@AfterClass(alwaysRun = true)
@Override
protected void destroyAfterClass() {
super.destroyAfterClass();
log.debug("Test finished, close memcached server");
shutdownClient();
killMemcachedServer(server);
}
protected void shutdownClient() {
client.shutdown();
}
public static void wait(OperationFuture<Boolean> f) throws ExecutionException, InterruptedException, TimeoutException {
AssertJUnit.assertTrue(f.get(timeout, TimeUnit.SECONDS));
}
protected String send(String req) throws IOException {
return sendMulti(req, 1, true).get(0);
}
protected List<String> sendNoWait(String req) throws IOException {
return sendMulti(req, 1, false);
}
protected List<String> sendMulti(String req, int expectedResponses, boolean wait) throws IOException {
try (Socket socket = new Socket(server.getHost(), server.getPort())) {
OutputStream outputStream = socket.getOutputStream();
outputStream.write(req.getBytes());
outputStream.flush();
if (wait) {
Stream.Builder<String> builder = Stream.builder();
for (int i = 0; i < expectedResponses; ++i) {
builder.accept(readLine(socket.getInputStream(), new StringBuilder()));
}
return builder.build().collect(Collectors.toList());
} else {
return Collections.emptyList();
}
}
}
protected String readLine(InputStream is, StringBuilder sb) throws IOException {
int next = is.read();
if (next == 13) { // CR
next = is.read();
if (next == 10) { // LF
return sb.toString().trim();
} else {
sb.append((char) next);
return readLine(is, sb);
}
} else if (next == 10) { //LF
return sb.toString().trim();
} else {
sb.append((char) next);
return readLine(is, sb);
}
}
protected void assertClientError(String resp) {
assertExpectedResponse(resp, "CLIENT_ERROR", false);
}
protected void assertError(String resp) {
assertExpectedResponse(resp, "ERROR", true);
}
protected void assertStored(String resp) {
assertExpectedResponse(resp, "STORED", true);
}
protected void assertExpectedResponse(String resp, String expectedResp, boolean strictComparison) {
if (strictComparison)
assertEquals(expectedResp, resp);
else
assertTrue(resp.contains(expectedResp), "Expecting '" + expectedResp + ", got '" + resp + "' instead");
}
}
| 5,999
| 35.144578
| 132
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedDistributionTest.java
|
package org.infinispan.server.memcached.text;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
import org.infinispan.Cache;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.distribution.DistributionTestHelper;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.memcached.test.MemcachedMultiNodeTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.internal.OperationFuture;
/**
* Tests distributed mode with Memcached servers.
*
* @author Galder Zamarreño
* @since 6.0
*/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedDistributionTest")
public class MemcachedDistributionTest extends MemcachedMultiNodeTest {
public EmbeddedCacheManager createCacheManager(int index) {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.clustering().cacheMode(CacheMode.DIST_SYNC).hash().numOwners(1);
return TestCacheManagerFactory.createClusteredCacheManager(
GlobalConfigurationBuilder.defaultClusteredBuilder().defaultCacheName(cacheName),
builder);
}
public void testGetFromNonOwner() throws InterruptedException, ExecutionException, TimeoutException {
MemcachedClient owner = getFirstOwner("1");
OperationFuture<Boolean> f = owner.set("1", 0, "v1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
MemcachedClient nonOwner = getFirstNonOwner("1");
assertEquals(nonOwner.get("1"), "v1");
}
private MemcachedClient getFirstNonOwner(String k) {
return getCacheThat(k, false);
}
private MemcachedClient getFirstOwner(String k) {
return getCacheThat(k, true);
}
private MemcachedClient getCacheThat(String k, Boolean owner) {
List<Cache<String, byte[]>> caches = servers.stream().map(s -> {
Cache<String, byte[]> cache = s.getCacheManager().getCache(cacheName);
return cache;
}).collect(Collectors.toList());
Cache<String, byte[]> cache;
if (owner) {
cache = DistributionTestHelper.getFirstOwner(k, caches);
} else {
cache = DistributionTestHelper.getFirstNonOwner(k, caches);
}
return cacheClient.get(cache);
}
}
| 2,680
| 35.726027
| 104
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedServerTest.java
|
package org.infinispan.server.memcached.text;
import static org.testng.AssertJUnit.assertEquals;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.Collections;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.server.core.test.Stoppable;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
import net.spy.memcached.ClientMode;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
/**
* Memcached server unit test.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedServerTest")
public class MemcachedServerTest extends AbstractInfinispanTest {
public void testValidateDefaultConfiguration() {
Stoppable.useCacheManager(TestCacheManagerFactory.createCacheManager(), cm ->
Stoppable.useServer(new MemcachedServer(), ms -> {
ms.start(new MemcachedServerConfigurationBuilder().build(), cm);
assertEquals(ms.getHost(), "127.0.0.1");
assertEquals((int) ms.getPort(), 11211);
}));
}
public void testNoDefaultConfigurationLocal() {
GlobalConfigurationBuilder global = new GlobalConfigurationBuilder();
Stoppable.useCacheManager(new DefaultCacheManager(global.build()), cm ->
Stoppable.useServer(new MemcachedServer(), ms -> {
ms.start(new MemcachedServerConfigurationBuilder().build(), cm);
assertEquals(CacheMode.LOCAL, ms.getCache().getCacheConfiguration().clustering().cacheMode());
}));
}
public void testNoDefaultConfigurationClustered() {
GlobalConfigurationBuilder global = GlobalConfigurationBuilder.defaultClusteredBuilder();
Stoppable.useCacheManager(new DefaultCacheManager(global.build()), cm ->
Stoppable.useServer(new MemcachedServer(), ms -> {
ms.start(new MemcachedServerConfigurationBuilder().build(), cm);
assertEquals(CacheMode.REPL_SYNC, ms.getCache().getCacheConfiguration().clustering().cacheMode());
}));
}
public void testProtocolDetectionBinary() {
testProtocolDetection(ConnectionFactoryBuilder.Protocol.BINARY);
}
public void testProtocolDetectionText() {
testProtocolDetection(ConnectionFactoryBuilder.Protocol.TEXT);
}
private void testProtocolDetection(ConnectionFactoryBuilder.Protocol protocol) {
GlobalConfigurationBuilder global = new GlobalConfigurationBuilder();
Stoppable.useCacheManager(new DefaultCacheManager(global.build()), cm ->
Stoppable.useServer(new MemcachedServer(), ms -> {
ms.start(new MemcachedServerConfigurationBuilder().build(), cm);
ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder().setProtocol(protocol).setOpTimeout(5).setClientMode(ClientMode.Static);
MemcachedClient client = null;
try {
client = new MemcachedClient(builder.build(), Collections.singletonList(new InetSocketAddress(ms.getHost(), ms.getPort())));
client.getVersions();
} catch (IOException e) {
throw new RuntimeException(e);
} finally {
if (client != null) {
client.shutdown();
}
}
}));
}
}
| 3,768
| 42.321839
| 152
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedTextAuthenticationTest.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertFalse;
import java.lang.reflect.Method;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.test.MemcachedSingleNodeTest;
import org.testng.annotations.Test;
import net.spy.memcached.CASValue;
/**
* @since 15.0
**/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedTextAuthenticationTest")
public class MemcachedTextAuthenticationTest extends MemcachedSingleNodeTest {
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.TEXT;
}
@Override
protected boolean withAuthentication() {
return true;
}
public void testAuthentication(Method m) throws ExecutionException, InterruptedException, TimeoutException {
String k = k(m);
String v = v(m);
wait(client.set(k, 0, v));
CASValue<Object> v1 = client.gets(k);
assertEquals(v, v1.getValue());
wait(client.set(k, 0, v + "+"));
CASValue<Object> v2 = client.gets(k);
assertEquals(v + "+", v2.getValue());
assertFalse(v1.getCas() == v2.getCas());
wait(client.delete(k));
}
}
| 1,459
| 30.06383
| 111
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedShutdownTest.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.killMemcachedServer;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertTrue;
import java.lang.reflect.Method;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.test.MemcachedSingleNodeTest;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
import net.spy.memcached.internal.OperationFuture;
/**
* Tests that Infinispan Memcached server can shutdown even if client does not close connection.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedShutdownTest")
public class MemcachedShutdownTest extends MemcachedSingleNodeTest {
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.TEXT;
}
@Override
protected boolean withAuthentication() {
return false;
}
@AfterClass(alwaysRun = true)
@Override
protected void destroyAfterClass() {
// Stop the server before the client
killMemcachedServer(server);
super.destroyAfterClass();
}
public void testAny(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = client.set(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m));
}
}
| 1,731
| 29.928571
| 100
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedStatsTest.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.server.memcached.test.MemcachedTestingUtil.createMemcachedClient;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.sleepThread;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertNotSame;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import java.io.IOException;
import java.lang.reflect.Method;
import java.net.SocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import org.infinispan.commons.jmx.MBeanServerLookup;
import org.infinispan.commons.jmx.TestMBeanServerLookup;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.test.MemcachedSingleNodeTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.jgroups.util.Triple;
import org.testng.annotations.Test;
import net.spy.memcached.CASValue;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.internal.OperationFuture;
/**
* Tests stats command for Infinispan Memcached server.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedStatsTest")
public class MemcachedStatsTest extends MemcachedSingleNodeTest {
private static final String jmxDomain = MemcachedStatsTest.class.getSimpleName();
private final MBeanServerLookup mBeanServerLookup = TestMBeanServerLookup.create();
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.TEXT;
}
@Override
protected boolean withAuthentication() {
return false;
}
@Override
public EmbeddedCacheManager createTestCacheManager() {
GlobalConfigurationBuilder globalConfiguration = new GlobalConfigurationBuilder().nonClusteredDefault();
globalConfiguration.cacheContainer().statistics(true).jmx().enabled(true).domain(jmxDomain).mBeanServerLookup(mBeanServerLookup).metrics().accurateSize(true);
ConfigurationBuilder configuration = new ConfigurationBuilder();
configuration.statistics().enabled(true);
return TestCacheManagerFactory.createCacheManager(globalConfiguration, configuration);
}
public void testUnsupportedStats() {
Triple<Map<String, String>, Integer, Integer> stats = getStats(-1, -1);
assertEquals(stats.getVal1().get("pointer_size"), "0");
assertEquals(stats.getVal1().get("rusage_user"), "0");
assertEquals(stats.getVal1().get("rusage_system"), "0");
assertEquals(stats.getVal1().get("bytes"), "0");
assertEquals(stats.getVal1().get("connection_structures"), "0");
assertEquals(stats.getVal1().get("auth_cmds"), "0");
assertEquals(stats.getVal1().get("auth_errors"), "0");
assertEquals(stats.getVal1().get("limit_maxbytes"), "0");
assertEquals(stats.getVal1().get("conn_yields"), "0");
assertEquals(stats.getVal1().get("reclaimed"), "0");
}
public void testUncomparableStats() {
sleepThread(TimeUnit.SECONDS.toMillis(1));
Triple<Map<String, String>, Integer, Integer> stats = getStats(-1, -1);
assertNotSame(stats.getVal1().get("uptime"), "0");
assertNotSame(stats.getVal1().get("time"), "0");
assertNotSame(stats.getVal1().get("uptime"), stats.getVal1().get("time"));
}
public void testStaticStats() {
Triple<Map<String, String>, Integer, Integer> stats = getStats(-1, -1);
assertEquals(stats.getVal1().get("version"), Version.getVersion());
}
public void testTodoStats() {
Triple<Map<String, String>, Integer, Integer> stats = getStats(-1, -1);
assertEquals(stats.getVal1().get("curr_connections"), "1");
assertEquals(stats.getVal1().get("total_connections"), "1");
assertEquals(stats.getVal1().get("threads"), "0");
}
public void testStats(Method m) throws InterruptedException, ExecutionException, TimeoutException {
Triple<Map<String, String>, Integer, Integer> stats = getStats(-1, -1);
assertEquals(stats.getVal1().get("cmd_set"), "0");
assertEquals(stats.getVal1().get("cmd_get"), "0");
assertEquals(stats.getVal1().get("get_hits"), "0");
assertEquals(stats.getVal1().get("get_misses"), "0");
assertEquals(stats.getVal1().get("delete_hits"), "0");
assertEquals(stats.getVal1().get("delete_misses"), "0");
assertEquals(stats.getVal1().get("curr_items"), "0");
assertEquals(stats.getVal1().get("total_items"), "0");
assertEquals(stats.getVal1().get("incr_misses"), "0");
assertEquals(stats.getVal1().get("incr_hits"), "0");
assertEquals(stats.getVal1().get("decr_misses"), "0");
assertEquals(stats.getVal1().get("decr_hits"), "0");
assertEquals(stats.getVal1().get("cas_misses"), "0");
assertEquals(stats.getVal1().get("cas_hits"), "0");
assertEquals(stats.getVal1().get("cas_badval"), "0");
OperationFuture<Boolean> f = client.set(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m)), v(m));
f = client.set(k(m, "k1-"), 0, v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(k(m, "k1-")), v(m, "v1-"));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("cmd_set"), "2");
assertEquals(stats.getVal1().get("cmd_get"), "2");
assertEquals(stats.getVal1().get("get_hits"), "2");
assertEquals(stats.getVal1().get("get_misses"), "0");
assertEquals(stats.getVal1().get("delete_hits"), "0");
assertEquals(stats.getVal1().get("delete_misses"), "0");
assertEquals(stats.getVal1().get("curr_items"), "2");
assertEquals(stats.getVal1().get("total_items"), "2");
f = client.delete(k(m, "k1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("curr_items"), "1");
assertEquals(stats.getVal1().get("total_items"), "2");
assertEquals(stats.getVal1().get("delete_hits"), "1");
assertEquals(stats.getVal1().get("delete_misses"), "0");
assertNull(client.get(k(m, "k99-")));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("get_hits"), "2");
assertEquals(stats.getVal1().get("get_misses"), "1");
f = client.delete(k(m, "k99-"));
assertFalse(f.get(timeout, TimeUnit.SECONDS));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("delete_hits"), "1");
assertEquals(stats.getVal1().get("delete_misses"), "1");
int future = (int) TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime() + 1000);
f = client.set(k(m, "k3-"), future, v(m, "v3-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
timeService.advance(1100);
assertNull(client.get(k(m, "k3-")));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("curr_items"), "1");
assertEquals(stats.getVal1().get("total_items"), "3");
client.incr(k(m, "k4-"), 1);
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("incr_misses"), "1");
assertEquals(stats.getVal1().get("incr_hits"), "0");
f = client.set(k(m, "k4-"), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
client.incr(k(m, "k4-"), 1);
client.incr(k(m, "k4-"), 2);
client.incr(k(m, "k4-"), 4);
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("incr_misses"), "1");
assertEquals(stats.getVal1().get("incr_hits"), "3");
client.decr(k(m, "k5-"), 1);
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("decr_misses"), "1");
assertEquals(stats.getVal1().get("decr_hits"), "0");
f = client.set(k(m, "k5-"), 0, "8");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
client.decr(k(m, "k5-"), 1);
client.decr(k(m, "k5-"), 2);
client.decr(k(m, "k5-"), 4);
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("decr_misses"), "1");
assertEquals(stats.getVal1().get("decr_hits"), "3");
client.cas(k(m, "k6-"), 1234, v(m, "v6-"));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("cas_misses"), "1");
assertEquals(stats.getVal1().get("cas_hits"), "0");
assertEquals(stats.getVal1().get("cas_badval"), "0");
f = client.set(k(m, "k6-"), 0, v(m, "v6-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
CASValue value = client.gets(k(m, "k6-"));
long old = value.getCas();
client.cas(k(m, "k6-"), value.getCas(), v(m, "v66-"));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("cas_misses"), "1");
assertEquals(stats.getVal1().get("cas_hits"), "1");
assertEquals(stats.getVal1().get("cas_badval"), "0");
client.cas(k(m, "k6-"), old, v(m, "v66-"));
stats = getStats(stats.getVal2(), stats.getVal3());
assertEquals(stats.getVal1().get("cas_misses"), "1");
assertEquals(stats.getVal1().get("cas_hits"), "1");
assertEquals(stats.getVal1().get("cas_badval"), "1");
}
private List<MemcachedClient> createMultipleClients(List<MemcachedClient> clients, int number, int from)
throws IOException {
if (from >= number) return clients;
else {
MemcachedClient newClient = createMemcachedClient(server);
Object value = newClient.get("a");
// 'Use' the value
if (value != null && value.hashCode() % 1000 == 0) {
System.out.print(value.hashCode());
}
clients.add(newClient);
return createMultipleClients(clients, number, from + 1);
}
}
public void testStatsSpecificToMemcachedViaJmx() throws Exception {
// Send any command
getStats(-1, -1);
MBeanServer mbeanServer = mBeanServerLookup.getMBeanServer();
String serverName = "Memcached-" + TestResourceTracker.getCurrentTestShortName() + "-" + server.getPort();
ObjectName on = new ObjectName(String.format("%s:type=Server,name=%s,component=Transport", jmxDomain, serverName));
assertTrue(Integer.parseInt(mbeanServer.getAttribute(on, "TotalBytesRead").toString()) > 0);
assertTrue(Integer.parseInt(mbeanServer.getAttribute(on, "TotalBytesWritten").toString()) > 0);
assertEquals(mbeanServer.getAttribute(on, "NumberOfLocalConnections"), 1);
List<MemcachedClient> clients = new ArrayList<>();
try {
clients = createMultipleClients(clients, 10, 0);
assertEquals(mbeanServer.getAttribute(on, "NumberOfLocalConnections"), clients.size() + 1);
} finally {
clients.forEach(client -> {
try {
client.shutdown(20, TimeUnit.SECONDS);
} catch (Throwable t) {
} // Ignore it...
});
}
}
public void testStatsWithArgs() throws IOException {
String resp = send("stats\r\n");
assertExpectedResponse(resp, "STAT", false);
resp = send("stats \r\n");
assertExpectedResponse(resp, "STAT", false);
resp = send("stats boo\r\n");
assertClientError(resp);
resp = send("stats boo boo2 boo3\r\n");
assertClientError(resp);
}
private Triple<Map<String, String>, Integer, Integer> getStats(int currentBytesRead, int currentBytesWritten) {
Map<SocketAddress, Map<String, String>> globalStats = client.getStats();
assertEquals(globalStats.size(), 1);
Map<String, String> stats = globalStats.values().iterator().next();
int bytesRead = assertHigherBytes(currentBytesRead, stats.get("bytes_read"));
int bytesWritten = assertHigherBytes(currentBytesWritten, stats.get("bytes_written"));
return new Triple<>(stats, bytesRead, bytesWritten);
}
private int assertHigherBytes(int currentBytesRead, String bytesStr) {
int bytesRead = Integer.parseInt(bytesStr);
assertTrue(bytesRead > currentBytesRead);
return bytesRead;
}
}
| 12,872
| 43.237113
| 164
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedReplicationTest.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.test.TestingUtil.k;
import static org.infinispan.test.TestingUtil.v;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.memcached.test.MemcachedMultiNodeTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
import net.spy.memcached.CASResponse;
import net.spy.memcached.CASValue;
import net.spy.memcached.internal.OperationFuture;
/**
* Tests replicated Infinispan Memcached servers.
*
* @author Galder Zamarreño
* @since 4.1
*/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedReplicationTest")
public class MemcachedReplicationTest extends MemcachedMultiNodeTest {
@Override
protected EmbeddedCacheManager createCacheManager(int index) {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.clustering().cacheMode(CacheMode.REPL_SYNC);
return TestCacheManagerFactory.createClusteredCacheManager(
GlobalConfigurationBuilder.defaultClusteredBuilder().defaultCacheName(cacheName),
builder);
}
public void testReplicatedSet(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).set(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(0).get(k(m)), v(m));
}
public void testReplicatedGetMultipleKeys(Method m) throws InterruptedException, ExecutionException,
TimeoutException {
OperationFuture<Boolean> f1 = clients.get(0).set(k(m, "k1-"), 0, v(m, "v1-"));
OperationFuture<Boolean> f2 = clients.get(0).set(k(m, "k2-"), 0, v(m, "v2-"));
OperationFuture<Boolean> f3 = clients.get(0).set(k(m, "k3-"), 0, v(m, "v3-"));
assertTrue(f1.get(timeout, TimeUnit.SECONDS));
assertTrue(f2.get(timeout, TimeUnit.SECONDS));
assertTrue(f3.get(timeout, TimeUnit.SECONDS));
List<String> keys = Arrays.asList(k(m, "k1-"), k(m, "k2-"), k(m, "k3-"));
Map<String, Object> ret = clients.get(1).getBulk(keys);
assertEquals(ret.get(k(m, "k1-")), v(m, "v1-"));
assertEquals(ret.get(k(m, "k2-")), v(m, "v2-"));
assertEquals(ret.get(k(m, "k3-")), v(m, "v3-"));
}
public void testReplicatedAdd(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).add(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(1).get(k(m)), v(m));
}
public void testReplicatedReplace(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).add(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(1).get(k(m)), v(m));
f = clients.get(1).replace(k(m), 0, v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(0).get(k(m)), v(m, "v1-"));
}
public void testReplicatedAppend(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).add(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(1).get(k(m)), v(m));
f = clients.get(1).append(0, k(m), v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
String expected = v(m) + v(m, "v1-");
assertEquals(clients.get(0).get(k(m)), expected);
}
public void testReplicatedPrepend(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).add(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(1).get(k(m)), v(m));
f = clients.get(1).prepend(0, k(m), v(m, "v1-"));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
String expected = v(m, "v1-") + v(m);
assertEquals(clients.get(0).get(k(m)), expected);
}
public void testReplicatedGets(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).set(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
CASValue<Object> value = clients.get(1).gets(k(m));
assertEquals(value.getValue(), v(m));
assertTrue(value.getCas() != 0);
}
public void testReplicatedCasExists(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).set(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
CASValue<Object> value = clients.get(1).gets(k(m));
assertEquals(value.getValue(), v(m));
assertTrue(value.getCas() != 0);
long old = value.getCas();
CASResponse resp = clients.get(1).cas(k(m), value.getCas(), v(m, "v1-"));
value = clients.get(0).gets(k(m));
assertEquals(value.getValue(), v(m, "v1-"));
assertTrue(value.getCas() != 0);
assertTrue(value.getCas() != old);
resp = clients.get(0).cas(k(m), old, v(m, "v2-"));
assertEquals(resp, CASResponse.EXISTS);
resp = clients.get(1).cas(k(m), value.getCas(), v(m, "v2-"));
assertEquals(resp, CASResponse.OK);
}
public void testReplicatedDelete(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).set(k(m), 0, v(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
f = clients.get(1).delete(k(m));
assertTrue(f.get(timeout, TimeUnit.SECONDS));
}
public void testReplicatedIncrement(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).set(k(m), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(1).incr(k(m), 1), 2);
}
public void testReplicatedDecrement(Method m) throws InterruptedException, ExecutionException, TimeoutException {
OperationFuture<Boolean> f = clients.get(0).set(k(m), 0, "1");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(clients.get(1).decr(k(m), 1), 0);
}
}
| 6,766
| 44.722973
| 116
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedTextFunctionalTest.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.test.TestingUtil.generateRandomString;
import static org.infinispan.test.TestingUtil.k;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertTrue;
import java.io.IOException;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved;
import org.infinispan.notifications.cachelistener.event.CacheEntryRemovedEvent;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.logging.Log;
import org.infinispan.server.memcached.test.MemcachedFunctionalTest;
import org.testng.annotations.Test;
import net.spy.memcached.internal.OperationFuture;
/**
* @since 15.0
**/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedTextFunctionalTest")
public class MemcachedTextFunctionalTest extends MemcachedFunctionalTest {
@Override
protected MemcachedProtocol getProtocol() {
return MemcachedProtocol.TEXT;
}
@Override
protected boolean withAuthentication() {
return false;
}
public void testInvalidCas() throws IOException {
String resp = send("cas bad blah 0 0 0\r\n\r\n");
assertClientError(resp);
resp = send("cas bad 0 blah 0 0\r\n\r\n");
assertClientError(resp);
resp = send("cas bad 0 0 blah 0\r\n\r\n");
assertClientError(resp);
resp = send("cas bad 0 0 0 blah\r\n\r\n");
assertClientError(resp);
}
public void testInvalidCasValue() throws IOException {
String resp = send("cas foo 0 0 6\r\nbarva2\r\n");
assertClientError(resp);
}
public void testSetAndMultiDelete(Method m) throws IOException {
String key = k(m);
List<String> responses = sendMulti(String.format(
"set %s 0 0 1\r\na\r\ndelete %s\r\ndelete %s\r\ndelete %s\r\ndelete %s\r\n", key, key, key, key, key), 5, true);
assertEquals(responses.size(), 5);
assertEquals(responses.get(0), "STORED");
assertEquals(responses.get(1), "DELETED");
assertEquals(responses.get(2), "NOT_FOUND");
assertEquals(responses.get(3), "NOT_FOUND");
assertEquals(responses.get(4), "NOT_FOUND");
}
public void testSetNoReplyMultiDelete(Method m) throws IOException {
String key = k(m);
List<String> responses = sendMulti(String.format(
"set %s 0 0 1 noreply\r\na\r\ndelete %s\r\ndelete %s\r\ndelete %s\r\ndelete %s\r\n", key, key, key, key, key), 4, true);
assertEquals(responses.size(), 4);
assertEquals(responses.get(0), "DELETED");
assertEquals(responses.get(1), "NOT_FOUND");
assertEquals(responses.get(2), "NOT_FOUND");
assertEquals(responses.get(3), "NOT_FOUND");
}
public void testPipelinedDelete() throws IOException {
List<String> responses = sendMulti("delete a\r\ndelete a\r\n", 2, true);
assertEquals(responses.size(), 2);
responses.forEach(r -> assertTrue(r.equals("NOT_FOUND")));
}
public void testPipelinedGetAfterInvalidCas() throws IOException {
List<String> responses = sendMulti("cas bad 0 0 1 0 0\r\nget a\r\n", 2, true);
assertEquals(responses.size(), 2);
assertTrue(responses.get(0), responses.get(0).contains("CLIENT_ERROR"));
assertEquals("END", responses.get(1));
}
public void testFlushAllPipeline() throws IOException {
List<String> responses = sendMulti("flush_all\r\nget a\r\n", 2, true);
assertEquals(responses.size(), 2);
assertEquals(responses.get(0), "OK");
assertEquals(responses.get(1), "END");
}
public void testGetKeyLengthLimit() throws IOException {
String tooLongKey = generateRandomString(251);
String resp = send("get " + tooLongKey + "\r\n");
assertClientError(resp);
tooLongKey = generateRandomString(251);
resp = send("get k1 k2 k3 " + tooLongKey + "\r\n");
assertClientError(resp);
}
public void testUnknownCommand() throws IOException {
assertError(send("blah\r\n"));
assertError(send("blah boo poo goo zoo\r\n"));
}
public void testUnknownCommandPipelined() throws IOException {
List<String> responses = sendMulti("bogus\r\ndelete a\r\n", 2, true);
assertEquals(responses.size(), 2);
assertEquals("ERROR", responses.get(0));
assertEquals("NOT_FOUND", responses.get(1));
}
public void testReadFullLineAfterLongKey() throws IOException {
String key = generateRandomString(300);
String command = "add " + key + " 0 0 1\r\nget a\r\n";
List<String> responses = sendMulti(command, 2, true);
assertEquals(2, responses.size());
assertTrue(responses.get(0), responses.get(0).contains("CLIENT_ERROR"));
assertEquals("END", responses.get(1));
}
public void testNegativeBytesLengthValue() throws IOException {
assertClientError(send("set boo1 0 0 -1\r\n"));
assertClientError(send("add boo2 0 0 -1\r\n"));
}
public void testFlagsIsUnsigned(Method m) throws IOException {
String k = m.getName();
assertClientError(send("set boo1 -1 0 0\r\n"));
assertStored(send("set " + k + " 4294967295 0 0\r\n\r\n"));
assertClientError(send("set boo2 4294967296 0 0\r\n"));
assertClientError(send("set boo2 18446744073709551615 0 0\r\n"));
}
public void testIncrDecrIsUnsigned(Method m) throws IOException, InterruptedException, ExecutionException, TimeoutException {
String k = m.getName();
OperationFuture<Boolean> f = client.set(k, 0, "0");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertClientError(send("incr " + k + " -1\r\n"));
assertClientError(send("decr " + k + " -1\r\n"));
k = k + "-1";
f = client.set(k, 0, "0");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertExpectedResponse(send("incr " + k + " 18446744073709551615\r\n"), "18446744073709551615", true);
k = k + "-1";
f = client.set(k, 0, "0");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertClientError(send("incr " + k + " 18446744073709551616\r\n"));
assertClientError(send("decr " + k + " 18446744073709551616\r\n"));
}
public void testIncrKeyLengthLimit() throws InterruptedException, ExecutionException, TimeoutException, IOException {
String keyUnderLimit = generateRandomString(249);
OperationFuture<Boolean> f = client.set(keyUnderLimit, 0, "78");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(keyUnderLimit), "78");
String keyInLimit = generateRandomString(250);
f = client.set(keyInLimit, 0, "89");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
assertEquals(client.get(keyInLimit), "89");
String keyAboveLimit = generateRandomString(251);
String resp = incr(keyAboveLimit, 1);
assertClientError(resp);
}
public void testIncrementBeyondLongMax(Method m) throws InterruptedException, ExecutionException, TimeoutException, IOException {
OperationFuture<Boolean> f = client.set(k(m), 0, "9223372036854775808");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
String newValue = incr(m, 1);
assertEquals(new BigInteger(newValue), new BigInteger("9223372036854775809"));
}
public void testIncrementSurpassLongMax(Method m) throws InterruptedException, ExecutionException, TimeoutException, IOException {
OperationFuture<Boolean> f = client.set(k(m), 0, "9223372036854775807");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
String newValue = incr(m, 1);
assertEquals(new BigInteger(newValue), new BigInteger("9223372036854775808"));
}
public void testIncrementSurpassBigIntMax(Method m) throws InterruptedException, ExecutionException, TimeoutException, IOException {
OperationFuture<Boolean> f = client.set(k(m), 0, "18446744073709551615");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
String newValue = incr(m, 1);
assertEquals(newValue, "0");
}
private String incr(Method m, int by) throws IOException {
return incr(k(m), by);
}
private String incr(String k, int by) throws IOException {
return send("incr " + k + " " + by + "\r\n");
}
public void testVerbosity() throws IOException {
assertClientError(send("verbosity\r\n"));
assertClientError(send("verbosity 5\r\n"));
assertClientError(send("verbosity 10 noreply\r\n"));
}
public void testQuit(Method m) throws InterruptedException, ExecutionException, TimeoutException, IOException {
OperationFuture<Boolean> f = client.set(k(m), 0, "0");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
sendNoWait("quit\r\n");
}
public void testBufferOverflowCausesUnknownException() throws Exception {
List<String> keys = Files.readAllLines(
Paths.get(getClass().getClassLoader().getResource("keys.txt").toURI()),
StandardCharsets.UTF_8
);
for (String key : keys) {
assertTrue(client.set(key, 0, "ISPN005003: UnknownOperationException").get());
}
}
public void testDeleteNoReply(Method m) throws InterruptedException, ExecutionException, TimeoutException, IOException {
withNoReply(m, String.format("delete %s noreply\r\n", k(m)));
}
public void testFlushAllNoReply(Method m) throws InterruptedException, ExecutionException, TimeoutException, IOException {
withNoReply(m, "flush_all noreply\r\n");
}
private void withNoReply(Method m, String op) throws InterruptedException, ExecutionException, TimeoutException,
IOException {
OperationFuture<Boolean> f = client.set(k(m), 0, "blah");
assertTrue(f.get(timeout, TimeUnit.SECONDS));
CountDownLatch latch = new CountDownLatch(1);
NoReplyListener listener = new NoReplyListener(latch);
cache.addListener(listener);
try {
sendNoWait(op);
log.debug("No reply delete sent, wait...");
boolean completed = latch.await(10, TimeUnit.SECONDS);
assertTrue("Timed out waiting for remove to be executed", completed);
} finally {
cache.removeListener(listener);
}
}
@Listener
class NoReplyListener {
private final CountDownLatch latch;
Log log = LogFactory.getLog(NoReplyListener.class, Log.class);
NoReplyListener(CountDownLatch latch) {
this.latch = latch;
}
@CacheEntryRemoved
public void removed(CacheEntryRemovedEvent event) {
log.debug("Entry removed, open latch");
latch.countDown();
}
}
}
| 11,042
| 38.159574
| 135
|
java
|
null |
infinispan-main/server/memcached/src/test/java/org/infinispan/server/memcached/text/MemcachedClusteredStatsTest.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.commons.test.TestResourceTracker.getCurrentTestShortName;
import static org.infinispan.test.fwk.TestCacheManagerFactory.configureJmx;
import javax.management.JMException;
import javax.management.ObjectName;
import org.infinispan.commons.jmx.MBeanServerLookup;
import org.infinispan.commons.jmx.TestMBeanServerLookup;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.memcached.test.MemcachedMultiNodeTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.annotations.Test;
/**
* Tests whether statistics of clustered Memcached instances are calculated correctly.
*
* @author Galder Zamarreño
* @since 5.2
*/
@Test(groups = "functional", testName = "server.memcached.text.MemcachedClusteredStatsTest")
public class MemcachedClusteredStatsTest extends MemcachedMultiNodeTest {
private static final String JMX_DOMAIN = MemcachedClusteredStatsTest.class.getSimpleName();
private final MBeanServerLookup mBeanServerLookup = TestMBeanServerLookup.create();
@Override
public EmbeddedCacheManager createCacheManager(int index) {
GlobalConfigurationBuilder globalBuilder = GlobalConfigurationBuilder.defaultClusteredBuilder();
globalBuilder.defaultCacheName(cacheName);
configureJmx(globalBuilder, JMX_DOMAIN + "-" + index, mBeanServerLookup);
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.clustering().cacheMode(CacheMode.REPL_SYNC);
return TestCacheManagerFactory.createClusteredCacheManager(globalBuilder, builder);
}
public void testSingleConnectionPerServer() throws Exception {
ObjectName objectName = new ObjectName(String.format("%s-0:type=Server,component=Transport,name=Memcached-%s-%d",
JMX_DOMAIN, getCurrentTestShortName(), servers.get(0).getPort()));
// Now verify that via JMX as well, these stats are also as expected
eventuallyEquals(2, () -> {
try {
return mBeanServerLookup.getMBeanServer().getAttribute(objectName, "NumberOfGlobalConnections");
} catch (JMException e) {
log.debug("Exception encountered", e);
}
return 0;
});
}
}
| 2,495
| 42.789474
| 125
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/PersistenceContextInitializer.java
|
package org.infinispan.server.memcached;
import org.infinispan.marshall.persistence.impl.PersistenceMarshallerImpl;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
/**
* Interface used to initialise the {@link PersistenceMarshallerImpl}'s {@link org.infinispan.protostream.SerializationContext}
* using the specified Pojos, Marshaller implementations and provided .proto schemas.
*
* @author Ryan Emerson
* @since 10.0
*/
@AutoProtoSchemaBuilder(
dependsOn = org.infinispan.marshall.persistence.impl.PersistenceContextInitializer.class,
includeClasses = MemcachedMetadata.class,
schemaFileName = "persistence.memcached.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.persistence.memcached",
service = false
)
interface PersistenceContextInitializer extends SerializationContextInitializer {
}
| 958
| 38.958333
| 127
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedStats.java
|
package org.infinispan.server.memcached;
import static java.util.concurrent.atomic.AtomicLongFieldUpdater.newUpdater;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.atomic.AtomicLongFieldUpdater;
/**
* @since 15.0
**/
public class MemcachedStats {
public static final AtomicLongFieldUpdater<MemcachedStats> INCR_MISSES = newUpdater(MemcachedStats.class, "incrMisses");
public static final AtomicLongFieldUpdater<MemcachedStats> INCR_HITS = newUpdater(MemcachedStats.class, "incrHits");
public static final AtomicLongFieldUpdater<MemcachedStats> DECR_MISSES = newUpdater(MemcachedStats.class, "decrMisses");
public static final AtomicLongFieldUpdater<MemcachedStats> DECR_HITS = newUpdater(MemcachedStats.class, "decrHits");
public static final AtomicLongFieldUpdater<MemcachedStats> CAS_MISSES = newUpdater(MemcachedStats.class, "casMisses");
public static final AtomicLongFieldUpdater<MemcachedStats> CAS_HITS = newUpdater(MemcachedStats.class, "casHits");
public static final AtomicLongFieldUpdater<MemcachedStats> CAS_BADVAL = newUpdater(MemcachedStats.class, "casBadval");
private volatile long incrMisses = 0;
private volatile long incrHits = 0;
private volatile long decrMisses = 0;
private volatile long decrHits = 0;
private volatile long casMisses = 0;
private volatile long casHits = 0;
private volatile long casBadval = 0;
public static class MemcachedStatsKeys {
public static final byte[] PID = "pid".getBytes(StandardCharsets.US_ASCII);
public static final byte[] UPTIME = "uptime".getBytes(StandardCharsets.US_ASCII);
public static final byte[] TIME = "time".getBytes(StandardCharsets.US_ASCII);
public static final byte[] VERSION = "version".getBytes(StandardCharsets.US_ASCII);
public static final byte[] POINTER_SIZE = "pointer_size".getBytes(StandardCharsets.US_ASCII);
public static final byte[] RUSAGE_USER = "rusage_user".getBytes(StandardCharsets.US_ASCII);
public static final byte[] RUSAGE_SYSTEM = "rusage_system".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CURR_ITEMS = "curr_items".getBytes(StandardCharsets.US_ASCII);
public static final byte[] TOTAL_ITEMS = "total_items".getBytes(StandardCharsets.US_ASCII);
public static final byte[] BYTES = "bytes".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CMD_GET = "cmd_get".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CMD_SET = "cmd_set".getBytes(StandardCharsets.US_ASCII);
public static final byte[] GET_HITS = "get_hits".getBytes(StandardCharsets.US_ASCII);
public static final byte[] GET_MISSES = "get_misses".getBytes(StandardCharsets.US_ASCII);
public static final byte[] DELETE_MISSES = "delete_misses".getBytes(StandardCharsets.US_ASCII);
public static final byte[] DELETE_HITS = "delete_hits".getBytes(StandardCharsets.US_ASCII);
public static final byte[] INCR_MISSES = "incr_misses".getBytes(StandardCharsets.US_ASCII);
public static final byte[] INCR_HITS = "incr_hits".getBytes(StandardCharsets.US_ASCII);
public static final byte[] DECR_MISSES = "decr_misses".getBytes(StandardCharsets.US_ASCII);
public static final byte[] DECR_HITS = "decr_hits".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CAS_MISSES = "cas_misses".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CAS_HITS = "cas_hits".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CAS_BADVAL = "cas_badval".getBytes(StandardCharsets.US_ASCII);
public static final byte[] AUTH_CMDS = "auth_cmds".getBytes(StandardCharsets.US_ASCII);
public static final byte[] AUTH_ERRORS = "auth_errors".getBytes(StandardCharsets.US_ASCII);
public static final byte[] EVICTIONS = "evictions".getBytes(StandardCharsets.US_ASCII);
public static final byte[] BYTES_READ = "bytes_read".getBytes(StandardCharsets.US_ASCII);
public static final byte[] BYTES_WRITTEN = "bytes_written".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CURR_CONNECTIONS = "curr_connections".getBytes(StandardCharsets.US_ASCII);
public static final byte[] TOTAL_CONNECTIONS = "total_connections".getBytes(StandardCharsets.US_ASCII);
public static final byte[] THREADS = "threads".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CONNECTION_STRUCTURES = "connection_structures".getBytes(StandardCharsets.US_ASCII);
public static final byte[] LIMIT_MAXBYTES = "limit_maxbytes".getBytes(StandardCharsets.US_ASCII);
public static final byte[] CONN_YIELDS = "conn_yields".getBytes(StandardCharsets.US_ASCII);
public static final byte[] RECLAIMED = "reclaimed".getBytes(StandardCharsets.US_ASCII);
}
}
| 4,824
| 71.014925
| 123
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedResponse.java
|
package org.infinispan.server.memcached;
import java.util.concurrent.CompletionStage;
import java.util.function.BiConsumer;
import org.infinispan.commons.util.ByRef;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.memcached.logging.Header;
import org.infinispan.server.memcached.logging.MemcachedAccessLogging;
import org.infinispan.util.concurrent.AggregateCompletionStage;
import org.infinispan.util.concurrent.CompletionStages;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
public abstract class MemcachedResponse implements BiConsumer<Object, Throwable>, Runnable {
private volatile Object response;
private volatile Throwable throwable;
protected Header header;
private CompletionStage<Void> responseSent;
private final ByRef<MemcachedResponse> current;
protected final Channel ch;
private GenericFutureListener<? extends Future<? super Void>> listener;
protected MemcachedResponse(ByRef<MemcachedResponse> current, Channel ch) {
this.current = current;
this.ch = ch;
}
public void queueResponse(Header header, CompletionStage<?> response) {
queueResponse(header, response, null);
}
public void queueResponse(Header header, CompletionStage<?> operationResponse, GenericFutureListener<? extends Future<? super Void>> listener) {
assert ch.eventLoop().inEventLoop();
AggregateCompletionStage<Void> all = CompletionStages.aggregateCompletionStage();
MemcachedResponse c = current.get();
if (c != null) {
all.dependsOn(c.responseSent);
}
all.dependsOn(operationResponse.whenComplete(this));
this.listener = listener;
this.header = header;
responseSent = all.freeze()
.exceptionally(CompletableFutures.toNullFunction())
.thenRunAsync(this, ch.eventLoop());
current.set(this);
}
@Override
public void accept(Object response, Throwable throwable) {
// store the response
this.response = response;
this.throwable = throwable;
}
@Override
public void run() {
ChannelFuture future = throwable != null ? writeThrowable(header, throwable) : writeResponse(header, response);
if (listener != null) {
future.addListener(listener);
}
}
protected abstract ChannelFuture writeThrowable(Header header, Throwable throwable);
protected ChannelFuture writeResponse(Header header, Object response) {
if (response != null) {
ChannelFuture future = null;
int responseBytes = 0;
if (response instanceof ByteBuf[]) {
for (ByteBuf buf : (ByteBuf[]) response) {
responseBytes += buf.readableBytes();
future = ch.writeAndFlush(buf);
}
} else if (response instanceof byte[]) {
responseBytes = ((byte[]) response).length;
future = ch.writeAndFlush(ch.alloc().buffer(((byte[]) response).length).writeBytes((byte[]) response));
} else if (response instanceof CharSequence) {
responseBytes = ((CharSequence) response).length();
future = ch.writeAndFlush(ByteBufUtil.writeAscii(ch.alloc(), (CharSequence) response));
} else {
responseBytes = ((ByteBuf) response).readableBytes();
future = ch.writeAndFlush(response);
}
if (header != null) {
MemcachedAccessLogging.logOK(future, header, responseBytes);
}
return future;
} else {
return null;
}
}
}
| 3,740
| 36.787879
| 147
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedTextDetector.java
|
package org.infinispan.server.memcached;
import java.nio.charset.StandardCharsets;
import java.util.List;
import org.infinispan.server.core.ProtocolDetector;
import org.infinispan.server.core.logging.Log;
import org.infinispan.server.core.transport.AccessControlFilter;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
/**
* Detect Memcached connections
*/
public class MemcachedTextDetector extends ProtocolDetector {
public static final String NAME = "memcached-text-detector";
private final MemcachedServer server;
public MemcachedTextDetector(MemcachedServer server) {
super(server);
this.server = server;
}
@Override
public String getName() {
return NAME;
}
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
// We need to only see the SET command
if (in.readableBytes() < 4) {
// noop, wait for further reads
return;
}
int i = in.readerIndex();
// Memcached authentication is performed via a "fake" set command
CharSequence handshake = in.getCharSequence(i, 4, StandardCharsets.US_ASCII);
if ("set ".contentEquals(handshake)) {
installHandler(ctx);
}
// Remove this
ctx.pipeline().remove(this);
}
private void installHandler(ChannelHandlerContext ctx) {
// We found the Memcached authentication command, let's do some pipeline surgery
trimPipeline(ctx);
// Add the Memcached server handler
ctx.pipeline().addLast(server.getInitializer(MemcachedProtocol.TEXT));
Log.SERVER.tracef("Detected Memcached text connection %s", ctx);
// Trigger any protocol-specific rules
ctx.pipeline().fireUserEventTriggered(AccessControlFilter.EVENT);
}
}
| 1,876
| 31.362069
| 86
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedAutoDetector.java
|
package org.infinispan.server.memcached;
import java.util.List;
import org.infinispan.server.core.ProtocolDetector;
import org.infinispan.server.core.logging.Log;
import org.infinispan.server.core.transport.AccessControlFilter;
import org.infinispan.server.memcached.binary.BinaryConstants;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
public class MemcachedAutoDetector extends ProtocolDetector {
public static final String NAME = "memcached-auto-detector";
public MemcachedAutoDetector(MemcachedServer server) {
super(server);
}
@Override
public String getName() {
return NAME;
}
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) {
// We need to only see the magic byte
if (in.readableBytes() < 1) {
// noop, wait for further reads
return;
}
byte b = in.getByte(in.readerIndex());
trimPipeline(ctx);
MemcachedProtocol protocol = b == BinaryConstants.MAGIC_REQ ? MemcachedProtocol.BINARY : MemcachedProtocol.TEXT;
ctx.pipeline().replace(this, "decoder", ((MemcachedServer) server).getDecoder(protocol));
// Make sure to fire registered on the newly installed handlers
ctx.fireChannelRegistered();
Log.SERVER.tracef("Detected %s connection", protocol);
// Trigger any protocol-specific rules
ctx.pipeline().fireUserEventTriggered(AccessControlFilter.EVENT);
}
}
| 1,543
| 34.090909
| 118
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/LifecycleCallbacks.java
|
package org.infinispan.server.memcached;
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.marshall.protostream.impl.SerializationContextRegistry;
/**
* Module lifecycle callbacks implementation that enables module specific
* {@link org.infinispan.commons.marshall.AdvancedExternalizer} implementations to be registered.
*
* @author Galder Zamarreño
* @since 5.0
*/
@InfinispanModule(name = "server-memcached", requiredModules = "core")
public class LifecycleCallbacks implements ModuleLifecycle {
@Override
public void cacheManagerStarting(GlobalComponentRegistry gcr, GlobalConfiguration globalConfiguration) {
SerializationContextRegistry ctxRegistry = gcr.getComponent(SerializationContextRegistry.class);
PersistenceContextInitializerImpl sci = new PersistenceContextInitializerImpl();
ctxRegistry.addContextInitializer(SerializationContextRegistry.MarshallerType.PERSISTENCE, sci);
ctxRegistry.addContextInitializer(SerializationContextRegistry.MarshallerType.GLOBAL, sci);
}
}
| 1,229
| 46.307692
| 107
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedServer.java
|
package org.infinispan.server.memcached;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.server.core.AbstractProtocolServer;
import org.infinispan.server.core.transport.NettyChannelInitializer;
import org.infinispan.server.core.transport.NettyInitializers;
import org.infinispan.server.memcached.binary.BinaryAuthDecoderImpl;
import org.infinispan.server.memcached.binary.BinaryOpDecoderImpl;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration;
import org.infinispan.server.memcached.text.TextAuthDecoderImpl;
import org.infinispan.server.memcached.text.TextOpDecoderImpl;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInboundHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOutboundHandler;
import io.netty.channel.group.ChannelMatcher;
/**
* Memcached server defining its decoder/encoder settings. In fact, Memcached does not use an encoder since there's no
* really common headers between protocol operations.
*
* @author Galder Zamarreño
* @since 4.1
*/
public class MemcachedServer extends AbstractProtocolServer<MemcachedServerConfiguration> {
protected final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
private Cache<Object, Object> memcachedCache;
private MemcachedStats statistics;
public MemcachedServer() {
super("Memcached");
}
@Override
protected void startInternal() {
if (cacheManager.getCacheConfiguration(configuration.defaultCacheName()) == null) {
ConfigurationBuilder builder = new ConfigurationBuilder();
Configuration defaultCacheConfiguration = cacheManager.getDefaultCacheConfiguration();
if (defaultCacheConfiguration != null) { // We have a default configuration, use that
builder.read(defaultCacheConfiguration);
} else if (cacheManager.getCacheManagerConfiguration().isClustered()) { // We are running in clustered mode
builder.clustering().cacheMode(CacheMode.REPL_SYNC);
}
builder.encoding().key().mediaType(MediaType.TEXT_PLAIN);
builder.encoding().value().mediaType(MediaType.APPLICATION_OCTET_STREAM);
cacheManager.defineConfiguration(configuration.defaultCacheName(), builder.build());
}
memcachedCache = cacheManager.getCache(configuration.defaultCacheName());
if (memcachedCache.getCacheConfiguration().statistics().enabled()) {
statistics = new MemcachedStats();
}
super.startInternal();
}
@Override
public ChannelOutboundHandler getEncoder() {
return null;
}
/**
* Invoked when the Memcached server has a dedicated transport
*/
@Override
public ChannelInboundHandler getDecoder() {
switch (configuration.protocol()) {
case TEXT:
if (configuration.authentication().enabled()) {
return new TextAuthDecoderImpl(this);
} else {
return new TextOpDecoderImpl(this);
}
case BINARY:
if (configuration.authentication().enabled()) {
return new BinaryAuthDecoderImpl(this);
} else {
return new BinaryOpDecoderImpl(this);
}
default:
return new MemcachedAutoDetector(this);
}
}
/**
* Invoked when the Memcached server is part of a single-port router
*/
public ChannelInboundHandler getDecoder(MemcachedProtocol protocol) {
switch (protocol) {
case TEXT:
if (configuration.authentication().enabled()) {
return new TextAuthDecoderImpl(this);
} else {
return new TextOpDecoderImpl(this);
}
case BINARY:
if (configuration.authentication().enabled()) {
return new BinaryAuthDecoderImpl(this);
} else {
return new BinaryOpDecoderImpl(this);
}
default:
throw new IllegalStateException();
}
}
@Override
public ChannelMatcher getChannelMatcher() {
return channel -> (channel.pipeline().get(TextOpDecoderImpl.class) != null || channel.pipeline().get(BinaryOpDecoderImpl.class) != null);
}
@Override
public ChannelInitializer<Channel> getInitializer() {
return new NettyInitializers(new NettyChannelInitializer<>(this, transport, getEncoder(), this::getDecoder));
}
/**
* This initializer is invoked by the detector
*/
public ChannelInitializer<Channel> getInitializer(MemcachedProtocol protocol) {
return new NettyInitializers(new NettyChannelInitializer<>(this, transport, getEncoder(), () -> getDecoder(protocol)));
}
@Override
public void stop() {
super.stop();
scheduler.shutdown();
}
/**
* Returns the cache being used by the Memcached server
*/
public Cache<Object, Object> getCache() {
return memcachedCache;
}
public ScheduledExecutorService getScheduler() {
return scheduler;
}
@Override
public void installDetector(Channel ch) {
switch (configuration.protocol()) {
case AUTO:
ch.pipeline()
.addLast(MemcachedTextDetector.NAME, new MemcachedTextDetector(this))
.addLast(MemcachedBinaryDetector.NAME, new MemcachedBinaryDetector(this));
break;
case TEXT:
ch.pipeline().addLast(MemcachedTextDetector.NAME, new MemcachedTextDetector(this));
break;
case BINARY:
ch.pipeline().addLast(MemcachedBinaryDetector.NAME, new MemcachedBinaryDetector(this));
break;
}
}
public MemcachedStats getStatistics() {
return statistics;
}
}
| 6,148
| 34.75
| 143
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedMetadata.java
|
package org.infinispan.server.memcached;
import java.util.Objects;
import org.infinispan.commons.marshall.ProtoStreamTypeIds;
import org.infinispan.container.versioning.EntryVersion;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.container.versioning.SimpleClusteredVersion;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.metadata.Metadata;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
/**
* Memcached metadata information.
*
* @author Galder Zamarreño
* @since 5.3
*/
@ProtoTypeId(ProtoStreamTypeIds.MEMCACHED_METADATA)
public class MemcachedMetadata extends EmbeddedMetadata.EmbeddedLifespanExpirableMetadata {
@ProtoField(number = 5, defaultValue = "0")
public final int flags;
@ProtoFactory
public MemcachedMetadata(int flags, long lifespan, NumericVersion numericVersion, SimpleClusteredVersion clusteredVersion) {
this(flags, lifespan, numericVersion != null ? numericVersion : clusteredVersion);
}
private MemcachedMetadata(int flags, long lifespan, EntryVersion version) {
super(lifespan, version);
this.flags = flags;
}
@Override
public boolean isEmpty() {
return super.isEmpty() && flags == 0;
}
@Override
public Metadata.Builder builder() {
return new Builder()
.flags(flags)
.lifespan(lifespan())
.version(version());
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
if (!super.equals(o)) return false;
MemcachedMetadata that = (MemcachedMetadata) o;
return flags == that.flags;
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), flags);
}
@Override
public String toString() {
return "MemcachedMetadata{" +
"flags=" + flags +
", version=" + version() +
", lifespan=" + lifespan() +
'}';
}
public static class Builder extends EmbeddedMetadata.Builder {
private int flags;
public Builder flags(int flags) {
this.flags = flags;
return this;
}
@Override
public Metadata build() {
return new MemcachedMetadata(flags, lifespan == null ? -1 : lifespanUnit.toMillis(lifespan), version);
}
}
}
| 2,505
| 27.477273
| 127
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedBaseDecoder.java
|
package org.infinispan.server.memcached;
import static org.infinispan.server.memcached.MemcachedStats.CAS_BADVAL;
import static org.infinispan.server.memcached.MemcachedStats.CAS_HITS;
import static org.infinispan.server.memcached.MemcachedStats.CAS_MISSES;
import static org.infinispan.server.memcached.MemcachedStats.DECR_HITS;
import static org.infinispan.server.memcached.MemcachedStats.DECR_MISSES;
import static org.infinispan.server.memcached.MemcachedStats.INCR_HITS;
import static org.infinispan.server.memcached.MemcachedStats.INCR_MISSES;
import static org.infinispan.server.memcached.binary.BinaryConstants.MAX_EXPIRATION;
import java.nio.charset.StandardCharsets;
import java.time.temporal.Temporal;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import javax.security.auth.Subject;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.time.TimeService;
import org.infinispan.commons.util.ByRef;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.versioning.NumericVersionGenerator;
import org.infinispan.container.versioning.VersionGenerator;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.metadata.Metadata;
import org.infinispan.security.Security;
import org.infinispan.server.core.transport.NettyTransport;
import org.infinispan.server.memcached.logging.Header;
import org.infinispan.server.memcached.logging.Log;
import org.infinispan.server.memcached.logging.MemcachedAccessLogging;
import org.infinispan.stats.Stats;
import org.infinispan.util.logging.LogFactory;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
/**
* @since 15.0
**/
public abstract class MemcachedBaseDecoder extends ByteToMessageDecoder {
protected final static Subject ANONYMOUS = new Subject();
protected final static Log log = LogFactory.getLog(MemcachedBaseDecoder.class, Log.class);
protected final MemcachedServer server;
protected final MemcachedStats statistics;
protected final boolean statsEnabled;
protected final boolean accessLogging;
protected Temporal requestStart;
protected Channel channel;
protected final TimeService timeService;
protected final VersionGenerator versionGenerator;
protected final AdvancedCache<byte[], byte[]> cache;
protected final Subject subject;
protected final String principalName;
protected final ByRef<MemcachedResponse> current = ByRef.create(null);
protected MemcachedBaseDecoder(MemcachedServer server, Subject subject, AdvancedCache<byte[], byte[]> cache) {
this.server = server;
this.subject = subject;
this.principalName = Security.getSubjectUserPrincipalName(subject);
this.cache = cache.withSubject(subject);
ComponentRegistry registry = cache.getComponentRegistry();
VersionGenerator versionGenerator = registry.getComponent(VersionGenerator.class);
if (versionGenerator == null) {
versionGenerator = new NumericVersionGenerator();
registry.registerComponent(versionGenerator, VersionGenerator.class);
}
this.versionGenerator = versionGenerator;
this.timeService = registry.getTimeService();
this.statistics = server.getStatistics();
this.statsEnabled = statistics != null;
this.accessLogging = MemcachedAccessLogging.isEnabled();
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
channel = ctx.channel();
}
protected abstract void send(Header header, CompletionStage<?> response);
protected abstract void send(Header header, CompletionStage<?> response, GenericFutureListener<? extends Future<? super Void>> listener);
protected Map<byte[], byte[]> statsMap() {
Stats stats = cache.getAdvancedCache().getStats();
Map<byte[], byte[]> map = new LinkedHashMap<>(35);
map.put(MemcachedStats.MemcachedStatsKeys.PID, ParseUtil.writeAsciiLong(ProcessHandle.current().pid()));
map.put(MemcachedStats.MemcachedStatsKeys.UPTIME, ParseUtil.writeAsciiLong(stats.getTimeSinceStart()));
map.put(MemcachedStats.MemcachedStatsKeys.TIME, ParseUtil.writeAsciiLong(TimeUnit.MILLISECONDS.toSeconds(timeService.wallClockTime())));
map.put(MemcachedStats.MemcachedStatsKeys.VERSION, cache.getVersion().getBytes(StandardCharsets.US_ASCII));
map.put(MemcachedStats.MemcachedStatsKeys.POINTER_SIZE, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.RUSAGE_USER, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.RUSAGE_SYSTEM, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.CURR_ITEMS, ParseUtil.writeAsciiLong(stats.getApproximateEntries()));
map.put(MemcachedStats.MemcachedStatsKeys.TOTAL_ITEMS, ParseUtil.writeAsciiLong(stats.getStores()));
map.put(MemcachedStats.MemcachedStatsKeys.BYTES, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.CMD_GET, ParseUtil.writeAsciiLong(stats.getRetrievals()));
map.put(MemcachedStats.MemcachedStatsKeys.CMD_SET, ParseUtil.writeAsciiLong(stats.getStores()));
map.put(MemcachedStats.MemcachedStatsKeys.GET_HITS, ParseUtil.writeAsciiLong(stats.getHits()));
map.put(MemcachedStats.MemcachedStatsKeys.GET_MISSES, ParseUtil.writeAsciiLong(stats.getMisses()));
map.put(MemcachedStats.MemcachedStatsKeys.DELETE_MISSES, ParseUtil.writeAsciiLong(stats.getRemoveMisses()));
map.put(MemcachedStats.MemcachedStatsKeys.DELETE_HITS, ParseUtil.writeAsciiLong(stats.getRemoveHits()));
map.put(MemcachedStats.MemcachedStatsKeys.INCR_MISSES, ParseUtil.writeAsciiLong(INCR_MISSES.get(statistics)));
map.put(MemcachedStats.MemcachedStatsKeys.INCR_HITS, ParseUtil.writeAsciiLong(INCR_HITS.get(statistics)));
map.put(MemcachedStats.MemcachedStatsKeys.DECR_MISSES, ParseUtil.writeAsciiLong(DECR_MISSES.get(statistics)));
map.put(MemcachedStats.MemcachedStatsKeys.DECR_HITS, ParseUtil.writeAsciiLong(DECR_HITS.get(statistics)));
map.put(MemcachedStats.MemcachedStatsKeys.CAS_MISSES, ParseUtil.writeAsciiLong(CAS_MISSES.get(statistics)));
map.put(MemcachedStats.MemcachedStatsKeys.CAS_HITS, ParseUtil.writeAsciiLong(CAS_HITS.get(statistics)));
map.put(MemcachedStats.MemcachedStatsKeys.CAS_BADVAL, ParseUtil.writeAsciiLong(CAS_BADVAL.get(statistics)));
map.put(MemcachedStats.MemcachedStatsKeys.AUTH_CMDS, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.AUTH_ERRORS, ParseUtil.ZERO); // Unsupported
//TODO: Evictions are measured by evict calls, but not by nodes are that are expired after the entry's lifespan has expired.
map.put(MemcachedStats.MemcachedStatsKeys.EVICTIONS, ParseUtil.writeAsciiLong(stats.getEvictions()));
NettyTransport transport = server.getTransport();
map.put(MemcachedStats.MemcachedStatsKeys.BYTES_READ, ParseUtil.writeAsciiLong(transport.getTotalBytesRead()));
map.put(MemcachedStats.MemcachedStatsKeys.BYTES_WRITTEN, ParseUtil.writeAsciiLong(transport.getTotalBytesWritten()));
map.put(MemcachedStats.MemcachedStatsKeys.CURR_CONNECTIONS, ParseUtil.writeAsciiLong(transport.getNumberOfLocalConnections()));
map.put(MemcachedStats.MemcachedStatsKeys.TOTAL_CONNECTIONS, ParseUtil.writeAsciiLong(transport.getNumberOfGlobalConnections()));
map.put(MemcachedStats.MemcachedStatsKeys.THREADS, ParseUtil.ZERO); // TODO: Through netty?
map.put(MemcachedStats.MemcachedStatsKeys.CONNECTION_STRUCTURES, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.LIMIT_MAXBYTES, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.CONN_YIELDS, ParseUtil.ZERO); // Unsupported
map.put(MemcachedStats.MemcachedStatsKeys.RECLAIMED, ParseUtil.ZERO); // Unsupported
return map;
}
protected Metadata touchMetadata(CacheEntry<?, ?> entry, int expiration) {
return new MemcachedMetadata.Builder()
.merge(entry.getMetadata())
.lifespan(toMillis(expiration))
.build();
}
protected long toMillis(int lifespan) {
if (lifespan > MAX_EXPIRATION) {
long unixTimeExpiry = TimeUnit.SECONDS.toMillis(lifespan) - timeService.wallClockTime();
return unixTimeExpiry < 0 ? 0 : unixTimeExpiry;
} else {
return TimeUnit.SECONDS.toMillis(lifespan);
}
}
protected Metadata metadata(int flags, int expiration) {
return new MemcachedMetadata.Builder()
.flags(flags)
.version(versionGenerator.generateNew())
.lifespan(expiration > 0 ? toMillis(expiration) : -1)
.build();
}
}
| 8,904
| 56.083333
| 142
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/ParseUtil.java
|
package org.infinispan.server.memcached;
public class ParseUtil {
private ParseUtil() { }
static final byte[] DigitTens = {
'0', '0', '0', '0', '0', '0', '0', '0', '0', '0',
'1', '1', '1', '1', '1', '1', '1', '1', '1', '1',
'2', '2', '2', '2', '2', '2', '2', '2', '2', '2',
'3', '3', '3', '3', '3', '3', '3', '3', '3', '3',
'4', '4', '4', '4', '4', '4', '4', '4', '4', '4',
'5', '5', '5', '5', '5', '5', '5', '5', '5', '5',
'6', '6', '6', '6', '6', '6', '6', '6', '6', '6',
'7', '7', '7', '7', '7', '7', '7', '7', '7', '7',
'8', '8', '8', '8', '8', '8', '8', '8', '8', '8',
'9', '9', '9', '9', '9', '9', '9', '9', '9', '9',
};
static final byte[] DigitOnes = {
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
};
public static byte[] ZERO = new byte[] { '0' };
public static long readLong(byte[] in) {
if (in == null || in.length == 0)
throw new NumberFormatException("Empty argument");
boolean negative = false;
int i = 0;
if (in[0] < '0') {
if ((in[0] != '-' && in[0] != '+') || in.length == 1)
throw new NumberFormatException("Invalid character: " + in[0]);
negative = true;
i = 1;
}
long result;
byte b = in[i++];
if (b < '0' || b > '9')
throw new NumberFormatException("Invalid character: " + b);
result = (b - 48);
for (; i < in.length; i++) {
b = in[i];
if (b < '0' || b > '9')
throw new NumberFormatException("Invalid character: " + b);
result = (result << 3) + (result << 1) + (b - 48);
}
return negative ? -result : result;
}
public static int readInt(byte[] in) {
long v = readLong(in);
if (v > Integer.MAX_VALUE || v < Integer.MIN_VALUE) {
throw new NumberFormatException("Invalid integer: " + v);
}
return (int)v;
}
public static byte[] writeAsciiLong(long in) {
if (in == 0) return ZERO;
int numberDigits = stringSize(in);
int writerIndex = numberDigits;
boolean negative = in < 0;
byte[] out = new byte[numberDigits];
if (!negative) {
in = -in;
}
long q;
int r;
while (in <= -100) {
q = in / 100;
r = (int)((q * 100) - in);
in = q;
out[--writerIndex] = DigitOnes[r];
out[--writerIndex] = DigitTens[r];
}
q = in / 10;
r = (int)((q * 10) - in);
out[--writerIndex] = (byte) ('0' + r);
if (q < 0) {
out[--writerIndex] = (byte) ('0' - q);
}
if (negative) {
out[0] = '-';
}
return out;
}
private static int stringSize(long x) {
int d = 1;
if (x >= 0) {
d = 0;
x = -x;
}
int p = -10;
for (int i = 1; i < 10; i++) {
if (x > p)
return i + d;
p = 10 * p;
}
return 10 + d;
}
}
| 3,554
| 26.992126
| 75
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedBinaryDetector.java
|
package org.infinispan.server.memcached;
import org.infinispan.server.core.MagicByteDetector;
import org.infinispan.server.memcached.binary.BinaryConstants;
import org.infinispan.server.memcached.configuration.MemcachedProtocol;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
public class MemcachedBinaryDetector extends MagicByteDetector {
public static final String NAME = "memcached-binary-detector";
public MemcachedBinaryDetector(MemcachedServer server) {
super(server, BinaryConstants.MAGIC_REQ);
}
@Override
public String getName() {
return NAME;
}
@Override
protected ChannelInitializer<Channel> getInitializer() {
return ((MemcachedServer) server).getInitializer(MemcachedProtocol.BINARY);
}
}
| 784
| 28.074074
| 81
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/MemcachedStatus.java
|
package org.infinispan.server.memcached;
import java.nio.charset.StandardCharsets;
/**
* @since 15.0
**/
public enum MemcachedStatus {
NO_ERROR(0x0000),
KEY_NOT_FOUND(0x0001, "NOT_FOUND"),
KEY_EXISTS(0x0002, "EXISTS"),
VALUE_TOO_LARGE(0x0003),
INVALID_ARGUMENTS(0x0004),
ITEM_NOT_STORED(0x0005, "NOT_STORED"),
INCR_DECR_NON_NUMERIC(0x0006),
VBUCKET_ON_OTHER_SERVER(0x0007),
AUTHN_ERROR(0x0020),
AUTHN_CONTINUE(0x0021),
UNKNOWN_COMMAND(0x0081),
OUT_OF_MEMORY(0x0082),
NOT_SUPPORTED(0x0083),
INTERNAL_ERROR(0x0084, "SERVER_ERROR"),
BUSY(0x0085),
TEMPORARY_FAILURE(0x0086),
DELETED(0x0);
private final short binaryOpCode;
private final byte[] text;
MemcachedStatus(int binaryOpCode, String text) {
this.binaryOpCode = (short) binaryOpCode;
this.text = text.getBytes(StandardCharsets.US_ASCII);
}
MemcachedStatus(int binaryOpCode) {
this.binaryOpCode = (short) binaryOpCode;
this.text = null;
}
public short getBinary() {
return binaryOpCode;
}
public byte[] getText() {
return text;
}
}
| 1,110
| 22.145833
| 59
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/MemcachedServerConfigurationBuilder.java
|
package org.infinispan.server.memcached.configuration;
import static org.infinispan.server.memcached.configuration.MemcachedServerConfiguration.CLIENT_ENCODING;
import static org.infinispan.server.memcached.configuration.MemcachedServerConfiguration.DEFAULT_MEMCACHED_CACHE;
import static org.infinispan.server.memcached.configuration.MemcachedServerConfiguration.DEFAULT_MEMCACHED_PORT;
import static org.infinispan.server.memcached.configuration.MemcachedServerConfiguration.PROTOCOL;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.server.core.admin.AdminOperationsHandler;
import org.infinispan.server.core.configuration.EncryptionConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
/**
* MemcachedServerConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 5.3
*/
public class MemcachedServerConfigurationBuilder extends ProtocolServerConfigurationBuilder<MemcachedServerConfiguration, MemcachedServerConfigurationBuilder, MemcachedAuthenticationConfiguration> implements
Builder<MemcachedServerConfiguration> {
private final MemcachedAuthenticationConfigurationBuilder authentication = new MemcachedAuthenticationConfigurationBuilder(this);
private final EncryptionConfigurationBuilder encryption = new EncryptionConfigurationBuilder(ssl());
public MemcachedServerConfigurationBuilder() {
super(DEFAULT_MEMCACHED_PORT, MemcachedServerConfiguration.attributeDefinitionSet());
this.defaultCacheName(DEFAULT_MEMCACHED_CACHE);
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public MemcachedServerConfigurationBuilder self() {
return this;
}
/**
* Use {@link ProtocolServerConfigurationBuilder#defaultCacheName(String)} instead
*/
@Deprecated
public MemcachedServerConfigurationBuilder cache(String cache) {
this.defaultCacheName(cache);
return this;
}
@Override
public MemcachedAuthenticationConfigurationBuilder authentication() {
return authentication;
}
public EncryptionConfigurationBuilder encryption() {
return encryption;
}
@Override
public MemcachedServerConfigurationBuilder adminOperationsHandler(AdminOperationsHandler handler) {
// Ignore
return this;
}
/**
* The encoding to be used by clients of the memcached text protocol. When not specified, "application/octet-stream" is assumed.
* When encoding is set, the memcached text server will assume clients will be reading and writing values in that encoding, and
* will perform the necessary conversions between this encoding and the storage format.
*/
public MemcachedServerConfigurationBuilder clientEncoding(MediaType payloadType) {
attributes.attribute(CLIENT_ENCODING).set(payloadType);
return this;
}
public MemcachedServerConfigurationBuilder protocol(MemcachedProtocol protocol) {
attributes.attribute(PROTOCOL).set(protocol);
return this;
}
public MemcachedProtocol protocol() {
return attributes.attribute(PROTOCOL).get();
}
@Override
public MemcachedServerConfiguration create() {
return new MemcachedServerConfiguration(attributes.protect(), authentication().create(), ssl.create(), encryption.create(), ipFilter.create());
}
@Override
public void validate() {
super.validate();
authentication.validate();
encryption.validate();
}
public MemcachedServerConfiguration build(boolean validate) {
if (validate) {
validate();
}
return create();
}
@Override
public MemcachedServerConfiguration build() {
return build(true);
}
@Override
public Builder<?> read(MemcachedServerConfiguration template, Combine combine) {
this.authentication.read(template.authentication(), combine);
this.encryption.read(template.encryption(), combine);
return this;
}
}
| 4,162
| 34.887931
| 207
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/package-info.java
|
/**
* Memcached Server Configuration API
*
* @api.public
*/
package org.infinispan.server.memcached.configuration;
| 119
| 16.142857
| 54
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/TextAuthenticationConfiguration.java
|
package org.infinispan.server.memcached.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.server.core.security.UsernamePasswordAuthenticator;
/**
* @since 15.0
**/
public class TextAuthenticationConfiguration extends ConfigurationElement<TextAuthenticationConfiguration> {
static final AttributeDefinition<UsernamePasswordAuthenticator> AUTHENTICATOR = AttributeDefinition.builder("authenticator", null, UsernamePasswordAuthenticator.class).autoPersist(false).build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(TextAuthenticationConfiguration.class, AUTHENTICATOR);
}
protected TextAuthenticationConfiguration(AttributeSet attributes) {
super("authenticator", attributes);
}
public UsernamePasswordAuthenticator authenticator() {
return attributes.attribute(AUTHENTICATOR).get();
}
}
| 1,075
| 40.384615
| 198
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/MemcachedAuthenticationConfigurationBuilder.java
|
package org.infinispan.server.memcached.configuration;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.core.configuration.AuthenticationConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationChildBuilder;
import org.infinispan.server.core.configuration.SaslConfigurationBuilder;
/**
* MemcachedAuthenticationConfigurationBuilder.
*
* @since 7.0
*/
public class MemcachedAuthenticationConfigurationBuilder implements AuthenticationConfigurationBuilder<MemcachedAuthenticationConfiguration> {
private final AttributeSet attributes;
private final SaslConfigurationBuilder sasl = new SaslConfigurationBuilder();
private final TextAuthenticationConfigurationBuilder text = new TextAuthenticationConfigurationBuilder();
public MemcachedAuthenticationConfigurationBuilder(ProtocolServerConfigurationChildBuilder<?,?,?> builder) {
this.attributes = MemcachedAuthenticationConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public MemcachedAuthenticationConfigurationBuilder enable() {
return enabled(true);
}
public MemcachedAuthenticationConfigurationBuilder disable() {
return enabled(false);
}
public MemcachedAuthenticationConfigurationBuilder enabled(boolean enabled) {
attributes.attribute(MemcachedAuthenticationConfiguration.ENABLED).set(enabled);
return this;
}
public boolean enabled() {
return attributes.attribute(MemcachedAuthenticationConfiguration.ENABLED).get();
}
public MemcachedAuthenticationConfigurationBuilder securityRealm(String name) {
attributes.attribute(MemcachedAuthenticationConfiguration.SECURITY_REALM).set(name);
return this;
}
public String securityRealm() {
return attributes.attribute(MemcachedAuthenticationConfiguration.SECURITY_REALM).get();
}
public boolean hasSecurityRealm() {
return !attributes.attribute(MemcachedAuthenticationConfiguration.SECURITY_REALM).isNull();
}
public SaslConfigurationBuilder sasl() {
return sasl;
}
public TextAuthenticationConfigurationBuilder text() {
return text;
}
@Override
public void validate() {
if (enabled()) {
sasl.validate();
text.validate();
}
}
@Override
public MemcachedAuthenticationConfiguration create() {
return new MemcachedAuthenticationConfiguration(attributes.protect(), sasl.create(), text.create());
}
@Override
public Builder<?> read(MemcachedAuthenticationConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.sasl.read(template.sasl(), combine);
this.text.read(template.text(), combine);
return this;
}
}
| 2,961
| 32.659091
| 142
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/MemcachedServerConfiguration.java
|
package org.infinispan.server.memcached.configuration;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OCTET_STREAM;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.ConfigurationFor;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.server.core.configuration.EncryptionConfiguration;
import org.infinispan.server.core.configuration.IpFilterConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.configuration.SslConfiguration;
import org.infinispan.server.memcached.MemcachedServer;
/**
* MemcachedServerConfiguration.
*
* @author Tristan Tarrant
* @since 5.3
*/
@BuiltBy(MemcachedServerConfigurationBuilder.class)
@ConfigurationFor(MemcachedServer.class)
public class MemcachedServerConfiguration extends ProtocolServerConfiguration<MemcachedServerConfiguration, MemcachedAuthenticationConfiguration> {
public static final int DEFAULT_MEMCACHED_PORT = 11211;
public static final String DEFAULT_MEMCACHED_CACHE = "memcachedCache";
public static final AttributeDefinition<MediaType> CLIENT_ENCODING = AttributeDefinition.builder("client-encoding", APPLICATION_OCTET_STREAM, MediaType.class).immutable().build();
public static final AttributeDefinition<MemcachedProtocol> PROTOCOL = AttributeDefinition.builder("protocol", MemcachedProtocol.AUTO, MemcachedProtocol.class).immutable().build();
private final EncryptionConfiguration encryption;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(MemcachedServerConfiguration.class, ProtocolServerConfiguration.attributeDefinitionSet(), CLIENT_ENCODING, PROTOCOL);
}
MemcachedServerConfiguration(AttributeSet attributes, MemcachedAuthenticationConfiguration authentication, SslConfiguration ssl, EncryptionConfiguration encryptionConfiguration, IpFilterConfiguration ipRules) {
super("memcached-connector", attributes, authentication, ssl, ipRules);
this.encryption = encryptionConfiguration;
}
public EncryptionConfiguration encryption() {
return encryption;
}
public MediaType clientEncoding() {
return attributes.attribute(CLIENT_ENCODING).get();
}
public MemcachedProtocol protocol() {
return attributes.attribute(PROTOCOL).get();
}
}
| 2,526
| 45.796296
| 213
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/MemcachedAuthenticationConfiguration.java
|
package org.infinispan.server.memcached.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.server.core.configuration.AuthenticationConfiguration;
import org.infinispan.server.core.configuration.SaslConfiguration;
/**
* AuthenticationConfiguration.
*
* @since 15.0
*/
public class MemcachedAuthenticationConfiguration extends ConfigurationElement<MemcachedAuthenticationConfiguration> implements AuthenticationConfiguration {
static final AttributeDefinition<String> SECURITY_REALM = AttributeDefinition.builder("security-realm", null, String.class).build();
static final AttributeDefinition<Boolean> ENABLED = AttributeDefinition.builder("enabled", false).build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(MemcachedAuthenticationConfiguration.class, SECURITY_REALM, ENABLED);
}
private final SaslConfiguration saslConfiguration;
private final TextAuthenticationConfiguration textAuthenticationConfiguration;
MemcachedAuthenticationConfiguration(AttributeSet attributes, SaslConfiguration saslConfiguration, TextAuthenticationConfiguration textAuthenticationConfiguration) {
super("authentication", attributes, saslConfiguration, textAuthenticationConfiguration);
this.saslConfiguration = saslConfiguration;
this.textAuthenticationConfiguration = textAuthenticationConfiguration;
}
@Override
public String securityRealm() {
return attributes.attribute(SECURITY_REALM).get();
}
public boolean enabled() {
return attributes.attribute(ENABLED).get();
}
public SaslConfiguration sasl() {
return saslConfiguration;
}
public TextAuthenticationConfiguration text() {
return textAuthenticationConfiguration;
}
}
| 1,960
| 39.854167
| 168
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/TextAuthenticationConfigurationBuilder.java
|
package org.infinispan.server.memcached.configuration;
import static org.infinispan.server.memcached.configuration.TextAuthenticationConfiguration.AUTHENTICATOR;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.core.security.UsernamePasswordAuthenticator;
/**
* @since 15.0
**/
public class TextAuthenticationConfigurationBuilder implements Builder<TextAuthenticationConfiguration> {
private final AttributeSet attributes = TextAuthenticationConfiguration.attributeDefinitionSet();
public TextAuthenticationConfigurationBuilder authenticator(UsernamePasswordAuthenticator authenticator) {
attributes.attribute(AUTHENTICATOR).set(authenticator);
return this;
}
@Override
public TextAuthenticationConfiguration create() {
return new TextAuthenticationConfiguration(attributes.protect());
}
@Override
public Builder<?> read(TextAuthenticationConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
}
| 1,258
| 33.027027
| 109
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/configuration/MemcachedProtocol.java
|
package org.infinispan.server.memcached.configuration;
/**
* @since 15.0
**/
public enum MemcachedProtocol {
AUTO(true, true),
TEXT(true, false),
BINARY(false, true),
;
private final boolean text;
private final boolean binary;
MemcachedProtocol(boolean text, boolean binary) {
this.text = text;
this.binary = binary;
}
public boolean isBinary() {
return binary;
}
public boolean isText() {
return text;
}
}
| 474
| 15.964286
| 54
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryOpDecoder.java
|
package org.infinispan.server.memcached.binary;
import static org.infinispan.server.memcached.MemcachedStats.CAS_BADVAL;
import static org.infinispan.server.memcached.MemcachedStats.CAS_HITS;
import static org.infinispan.server.memcached.MemcachedStats.CAS_MISSES;
import static org.infinispan.server.memcached.MemcachedStats.DECR_HITS;
import static org.infinispan.server.memcached.MemcachedStats.DECR_MISSES;
import static org.infinispan.server.memcached.MemcachedStats.INCR_HITS;
import static org.infinispan.server.memcached.MemcachedStats.INCR_MISSES;
import static org.infinispan.server.memcached.MemcachedStatus.DELETED;
import static org.infinispan.server.memcached.MemcachedStatus.ITEM_NOT_STORED;
import static org.infinispan.server.memcached.MemcachedStatus.KEY_EXISTS;
import static org.infinispan.server.memcached.MemcachedStatus.KEY_NOT_FOUND;
import static org.infinispan.server.memcached.MemcachedStatus.NO_ERROR;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import javax.security.auth.Subject;
import org.infinispan.commons.util.SimpleImmutableEntry;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.Version;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.context.Flag;
import org.infinispan.metadata.Metadata;
import org.infinispan.server.memcached.MemcachedMetadata;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.ParseUtil;
import org.jgroups.util.CompletableFutures;
import io.netty.buffer.ByteBuf;
abstract class BinaryOpDecoder extends BinaryDecoder {
protected BinaryOpDecoder(MemcachedServer server, Subject subject) {
super(server, subject);
}
protected void get(BinaryHeader header, byte[] key, boolean quiet) {
CompletableFuture<ByteBuf> response = cache.getCacheEntryAsync(key).thenApply(e -> {
boolean withKey = header.op == BinaryCommand.GETK || header.op == BinaryCommand.GETKQ;
// getq/getkq
if (e == null) {
if (quiet)
return null;
return response(header, KEY_NOT_FOUND, withKey ? key : Util.EMPTY_BYTE_ARRAY, Util.EMPTY_BYTE_ARRAY);
} else {
MemcachedMetadata metadata = (MemcachedMetadata) e.getMetadata();
header.cas = ((NumericVersion) metadata.version()).getVersion();
return response(header, NO_ERROR, metadata.flags, withKey ? key : Util.EMPTY_BYTE_ARRAY, e.getValue());
}
});
send(header, response);
}
protected void set(BinaryHeader header, byte[] key, byte[] value, int flags, int expiration, boolean quiet) {
Metadata metadata = metadata(flags, expiration);
CompletableFuture<ByteBuf> response;
if (header.cas == 0) {
response = cache.withFlags(Flag.IGNORE_RETURN_VALUES)
.putAsync(key, value, metadata)
.thenApply(ignore -> storeResponse(header, quiet, metadata));
} else {
response = cache.getCacheEntryAsync(key).thenCompose(e -> {
if (e == null) {
return CompletableFuture.completedFuture(response(header, KEY_NOT_FOUND));
} else {
long version = ((NumericVersion) e.getMetadata().version()).getVersion();
if (version == header.cas) {
return cache.replaceAsync(key, e.getValue(), value, metadata).thenApply(ignore -> storeResponse(header, quiet, metadata));
} else {
return CompletableFuture.completedFuture(response(header, KEY_EXISTS));
}
}
});
}
send(header, response);
}
protected void add(BinaryHeader header, byte[] key, byte[] value, int flags, int expiration, boolean quiet) {
Metadata metadata = metadata(flags, expiration);
CompletableFuture<ByteBuf> response = cache
.putIfAbsentAsyncEntry(key, value, metadata)
.thenApply(e -> {
if (e != null) {
return response(header, KEY_EXISTS);
} else {
return storeResponse(header, quiet, metadata);
}
});
send(header, response);
}
protected void replace(BinaryHeader header, byte[] key, byte[] value, int flags, int expiration, boolean quiet) {
Metadata metadata = metadata(flags, expiration);
CompletableFuture<ByteBuf> response;
if (header.cas == 0) {
response = cache
.replaceAsync(key, value, metadata)
.thenApply(e -> {
if (e == null) {
return response(header, KEY_NOT_FOUND);
} else {
return storeResponse(header, quiet, metadata);
}
});
} else {
response = cache.getCacheEntryAsync(key).thenCompose(e -> {
if (e == null) {
CAS_MISSES.incrementAndGet(statistics);
return CompletableFuture.completedFuture(response(header, KEY_NOT_FOUND));
} else {
long version = ((NumericVersion) metadata.version()).getVersion();
if (header.cas == version) {
return cache.replaceAsync(key, e.getValue(), value, metadata).thenApply(ignore -> {
CAS_HITS.incrementAndGet(statistics);
return storeResponse(header, quiet, metadata);
});
} else {
CAS_BADVAL.incrementAndGet(statistics);
return CompletableFuture.completedFuture(response(header, ITEM_NOT_STORED));
}
}
});
}
send(header, response);
}
private ByteBuf storeResponse(BinaryHeader header, boolean quiet, Metadata metadata) {
if (quiet) {
return null;
}
header.cas = ((NumericVersion) metadata.version()).getVersion();
return response(header, NO_ERROR);
}
protected void delete(BinaryHeader header, byte[] key, boolean quiet) {
CompletableFuture<ByteBuf> response;
if (header.cas == 0) {
response = cache.removeAsync(key)
.thenApply(v -> {
if (v != null && quiet) {
return null;
} else {
return response(header, v == null ? KEY_NOT_FOUND : DELETED);
}
});
} else {
response = cache.getCacheEntryAsync(key)
.thenCompose(e -> {
if (e == null) {
return CompletableFuture.completedFuture(response(header, KEY_NOT_FOUND));
} else {
long version = ((NumericVersion) e.getMetadata().version()).getVersion();
if (header.cas == version) {
return cache.removeAsync(key, e.getValue()).thenApply(d -> {
if (d) {
return quiet ? null : response(header, DELETED);
} else {
return response(header, KEY_EXISTS);
}
});
} else {
return CompletableFuture.completedFuture(response(header, KEY_EXISTS));
}
}
});
}
send(header, response);
}
protected void increment(BinaryHeader header, byte[] key, long delta, long initial, int expiration, boolean quiet) {
Metadata metadata = metadata(0, expiration);
CompletableFuture<byte[]> f;
if (expiration == -1) {
f = cache.computeIfPresentAsync(key, (k, v) -> increment(delta, v), metadata);
} else {
f = cache.mergeAsync(key, ParseUtil.writeAsciiLong(initial), (v1, v2) -> increment(delta, v1), metadata);
}
CompletableFuture<ByteBuf> response = f.thenApply(v -> {
if (v == null) {
if (statsEnabled) {
if (delta > 0) {
INCR_MISSES.incrementAndGet(statistics);
} else {
DECR_MISSES.incrementAndGet(statistics);
}
}
return response(header, KEY_NOT_FOUND);
}
if (statsEnabled) {
if (delta > 0) {
INCR_HITS.incrementAndGet(statistics);
} else {
DECR_HITS.incrementAndGet(statistics);
}
}
if (quiet)
return null;
header.cas = ((NumericVersion) metadata.version()).getVersion();
return response(header, NO_ERROR, ParseUtil.readLong(v));
});
send(header, response);
}
private static byte[] increment(long delta, byte[] v1) {
long l = ParseUtil.readLong(v1);
l += delta;
if (l < 0) l = 0;
return ParseUtil.writeAsciiLong(l);
}
protected void append(BinaryHeader header, byte[] key, byte[] value, boolean quiet) {
CompletableFuture<ByteBuf> response = cache.computeIfPresentAsync(key, (k, v) -> {
byte[] r = Arrays.copyOf(v, v.length + value.length);
System.arraycopy(value, 0, r, v.length, value.length);
return r;
}, null).thenApply(v -> {
if (quiet)
return null;
return response(header, v == null ? KEY_NOT_FOUND : NO_ERROR);
});
send(header, response);
}
protected void prepend(BinaryHeader header, byte[] key, byte[] value, boolean quiet) {
CompletableFuture<ByteBuf> response = cache.computeIfPresentAsync(key, (k, v) -> {
byte[] r = Arrays.copyOf(value, v.length + value.length);
System.arraycopy(v, 0, r, value.length, v.length);
return r;
}, null).thenApply(v -> {
if (quiet)
return null;
return response(header, v == null ? KEY_NOT_FOUND : NO_ERROR);
});
send(header, response);
}
protected void quit(BinaryHeader header, boolean quiet) {
if (quiet) {
channel.close();
} else {
ByteBuf buf = response(header, NO_ERROR);
send(header, CompletableFuture.completedFuture(buf), (v) -> channel.close());
}
}
protected void version(BinaryHeader header) {
ByteBuf r = response(header, NO_ERROR, Version.getVersion().getBytes(StandardCharsets.US_ASCII));
send(header, CompletableFuture.completedFuture(r));
}
protected void noop(BinaryHeader header) {
send(header, CompletableFuture.completedFuture(response(header, NO_ERROR)));
}
protected void touch(BinaryHeader header, byte[] key, int expiration) {
CompletableFuture<Object> r = cache.getCacheEntryAsync(key)
.thenCompose(e -> {
if (e == null) {
return CompletableFuture.completedFuture(response(header, KEY_NOT_FOUND));
} else {
return cache.replaceAsync(e.getKey(), e.getValue(), touchMetadata(e, expiration))
.thenApply(ignore -> response(header, NO_ERROR));
}
});
send(header, r);
}
protected void gat(BinaryHeader header, byte[] key, int expiration, boolean quiet) {
CompletableFuture<Object> r = cache.getCacheEntryAsync(key)
.thenCompose(e -> {
boolean withKey = header.op == BinaryCommand.GATK || header.op == BinaryCommand.GATKQ;
if (e == null) {
if (quiet)
return CompletableFutures.completedNull();
else
return CompletableFuture.completedFuture(response(header, KEY_NOT_FOUND, withKey ? key : Util.EMPTY_BYTE_ARRAY, Util.EMPTY_BYTE_ARRAY));
} else {
MemcachedMetadata metadata = (MemcachedMetadata) e.getMetadata();
header.cas = ((NumericVersion) metadata.version()).getVersion();
return cache.replaceAsync(e.getKey(), e.getValue(), touchMetadata(e, expiration))
.thenApply(x -> response(header, NO_ERROR, metadata.flags, withKey ? e.getKey() : Util.EMPTY_BYTE_ARRAY, e.getValue()));
}
});
send(header, r);
}
protected void stat(BinaryHeader header, byte[] key) {
CompletionStage<ByteBuf> s = server.getBlockingManager().supplyBlocking(() -> {
Map<byte[], byte[]> map = statsMap();
if (key != null) {
if (!map.containsKey(key)) {
return response(header, KEY_NOT_FOUND);
} else {
return singleStat(header, new SimpleImmutableEntry<>(key, map.get(key)));
}
} else {
ByteBuf buf = channel.alloc().buffer();
for (Map.Entry<byte[], byte[]> e : map.entrySet()) {
buf.writeBytes(singleStat(header, e));
}
buf.writeBytes(response(header, NO_ERROR));
return buf;
}
}, "memcached-stats");
send(header, s);
}
private ByteBuf singleStat(BinaryHeader header, Map.Entry<byte[], byte[]> e) {
return response(header, NO_ERROR, e.getKey(), e.getValue());
}
protected void flush(BinaryHeader header, int expiration, boolean quiet) {
final CompletableFuture<Void> future;
if (expiration == 0) {
future = cache.clearAsync();
} else {
server.getBlockingManager().scheduleRunBlocking(cache::clear, toMillis(expiration), TimeUnit.MILLISECONDS, "memcached-flush");
future = CompletableFuture.completedFuture(null);
}
if (quiet)
return;
send(header, future.thenApply(ignore -> response(header, NO_ERROR)));
}
protected void verbosityLevel(BinaryHeader header, int verbosity) {
send(header, CompletableFuture.completedFuture(response(header, NO_ERROR)));
}
}
| 14,004
| 40.681548
| 157
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryAuthDecoder.java
|
package org.infinispan.server.memcached.binary;
import static org.infinispan.server.memcached.binary.BinaryConstants.MEMCACHED_SASL_PROTOCOL;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import javax.security.auth.Subject;
import javax.security.sasl.Sasl;
import javax.security.sasl.SaslException;
import javax.security.sasl.SaslServer;
import org.infinispan.commons.util.Util;
import org.infinispan.server.core.security.sasl.SaslAuthenticator;
import org.infinispan.server.core.security.sasl.SubjectSaslServer;
import org.infinispan.server.core.transport.SaslQopHandler;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.MemcachedStatus;
import io.netty.buffer.ByteBuf;
abstract class BinaryAuthDecoder extends BinaryDecoder {
private SaslServer saslServer;
protected BinaryAuthDecoder(MemcachedServer server) {
super(server, ANONYMOUS);
}
protected void saslListMechs(BinaryHeader header) {
byte[] mechs = String.join(" ", server.getConfiguration().authentication().sasl().mechanisms()).getBytes(StandardCharsets.US_ASCII);
ByteBuf r = response(header, MemcachedStatus.NO_ERROR, mechs);
send(header, CompletableFuture.completedFuture(r));
}
protected void saslAuth(BinaryHeader header, byte[] mech, byte[] data) {
CompletionStage<ByteBuf> r = server.getBlockingManager().supplyBlocking(() -> {
try {
saslServer = SaslAuthenticator.createSaslServer(server.getConfiguration().authentication().sasl(), channel, new String(mech, StandardCharsets.US_ASCII), MEMCACHED_SASL_PROTOCOL);
return doSasl(header, data);
} catch (Throwable t) {
return response(header, MemcachedStatus.AUTHN_ERROR, t);
}
}, "memcached-sasl-auth");
send(header, r);
}
protected void saslStep(BinaryHeader header, byte[] mech, byte[] data) {
CompletionStage<ByteBuf> r = server.getBlockingManager().supplyBlocking(() -> doSasl(header, data), "memcached-sasl-step");
send(header, r);
}
private ByteBuf doSasl(BinaryHeader header, byte[] data) {
try {
byte[] serverChallenge = saslServer.evaluateResponse(data);
if (saslServer.isComplete()) {
// Obtaining the subject might be expensive, so do it before sending the final server challenge, otherwise the
// client might send another operation before this is complete
Subject subject = (Subject) saslServer.getNegotiatedProperty(SubjectSaslServer.SUBJECT);
// Finally we set up the QOP handler if required
String qop = (String) saslServer.getNegotiatedProperty(Sasl.QOP);
if ("auth-int".equals(qop) || "auth-conf".equals(qop)) {
channel.eventLoop().submit(() -> {
channel.writeAndFlush(response(header, MemcachedStatus.NO_ERROR));
SaslQopHandler qopHandler = new SaslQopHandler(saslServer);
channel.pipeline().addBefore("decoder", "saslQop", qopHandler);
});
} else {
// Send the final server challenge
channel.eventLoop().submit(() -> {
channel.writeAndFlush(response(header, MemcachedStatus.NO_ERROR, serverChallenge == null ? Util.EMPTY_BYTE_ARRAY : serverChallenge));
channel.pipeline().replace("decoder", "decoder", new BinaryOpDecoderImpl(server, subject));
disposeSaslServer();
});
}
return null;
} else {
return response(header, MemcachedStatus.AUTHN_CONTINUE, serverChallenge);
}
} catch (Throwable t) {
return response(header, MemcachedStatus.AUTHN_ERROR, t);
}
}
private void disposeSaslServer() {
try {
if (saslServer != null)
saslServer.dispose();
} catch (SaslException e) {
log.debug("Exception while disposing SaslServer", e);
} finally {
saslServer = null;
}
}
}
| 4,128
| 42.010417
| 190
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryHeader.java
|
package org.infinispan.server.memcached.binary;
import java.time.temporal.Temporal;
import org.infinispan.server.memcached.logging.Header;
/**
* @since 15.0
**/
public class BinaryHeader extends Header {
private final Object key;
final BinaryCommand op;
final int opaque;
long cas;
BinaryHeader(Temporal requestStart, int requestBytes, String principalName, Object key, BinaryCommand op, int opaque, long cas) {
super(requestStart, requestBytes, principalName);
this.key = key;
this.op = op;
this.opaque = opaque;
this.cas = cas;
}
BinaryHeader(BinaryHeader h) {
this(h.requestStart, h.requestBytes, h.principalName, h.key, h.op, h.opaque, h.cas);
}
@Override
public Object getKey() {
return key;
}
@Override
public String getOp() {
return op.name();
}
@Override
public String getProtocol() {
return "MCBIN";
}
}
| 928
| 20.604651
| 132
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryConstants.java
|
package org.infinispan.server.memcached.binary;
/**
* Memcache binary protocol constants.
* {@link <a href="https://github.com/memcached/memcached/wiki/BinaryProtocolRevamped">Memcached Binary Protocol</a>}
*
* @since 15.0
*/
public interface BinaryConstants {
// Magic
byte MAGIC_REQ = (byte) 0x80;
byte MAGIC_RES = (byte) 0x81;
int MAX_EXPIRATION = 60 * 60 * 24 * 30;
String MEMCACHED_SASL_PROTOCOL = "memcached";
}
| 441
| 23.555556
| 117
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryDecoder.java
|
package org.infinispan.server.memcached.binary;
import static org.infinispan.server.memcached.binary.BinaryConstants.MAGIC_RES;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import javax.security.auth.Subject;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.util.Util;
import org.infinispan.server.core.transport.ConnectionMetadata;
import org.infinispan.server.memcached.MemcachedBaseDecoder;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.MemcachedStatus;
import org.infinispan.server.memcached.logging.Header;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
/**
* @since 15.0
**/
abstract class BinaryDecoder extends MemcachedBaseDecoder {
protected BinaryDecoder(MemcachedServer server, Subject subject) {
super(server, subject, server.getCache().getAdvancedCache().withMediaType(MediaType.APPLICATION_OCTET_STREAM, server.getConfiguration().clientEncoding()));
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
super.handlerAdded(ctx);
ConnectionMetadata metadata = ConnectionMetadata.getInstance(channel);
metadata.subject(subject);
metadata.protocolVersion("MCBIN");
}
protected void config(BinaryHeader header, byte[] key) {
if (log.isTraceEnabled()) {
log.tracef("CONFIG %s", Util.printArray(key));
}
String k = new String(key, StandardCharsets.US_ASCII);
StringBuilder sb = new StringBuilder();
if (k.equals("cluster")) {
sb.append("1");
sb.append("\r\n");
sb.append(server.getHost());
sb.append('|');
sb.append(server.getHost());
sb.append('|');
sb.append(server.getPort());
sb.append("\r\n");
}
ByteBuf b = response(header, MemcachedStatus.NO_ERROR, 0, Util.EMPTY_BYTE_ARRAY, sb.toString().getBytes(StandardCharsets.US_ASCII));
send(header, CompletableFuture.completedFuture(b));
}
protected ByteBuf response(BinaryHeader header, MemcachedStatus status) {
return response(header, status, Util.EMPTY_BYTE_ARRAY, Util.EMPTY_BYTE_ARRAY);
}
protected ByteBuf response(BinaryHeader header, MemcachedStatus status, byte[] value) {
return response(header, status, Util.EMPTY_BYTE_ARRAY, value);
}
protected ByteBuf response(BinaryHeader header, MemcachedStatus status, byte[] key, byte[] value) {
int totalLength = key.length + value.length;
ByteBuf buf = channel.alloc().buffer(24 + totalLength);
buf.writeByte(MAGIC_RES);
buf.writeByte(header.op.opCode());
buf.writeShort(key.length); // key length
buf.writeByte(0); // extras length
buf.writeByte(0); // data type
buf.writeShort(status.getBinary());
buf.writeInt(totalLength);
buf.writeInt(header.opaque);
buf.writeLong(header.cas);
buf.writeBytes(key);
buf.writeBytes(value);
return buf;
}
protected ByteBuf response(BinaryHeader header, MemcachedStatus status, int flags, byte[] key, byte[] value) {
int totalLength = key.length + value.length + 4;
ByteBuf buf = channel.alloc().buffer(24 + totalLength);
buf.writeByte(MAGIC_RES);
buf.writeByte(header.op.opCode());
buf.writeShort(key.length); // key length
buf.writeByte(4); // extras length
buf.writeByte(0); // data type
buf.writeShort(status.getBinary());
buf.writeInt(totalLength);
buf.writeInt(header.opaque);
buf.writeLong(header.cas);
buf.writeInt(flags);
buf.writeBytes(key);
buf.writeBytes(value);
return buf;
}
protected ByteBuf response(BinaryHeader header, MemcachedStatus status, long number) {
ByteBuf buf = channel.alloc().buffer(32);
buf.writeByte(MAGIC_RES);
buf.writeByte(header.op.opCode());
buf.writeShort(0); // key length
buf.writeByte(0); // extras length
buf.writeByte(0); // data type
buf.writeShort(status.getBinary());
buf.writeInt(8);
buf.writeInt(header.opaque);
buf.writeLong(header.cas);
buf.writeLong(number);
return buf;
}
protected ByteBuf response(BinaryHeader header, MemcachedStatus status, Throwable t) {
return response(header, status, t.getMessage().getBytes(StandardCharsets.US_ASCII));
}
@Override
public void send(Header header, CompletionStage<?> response) {
new BinaryResponse(current, channel).queueResponse(accessLogging ? header : null, response);
}
@Override
public void send(Header header, CompletionStage<?> response, GenericFutureListener<? extends Future<? super Void>> listener) {
new BinaryResponse(current, channel).queueResponse(accessLogging ? header : null, response, listener);
}
}
| 4,998
| 36.586466
| 161
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryIntrinsics.java
|
package org.infinispan.server.memcached.binary;
import org.infinispan.server.core.transport.ExtendedByteBufJava;
import io.netty.buffer.ByteBuf;
public class BinaryIntrinsics {
public static int int_(ByteBuf b) {
if (b.readableBytes() >= 4) {
return b.readInt();
} else return 0;
}
public static long long_(ByteBuf b) {
if (b.readableBytes() >= 8) {
return b.readLong();
} else return 0;
}
public static byte byte_(ByteBuf b) {
if (b.isReadable()) {
return b.readByte();
} else return 0;
}
public static short short_(ByteBuf b) {
if (b.readableBytes() >= 2) {
return b.readShort();
} else return 0;
}
public static byte[] fixedArray(ByteBuf b, int length) {
b.markReaderIndex();
return ExtendedByteBufJava.readMaybeRangedBytes(b, length);
}
public static BinaryCommand opCode(ByteBuf b) {
if (b.isReadable()) {
return BinaryCommand.fromOpCode(b.readByte());
} else {
return null;
}
}
}
| 1,063
| 22.130435
| 65
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryCommand.java
|
package org.infinispan.server.memcached.binary;
/**
* @since 15.0
**/
public enum BinaryCommand {
// Opcodes
GET(0x00),
SET(0x01),
ADD(0x02),
REPLACE(0x03),
DELETE(0x04),
INCREMENT(0x05),
DECREMENT(0x06),
QUIT(0x07),
FLUSH(0x08),
GETQ(0x09),
NO_OP(0x0a),
VERSION(0x0b),
GETK(0x0c),
GETKQ(0x0d),
APPEND(0x0e),
PREPEND(0x0f),
STAT(0x10),
SETQ(0x11),
ADDQ(0x12),
REPLACEQ(0x13),
DELETEQ(0x14),
INCREMENTQ(0x15),
DECREMENTQ(0x16),
QUITQ(0x17),
FLUSHQ(0x18),
APPENDQ(0x19),
PREPENDQ(0x1a),
VERBOSITY(0x1b),
TOUCH(0x1c),
GAT(0x1d),
GATQ(0x1e),
SASL_LIST_MECHS(0x20),
SASL_AUTH(0x21),
SASL_STEP(0x22),
GATK(0x23),
GATKQ(0x24),
CONFIG_GET(0x60);
private final byte opCode;
static final BinaryCommand[] ALL;
static {
ALL = new BinaryCommand[0x61];
for (BinaryCommand op : values()) {
ALL[op.opCode] = op;
}
}
BinaryCommand(int opCode) {
this.opCode = (byte) opCode;
}
public byte opCode() {
return opCode;
}
public static BinaryCommand fromOpCode(byte opCode) {
return ALL[opCode];
}
}
| 1,175
| 16.043478
| 56
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/binary/BinaryResponse.java
|
package org.infinispan.server.memcached.binary;
import org.infinispan.commons.util.ByRef;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.memcached.MemcachedResponse;
import org.infinispan.server.memcached.logging.Header;
import org.infinispan.server.memcached.logging.MemcachedAccessLogging;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
/**
* @since 15.0
**/
public class BinaryResponse extends MemcachedResponse {
public BinaryResponse(ByRef<MemcachedResponse> current, Channel ch) {
super(current, ch);
}
@Override
protected ChannelFuture writeThrowable(Header header, Throwable throwable) {
Throwable cause = CompletableFutures.extractException(throwable);
ch.pipeline().fireExceptionCaught(cause);
ChannelFuture future = ch.newFailedFuture(cause);
if (header != null) {
MemcachedAccessLogging.logException(future, header, cause.getMessage(), 0);
}
return future;
}
}
| 1,019
| 30.875
| 84
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/logging/Log.java
|
package org.infinispan.server.memcached.logging;
import static org.jboss.logging.Logger.Level.ERROR;
import org.infinispan.commons.CacheConfigurationException;
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 Memcached server module. For this module, message ids
* ranging from 11001 to 12000 inclusively have been reserved.
*
* @author Galder Zamarreño
* @since 5.0
*/
@MessageLogger(projectCode = "ISPN")
public interface Log extends BasicLogger {
Log SERVER = Logger.getMessageLogger(Log.class, "org.infinispan.SERVER");;
@LogMessage(level = ERROR)
@Message(value = "Exception reported", id = 5003)
void exceptionReported(@Cause Throwable t);
@Message(value = "Cache '%s' has expiration enabled which violates the Memcached protocol", id = 11001)
CacheConfigurationException invalidExpiration(String cacheName);
@Message(value = "Cannot enable Memcached text-protocol detection when authentication is disabled", id = 11002)
CacheConfigurationException cannotDetectMemcachedTextWithoutAuthentication();
}
| 1,286
| 36.852941
| 114
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/logging/Header.java
|
package org.infinispan.server.memcached.logging;
import java.time.temporal.Temporal;
/**
* @since 15.0
**/
public abstract class Header {
protected final Temporal requestStart;
protected final int requestBytes;
protected final String principalName;
protected Header(Temporal requestStart, int requestBytes, String principalName) {
this.requestStart = requestStart;
this.requestBytes = requestBytes;
this.principalName = principalName;
}
public abstract String getOp();
public abstract String getProtocol();
public abstract Object getKey();
}
| 592
| 22.72
| 84
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/logging/MemcachedAccessLogging.java
|
package org.infinispan.server.memcached.logging;
import java.net.InetSocketAddress;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import org.infinispan.commons.util.Util;
import org.infinispan.util.logging.LogFactory;
import org.jboss.logging.Logger;
import org.jboss.logging.MDC;
import io.netty.channel.ChannelFuture;
/**
* Logging handler for Memcached to log what requests have come into the server
*
* @since 15.0
*/
public final class MemcachedAccessLogging {
public final static Logger log = LogFactory.getLogger("MEMCACHED_ACCESS_LOG");
public static boolean isEnabled() {
return log.isTraceEnabled();
}
public static void logOK(ChannelFuture future, Header header, int responseBytes) {
logAfterComplete(future, header, responseBytes, "OK");
}
public static void logException(ChannelFuture future, Header header, String exception, int responseBytes) {
logAfterComplete(future, header, responseBytes, exception);
}
private static void logAfterComplete(ChannelFuture future, Header header, int responseBytes, String status) {
String remoteAddress = ((InetSocketAddress)future.channel().remoteAddress()).getHostString();
future.addListener(f -> {
// Duration
long duration;
if (header.requestStart == null) {
duration = -1;
} else {
duration = ChronoUnit.MILLIS.between(header.requestStart, Instant.now());
}
MDC.clear();
MDC.put("address", remoteAddress);
MDC.put("user", checkForNull(header.principalName));
MDC.put("method", checkForNull(header.getOp()));
MDC.put("protocol", header.getProtocol());
MDC.put("status", checkForNull(status));
MDC.put("responseSize", responseBytes);
MDC.put("requestSize", header.requestBytes);
MDC.put("duration", duration);
log.tracef("/%s", checkForNull(header.getKey()));
});
}
private static String checkForNull(Object obj) {
if (obj == null || obj instanceof String && ((String) obj).isEmpty()) {
return "-";
} else if (obj instanceof byte[]) {
return Util.printArray((byte[]) obj);
} else {
return obj.toString();
}
}
}
| 2,275
| 32.970149
| 112
|
java
|
null |
infinispan-main/server/memcached/src/main/java/org/infinispan/server/memcached/text/TextResponse.java
|
package org.infinispan.server.memcached.text;
import static org.infinispan.server.memcached.text.TextConstants.CLIENT_ERROR_BAD_FORMAT;
import static org.infinispan.server.memcached.text.TextConstants.CRLF;
import static org.infinispan.server.memcached.text.TextConstants.SERVER_ERROR;
import java.io.IOException;
import java.nio.CharBuffer;
import java.nio.charset.StandardCharsets;
import org.infinispan.commons.util.ByRef;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.server.memcached.MemcachedResponse;
import org.infinispan.server.memcached.logging.Header;
import org.infinispan.server.memcached.logging.MemcachedAccessLogging;
import io.netty.buffer.ByteBufUtil;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
/**
* @since 15.0
**/
public class TextResponse extends MemcachedResponse {
public TextResponse(ByRef<MemcachedResponse> current, Channel ch) {
super(current, ch);
}
@Override
protected ChannelFuture writeThrowable(Header header, Throwable throwable) {
Throwable cause = CompletableFutures.extractException(throwable);
String error;
if (cause instanceof IOException || cause instanceof IllegalArgumentException) {
error = CLIENT_ERROR_BAD_FORMAT + " " + cause.getMessage() + CRLF;
} else if (cause instanceof UnsupportedOperationException) {
error = "ERROR" + CRLF;
} else {
error = SERVER_ERROR + " " + cause.getMessage() + CRLF;
}
ChannelFuture future = ch.writeAndFlush(ByteBufUtil.encodeString(ch.alloc(), CharBuffer.wrap(error), StandardCharsets.US_ASCII));
if (header != null) {
MemcachedAccessLogging.logException(future, header, error, error.length());
}
return future;
}
}
| 1,792
| 36.354167
| 135
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.