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/core/src/main/java/org/infinispan/server/core/admin/embeddedserver/TemplateCreateTask.java
|
package org.infinispan.server.core.admin.embeddedserver;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.api.CacheContainerAdmin;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.manager.EmbeddedCacheManager;
/**
* * Admin operation to create a template
* * Parameters:
* * <ul>
* * <li><strong>name</strong> the name of the template to create</li>
* * <li><strong>configuration</strong> the XML configuration to use</li>
* * <li><strong>flags</strong> any flags, e.g. PERMANENT</li>
* * </ul>
*
* @author Ryan Emerson
* @since 12.0
*/
public class TemplateCreateTask extends CacheCreateTask {
private static final Set<String> PARAMETERS;
static {
Set<String> params = new HashSet<>(2);
params.add("name");
params.add("configuration");
PARAMETERS = Collections.unmodifiableSet(params);
}
@Override
public String getTaskContextName() {
return "template";
}
@Override
public String getTaskOperationName() {
return "create";
}
@Override
public Set<String> getParameters() {
return PARAMETERS;
}
@Override
protected Void execute(EmbeddedCacheManager cacheManager, Map<String, List<String>> parameters,
EnumSet<CacheContainerAdmin.AdminFlag> flags) {
String name = requireParameter(parameters, "name");
String configuration = requireParameter(parameters, "configuration");
Configuration config = getConfigurationBuilder(name, configuration).build();
if (!cacheManager.getCacheManagerConfiguration().isClustered() && config.clustering().cacheMode().isClustered()) {
throw log.cannotCreateClusteredCache();
}
cacheManager.administration().withFlags(flags).createTemplate(name, config);
return null;
}
}
| 1,956
| 29.578125
| 120
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/admin/embeddedserver/TemplateRemoveTask.java
|
package org.infinispan.server.core.admin.embeddedserver;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.api.CacheContainerAdmin;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.admin.AdminServerTask;
/**
* * Admin operation to remove a template
* * Parameters:
* * <ul>
* * <li><strong>name</strong> the name of the template to remove</li>
* * <li><strong>flags</strong> any flags, e.g. PERMANENT</li>
* * </ul>
*
* @author Ryan Emerson
* @since 12.0
*/
public class TemplateRemoveTask extends AdminServerTask<Void> {
private static final Set<String> PARAMETERS;
static {
Set<String> params = new HashSet<>(1);
params.add("name");
PARAMETERS = Collections.unmodifiableSet(params);
}
@Override
public String getTaskContextName() {
return "template";
}
@Override
public String getTaskOperationName() {
return "remove";
}
@Override
public Set<String> getParameters() {
return PARAMETERS;
}
@Override
protected Void execute(EmbeddedCacheManager cacheManager, Map<String, List<String>> parameters,
EnumSet<CacheContainerAdmin.AdminFlag> flags) {
String name = requireParameter(parameters,"name");
cacheManager.administration().withFlags(flags).removeTemplate(name);
return null;
}
}
| 1,503
| 25.385965
| 98
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/admin/embeddedserver/CacheNamesTask.java
|
package org.infinispan.server.core.admin.embeddedserver;
import java.nio.charset.StandardCharsets;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.api.CacheContainerAdmin;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.core.admin.AdminServerTask;
/**
* Admin operation to obtain a list of caches
*
* @author Tristan Tarrant
* @since 9.2
*/
public class CacheNamesTask extends AdminServerTask<byte[]> {
@Override
public String getTaskContextName() {
return "cache";
}
@Override
public String getTaskOperationName() {
return "names";
}
@Override
protected byte[] execute(EmbeddedCacheManager cacheManager, Map<String, List<String>> parameters, EnumSet<CacheContainerAdmin.AdminFlag> adminFlags) {
Set<String> cacheNames = cacheManager.getAccessibleCacheNames();
StringBuilder sb = new StringBuilder("[");
for(String s : cacheNames) {
if (sb.length() > 1)
sb.append(',');
sb.append('"');
sb.append(s);
sb.append('"');
}
sb.append(']');
return sb.toString().getBytes(StandardCharsets.UTF_8);
}
}
| 1,234
| 26.444444
| 153
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/utils/ManageableThreadPoolExecutorService.java
|
package org.infinispan.server.core.utils;
import java.util.concurrent.ExecutorService;
import org.infinispan.executors.ManageableExecutorService;
import org.infinispan.jmx.annotations.MBean;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
*/
@MBean(objectName = "WorkerExecutor")
public class ManageableThreadPoolExecutorService extends ManageableExecutorService<ExecutorService> {
public ManageableThreadPoolExecutorService(ExecutorService threadPoolExecutor) {
this.executor = threadPoolExecutor;
}
}
| 549
| 27.947368
| 101
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/utils/SslUtils.java
|
package org.infinispan.server.core.utils;
import java.util.Arrays;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLEngine;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.server.core.configuration.SslConfiguration;
import org.infinispan.server.core.configuration.SslEngineConfiguration;
import org.infinispan.server.core.logging.Log;
import io.netty.handler.ssl.ApplicationProtocolConfig;
import io.netty.handler.ssl.ClientAuth;
import io.netty.handler.ssl.IdentityCipherSuiteFilter;
import io.netty.handler.ssl.JdkSslContext;
/**
* SSL utils mainly for Netty.
*
* @author Sebastian Łaskawiec
* @since 9.0
*/
public class SslUtils {
public static JdkSslContext createNettySslContext(SslConfiguration sslConfiguration, SslEngineConfiguration sslEngineConfiguration, ApplicationProtocolConfig alpnConfig) {
return createSslContext(createJdkSslContext(sslEngineConfiguration), requireClientAuth(sslConfiguration), alpnConfig);
}
public static SSLContext createJdkSslContext(SslEngineConfiguration sslEngineConfiguration) {
if (sslEngineConfiguration.sslContext() != null) {
return sslEngineConfiguration.sslContext();
}
return new SslContextFactory()
.keyStoreFileName(sslEngineConfiguration.keyStoreFileName())
.keyStoreType(sslEngineConfiguration.keyStoreType())
.keyStorePassword(sslEngineConfiguration.keyStorePassword())
.keyStoreCertificatePassword(sslEngineConfiguration.keyStoreCertificatePassword())
.keyAlias(sslEngineConfiguration.keyAlias())
.trustStoreFileName(sslEngineConfiguration.trustStoreFileName())
.trustStoreType(sslEngineConfiguration.trustStoreType())
.trustStorePassword(sslEngineConfiguration.trustStorePassword())
.sslProtocol(sslEngineConfiguration.protocol())
.getContext();
}
private static JdkSslContext createSslContext(SSLContext sslContext, ClientAuth clientAuth, ApplicationProtocolConfig alpnConfig) {
SSLEngine engine = SslContextFactory.getEngine(sslContext, false, clientAuth == ClientAuth.REQUIRE);
String[] ciphers = engine.getEnabledCipherSuites();
if (Log.SECURITY.isDebugEnabled()) {
Log.SECURITY.debugf("SSL Engine enabled cipher suites = %s", ciphers);
Log.SECURITY.debugf("SSL Engine supported cipher suites = %s", engine.getSupportedCipherSuites());
Log.SECURITY.debugf("SSL Engine enabled protocols = %s", engine.getEnabledProtocols());
Log.SECURITY.debugf("SSL Engine supported protocols = %s", engine.getSupportedProtocols());
}
return new JdkSslContext(sslContext, false, Arrays.asList(ciphers), IdentityCipherSuiteFilter.INSTANCE, alpnConfig, clientAuth, null, false);
}
private static ClientAuth requireClientAuth(SslConfiguration sslConfig) {
return sslConfig.requireClientAuth() ? ClientAuth.REQUIRE : ClientAuth.NONE;
}
}
| 2,976
| 46.253968
| 174
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/utils/DelegatingEventLoopGroup.java
|
package org.infinispan.server.core.utils;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelPromise;
import io.netty.channel.EventLoop;
import io.netty.channel.EventLoopGroup;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.ScheduledFuture;
public abstract class DelegatingEventLoopGroup implements EventLoopGroup {
protected abstract EventLoopGroup delegate();
@Override
public boolean isShuttingDown() {
return delegate().isShuttingDown();
}
@Override
public Future<?> shutdownGracefully() {
return delegate().shutdownGracefully();
}
@Override
public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) {
return delegate().shutdownGracefully(quietPeriod, timeout, unit);
}
@Override
public Future<?> terminationFuture() {
return delegate().terminationFuture();
}
@Override
public void shutdown() {
delegate().shutdown();
}
@Override
public List<Runnable> shutdownNow() {
return delegate().shutdownNow();
}
@Override
public boolean isShutdown() {
return delegate().isShutdown();
}
@Override
public boolean isTerminated() {
return delegate().isTerminated();
}
@Override
public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
return delegate().awaitTermination(timeout, unit);
}
@Override
public EventLoop next() {
return delegate().next();
}
@Override
public Iterator<EventExecutor> iterator() {
return delegate().iterator();
}
@Override
public Future<?> submit(Runnable task) {
return delegate().submit(task);
}
@Override
public <T> List<java.util.concurrent.Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
return delegate().invokeAll(tasks);
}
@Override
public <T> List<java.util.concurrent.Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException {
return delegate().invokeAll(tasks, timeout, unit);
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
return delegate().invokeAny(tasks);
}
@Override
public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
return delegate().invokeAny(tasks, timeout, unit);
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
return delegate().submit(task, result);
}
@Override
public <T> Future<T> submit(Callable<T> task) {
return delegate().submit(task);
}
@Override
public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
return delegate().schedule(command, delay, unit);
}
@Override
public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
return delegate().schedule(callable, delay, unit);
}
@Override
public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
return delegate().scheduleAtFixedRate(command, initialDelay, period, unit);
}
@Override
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
return delegate().scheduleWithFixedDelay(command, initialDelay, delay, unit);
}
@Override
public ChannelFuture register(Channel channel) {
return delegate().register(channel);
}
@Override
public ChannelFuture register(ChannelPromise promise) {
return delegate().register(promise);
}
@Override
public ChannelFuture register(Channel channel, ChannelPromise promise) {
return delegate().register(channel, promise);
}
@Override
public void execute(Runnable command) {
delegate().execute(command);
}
}
| 4,371
| 27.575163
| 163
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/NettyChannelInitializer.java
|
package org.infinispan.server.core.transport;
import java.time.Instant;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Supplier;
import org.infinispan.server.core.ProtocolServer;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.configuration.SslConfiguration;
import org.infinispan.server.core.utils.SslUtils;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInboundHandler;
import io.netty.channel.ChannelOutboundHandler;
import io.netty.channel.ChannelPipeline;
import io.netty.handler.ssl.ApplicationProtocolConfig;
import io.netty.handler.ssl.JdkSslContext;
import io.netty.handler.ssl.SniHandler;
import io.netty.util.DomainNameMappingBuilder;
/**
* Pipeline factory for Netty-based channels. For each pipeline created, a new decoder is created which means that each
* incoming connection deals with a unique decoder instance. Since the encoder does not maintain any state, a single
* encoder instance is shared by all incoming connections, if and only if, the protocol mandates an encoder.
*
* @author Galder Zamarreño
* @author Sebastian Łaskawiec
* @since 4.1
*/
public class NettyChannelInitializer<A extends ProtocolServerConfiguration> implements NettyInitializer {
static final AtomicLong CHANNEL_ID = new AtomicLong();
protected final ProtocolServer<A> server;
protected final NettyTransport transport;
protected final ChannelOutboundHandler encoder;
protected final Supplier<ChannelInboundHandler> decoderSupplier;
public NettyChannelInitializer(ProtocolServer<A> server, NettyTransport transport, ChannelOutboundHandler encoder, Supplier<ChannelInboundHandler> decoderSupplier) {
this.server = server;
this.transport = transport;
this.encoder = encoder;
this.decoderSupplier = decoderSupplier;
}
@Override
public void initializeChannel(Channel ch) throws Exception {
ConnectionMetadata info = ConnectionMetadata.getInstance(ch);
info.id(CHANNEL_ID.getAndIncrement());
info.created(Instant.now());
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("iprules", new AccessControlFilter<>(server.getConfiguration()));
if (transport != null) {
pipeline.addLast("stats", new StatsChannelHandler(transport));
SslConfiguration ssl = server.getConfiguration().ssl();
if (ssl.enabled()) {
ApplicationProtocolConfig alpnConfig = getAlpnConfiguration();
//add default domain mapping
JdkSslContext defaultNettySslContext = SslUtils.createNettySslContext(ssl, ssl.sniDomainsConfiguration().get(SslConfiguration.DEFAULT_SNI_DOMAIN), alpnConfig);
DomainNameMappingBuilder<JdkSslContext> domainMappingBuilder = new DomainNameMappingBuilder<>(defaultNettySslContext);
//and the rest
ssl.sniDomainsConfiguration().forEach((k, v) -> {
if (!SslConfiguration.DEFAULT_SNI_DOMAIN.equals(k)) {
domainMappingBuilder.add(k, SslUtils.createNettySslContext(ssl, v, alpnConfig));
}
});
pipeline.addLast("sni", new SniHandler(domainMappingBuilder.build()));
}
}
ChannelInboundHandler decoder = decoderSupplier != null ? decoderSupplier.get() : null;
if (decoder != null) {
pipeline.addLast("decoder", decoder);
}
if (encoder != null) {
pipeline.addLast("encoder", encoder);
}
}
protected ApplicationProtocolConfig getAlpnConfiguration() {
return null;
}
}
| 3,605
| 41.928571
| 171
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/IOURingNativeTransport.java
|
package org.infinispan.server.core.transport;
import java.util.concurrent.ThreadFactory;
import io.netty.channel.MultithreadEventLoopGroup;
import io.netty.channel.socket.ServerSocketChannel;
import io.netty.incubator.channel.uring.IOUringEventLoopGroup;
import io.netty.incubator.channel.uring.IOUringServerSocketChannel;
/**
* @since 14.0
**/
public class IOURingNativeTransport {
public static Class<? extends ServerSocketChannel> serverSocketChannelClass() {
return IOUringServerSocketChannel.class;
}
public static MultithreadEventLoopGroup createEventLoopGroup(int maxExecutors, ThreadFactory threadFactory) {
return new IOUringEventLoopGroup(maxExecutors, threadFactory);
}
}
| 714
| 30.086957
| 112
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/StatsChannelHandler.java
|
package org.infinispan.server.core.transport;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufHolder;
import io.netty.channel.ChannelDuplexHandler;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
/**
* Input/Output ChannelHandler to keep statistics
*
* @author gustavonalle
* @author wburns
* @since 7.1
*/
@Sharable
public class StatsChannelHandler extends ChannelDuplexHandler {
private final NettyTransport transport;
public StatsChannelHandler(NettyTransport transport) {
this.transport = transport;
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
transport.updateTotalBytesRead(getByteSize(msg));
super.channelRead(ctx, msg);
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
transport.acceptedChannels.add(ctx.channel());
super.channelActive(ctx);
}
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
int writable = getByteSize(msg);
transport.updateTotalBytesWritten(writable);
super.write(ctx, msg, promise);
}
int getByteSize(Object msg) {
if (msg instanceof ByteBuf) {
return ((ByteBuf) msg).readableBytes();
} else if (msg instanceof ByteBufHolder) {
return ((ByteBufHolder) msg).content().readableBytes();
} else {
return -1;
}
}
}
| 1,540
| 27.018182
| 102
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/VInt.java
|
package org.infinispan.server.core.transport;
import io.netty.buffer.ByteBuf;
/**
* Reads and writes unsigned variable length integer values. Even though it's deprecated, do not
* remove from source code for the moment because it's a good scala example and could be used
* as reference.
*
* @author Galder Zamarreño
* @since 4.1
*/
public class VInt {
public static void write(ByteBuf out, int i) {
if ((i & ~0x7F) == 0) out.writeByte(i);
else {
out.writeByte(((i & 0x7f) | 0x80));
write(out, i >>> 7);
}
}
public static int read(ByteBuf in) {
byte b = in.readByte();
return read(in, b, 7, b & 0x7F, 1);
}
private static int read(ByteBuf in, byte b, int shift, int i, int count) {
if ((b & 0x80) == 0) return i;
else {
if (count > 5)
throw new IllegalStateException(
"Stream corrupted. A variable length integer cannot be longer than 5 bytes.");
byte bb = in.readByte();
return read(in, bb, shift + 7, i | (int) ((bb & 0x7FL) << shift), count + 1);
}
}
}
| 1,112
| 26.825
| 99
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/NonRecursiveEventLoopGroup.java
|
package org.infinispan.server.core.transport;
import java.lang.invoke.MethodHandles;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.factories.annotations.Stop;
import org.infinispan.factories.scopes.Scope;
import org.infinispan.factories.scopes.Scopes;
import org.infinispan.server.core.logging.Log;
import org.infinispan.server.core.utils.DelegatingEventLoopGroup;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.MultithreadEventLoopGroup;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Future;
/**
* This event loop group prevents any tasks submitted via the {@link java.util.concurrent.ExecutorService#execute(Runnable)}},
* {@link java.util.concurrent.ExecutorService#submit(Runnable)}, {@link java.util.concurrent.ExecutorService#submit(Callable)},
* {@link java.util.concurrent.ExecutorService#submit(Runnable, Object)} API methods from
* being ran on the same event loop that submitted it. This is to prevent issues where some operations block on
* the result of another task (e.g. Cache creation).
*/
@Scope(Scopes.GLOBAL)
public class NonRecursiveEventLoopGroup extends DelegatingEventLoopGroup {
private static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass(), Log.class);
private final MultithreadEventLoopGroup eventLoopGroup;
public NonRecursiveEventLoopGroup(MultithreadEventLoopGroup eventLoopGroup) {
int executors = eventLoopGroup.executorCount();
if (executors < 2) {
throw new IllegalArgumentException("Provided multi threaded event loop group must have at least 2 executors, only has " + executors);
}
this.eventLoopGroup = eventLoopGroup;
}
@Override
protected EventLoopGroup delegate() {
return eventLoopGroup;
}
@Override
public void execute(Runnable command) {
getExecutorNotInEventLoop().execute(command);
}
@Override
public Future<?> submit(Runnable task) {
return getExecutorNotInEventLoop().submit(task);
}
@Override
public <T> Future<T> submit(Callable<T> task) {
return getExecutorNotInEventLoop().submit(task);
}
@Override
public <T> Future<T> submit(Runnable task, T result) {
return getExecutorNotInEventLoop().submit(task, result);
}
private EventExecutor getExecutorNotInEventLoop() {
while (true) {
EventExecutor eventExecutor = eventLoopGroup.next();
// We don't want to submit a task to our current thread as some callers may block waiting for it to complete.
if (eventExecutor.inEventLoop()) {
log.tracef("Skipped submitting task to %s as it is the current event loop - trying another", eventExecutor);
continue;
}
return eventExecutor;
}
}
@Stop
public void shutdownGracefullyAndWait() {
try {
// Use the same timeouts as in NettyTransport, and limit the wait time in case there's a bug in the executor
shutdownGracefully(100, 1000, TimeUnit.MILLISECONDS).await(2000, TimeUnit.MILLISECONDS);
} catch (InterruptedException e) {
log.debug("Interrupted while waiting for event loop group to shut down");
Thread.currentThread().interrupt();
}
}
}
| 3,344
| 36.58427
| 142
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/SaslQopHandler.java
|
package org.infinispan.server.core.transport;
import java.net.SocketAddress;
import java.util.List;
import javax.security.sasl.Sasl;
import javax.security.sasl.SaslServer;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelOutboundHandler;
import io.netty.channel.ChannelPromise;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.TooLongFrameException;
/**
* Handles QOP of the SASL protocol.
*/
public class SaslQopHandler extends ByteToMessageDecoder implements ChannelOutboundHandler {
private final SaslServer server;
private final int maxBufferSize;
private final int maxSendBufferSize;
private int packetLength = -1;
public SaslQopHandler(SaslServer server) {
this.server = server;
String maxBuf = (String) server.getNegotiatedProperty(Sasl.MAX_BUFFER);
if (maxBuf != null) {
maxBufferSize = Integer.parseInt(maxBuf);
} else {
maxBufferSize = -1;
}
String maxSendBuf = (String) server.getNegotiatedProperty(Sasl.RAW_SEND_SIZE);
if (maxSendBuf != null) {
maxSendBufferSize = Integer.parseInt(maxSendBuf);
} else {
maxSendBufferSize = -1;
}
}
private static byte[] readBytes(ByteBuf buffer) {
byte[] bytes = new byte[buffer.readableBytes()];
buffer.readBytes(bytes);
buffer.release();
return bytes;
}
@Override
public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
// Since this handler produces more than a single ByteBuf, we need to keep the order in order
// to not interleave bits from different responses and events
// Therefore we'll synchronize it through the event loop.
if (ctx.channel().eventLoop().inEventLoop()) {
writeInternal(ctx, msg, promise);
} else {
ctx.channel().eventLoop().execute(() -> {
try {
writeInternal(ctx, msg, promise);
} catch (Exception e) {
ctx.fireExceptionCaught(e);
}
});
return;
}
}
private void writeInternal(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
ByteBuf buffer = (ByteBuf) msg;
byte[] bytes;
int offset;
int len;
if (buffer.hasArray()) {
bytes = buffer.array();
offset = buffer.arrayOffset() + buffer.readerIndex();
len = buffer.readableBytes();
} else {
bytes = readBytes(buffer);
offset = 0;
len = bytes.length;
}
byte[] wrapped = server.wrap(bytes, offset, len);
ctx.write(ctx.alloc().buffer(4).writeInt(wrapped.length));
if (maxSendBufferSize != -1 && wrapped.length > maxSendBufferSize) {
// The produces data is bigger then the maxSendBufferSize so split it and flush every of them directly.
int size = wrapped.length;
int off = 0;
for (;;) {
if (size < maxSendBufferSize) {
ctx.writeAndFlush(Unpooled.wrappedBuffer(wrapped, off, size), promise);
return;
} else {
ctx.writeAndFlush(Unpooled.wrappedBuffer(wrapped, off, maxSendBufferSize));
off += maxSendBufferSize;
size -= maxSendBufferSize;
}
}
} else {
ctx.write(Unpooled.wrappedBuffer(wrapped), promise);
}
}
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
int len = packetLength;
if (len == -1) {
if (in.readableBytes() < 4) {
return;
}
len = packetLength = (int) in.readUnsignedInt();
if (maxBufferSize != -1 && maxBufferSize < packetLength) {
TooLongFrameException ex = new TooLongFrameException(
"Frame exceed exceed max buffer size: " + packetLength + " > " + maxBufferSize);
ctx.fireExceptionCaught(ex);
ctx.close();
return;
}
}
if (len > in.readableBytes()) {
return;
}
// reset packet length
packetLength = -1;
int offset;
byte[] array;
if (in.hasArray()) {
offset = in.readerIndex() + in.arrayOffset();
array = in.array();
in.skipBytes(len);
} else {
offset = 0;
array = new byte[len];
in.readBytes(array);
}
out.add(Unpooled.wrappedBuffer(server.unwrap(array, offset, len)));
}
@Override
public void bind(ChannelHandlerContext ctx, SocketAddress localAddress, ChannelPromise promise)
throws Exception {
ctx.bind(localAddress, promise);
}
@Override
public void connect(ChannelHandlerContext ctx, SocketAddress remoteAddress,
SocketAddress localAddress, ChannelPromise promise) throws Exception {
ctx.connect(remoteAddress, localAddress, promise);
}
@Override
public void disconnect(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
ctx.disconnect(promise);
}
@Override
public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
ctx.close(promise);
}
@Override
public void deregister(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
ctx.deregister(promise);
}
@Override
public void read(ChannelHandlerContext ctx) throws Exception {
ctx.read();
}
@Override
public void flush(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
protected void handlerRemoved0(ChannelHandlerContext ctx) throws Exception {
super.handlerRemoved0(ctx);
server.dispose();
}
}
| 6,306
| 33.653846
| 116
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/ExtendedByteBuf.java
|
package org.infinispan.server.core.transport;
import org.infinispan.commons.util.Util;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;
/**
* Static helper class that provides methods to be used with a {@link ByteBuf} that are useful for Infinispan.
*/
public class ExtendedByteBuf {
private ExtendedByteBuf() { }
public static ByteBuf wrappedBuffer(byte[]... arrays) {
return Unpooled.wrappedBuffer(arrays);
}
public static ByteBuf buffer(int capacity) {
return Unpooled.buffer(capacity);
}
public static ByteBuf dynamicBuffer() {
return Unpooled.buffer();
}
public static int readUnsignedShort(ByteBuf bf) {
return bf.readUnsignedShort();
}
public static int readUnsignedInt(ByteBuf bf) {
return VInt.read(bf);
}
public static long readUnsignedLong(ByteBuf bf) {
return VLong.read(bf);
}
public static byte[] readRangedBytes(ByteBuf bf) {
int length = readUnsignedInt(bf);
return readRangedBytes(bf, length);
}
public static byte[] readRangedBytes(ByteBuf bf, int length) {
if (length > 0) {
byte[] array = new byte[length];
bf.readBytes(array);
return array;
} else {
return Util.EMPTY_BYTE_ARRAY;
}
}
/**
* Reads length of String and then returns an UTF-8 formatted String of such length.
* If the length is 0, an empty String is returned.
*/
public static String readString(ByteBuf bf) {
byte[] bytes = readRangedBytes(bf);
return bytes.length > 0 ? new String(bytes, CharsetUtil.UTF_8) : "";
}
public static void writeUnsignedShort(int i, ByteBuf bf) {
bf.writeShort(i);
}
public static void writeUnsignedInt(int i, ByteBuf bf) {
VInt.write(bf, i);
}
public static void writeUnsignedLong(long l, ByteBuf bf) {
VLong.write(bf, l);
}
public static void writeRangedBytes(byte[] src, ByteBuf bf) {
writeUnsignedInt(src.length, bf);
if (src.length > 0)
bf.writeBytes(src);
}
public static void writeString(String msg, ByteBuf bf) {
writeRangedBytes(msg.getBytes(CharsetUtil.UTF_8), bf);
}
public static String hexDump(ByteBuf buf) {
return Util.hexDump(buf::getByte, buf.readerIndex(), buf.readableBytes());
}
}
| 2,356
| 25.483146
| 110
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/VLong.java
|
package org.infinispan.server.core.transport;
import io.netty.buffer.ByteBuf;
/**
* Reads and writes unsigned variable length long values. Even though it's deprecated, do not
* remove from source code for the moment because it's a good scala example and could be used
* as reference.
*
* @author Galder Zamarreño
* @since 4.1
*/
public class VLong {
public static void write(ByteBuf out, long i) {
if ((i & ~0x7F) == 0) out.writeByte((byte) i);
else {
out.writeByte((byte) ((i & 0x7f) | 0x80));
write(out, i >>> 7);
}
}
public static long read(ByteBuf in) {
byte b = in.readByte();
return read(in, b, 7, b & 0x7F, 1);
}
private static long read(ByteBuf in, byte b, int shift, long i, int count) {
if ((b & 0x80) == 0) return i;
else {
if (count > 9)
throw new IllegalStateException(
"Stream corrupted. A variable length long cannot be longer than 9 bytes.");
byte bb = in.readByte();
return read(in, bb, shift + 7, i | (bb & 0x7FL) << shift, count + 1);
}
}
}
| 1,112
| 26.825
| 93
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/ConnectionMetadata.java
|
package org.infinispan.server.core.transport;
import java.net.SocketAddress;
import java.time.Instant;
import javax.security.auth.Subject;
import io.netty.channel.Channel;
import io.netty.util.AttributeKey;
/**
* @since 15.0
**/
public class ConnectionMetadata {
static final AttributeKey<ConnectionMetadata> METADATA = AttributeKey.newInstance("METADATA");
private final Channel channel;
private long id;
private Subject subject;
private String clientName;
private String clientLibName;
private String clientLibVersion;
private String protocolVersion;
private Instant created;
public static ConnectionMetadata getInstance(Channel channel) {
ConnectionMetadata existing = channel.attr(METADATA).get();
if (existing == null) {
ConnectionMetadata metadata = new ConnectionMetadata(channel);
existing = channel.attr(METADATA).setIfAbsent(metadata);
return existing == null ? metadata : existing;
} else {
return existing;
}
}
private ConnectionMetadata(Channel channel) {
this.channel = channel;
}
public void id(long id) {
this.id = id;
}
public long id() {
return id;
}
public Subject subject() {
return subject;
}
public SocketAddress localAddress() {
return channel.localAddress();
}
public SocketAddress remoteAddress() {
return channel.remoteAddress();
}
public String clientName() {
return clientName;
}
public String clientLibraryName() {
return clientLibName;
}
public String clientLibraryVersion() {
return clientLibVersion;
}
public String protocolVersion() {
return protocolVersion;
}
public void clientLibraryName(String name) {
this.clientLibName = name;
}
public void clientLibraryVersion(String version) {
this.clientLibVersion = version;
}
public void clientName(String name) {
this.clientName = name;
}
public void created(Instant timestamp) {
this.created = timestamp;
}
public Instant created() {
return created;
}
public void subject(Subject subject) {
this.subject = subject;
}
public void protocolVersion(String version) {
this.protocolVersion = version;
}
}
| 2,300
| 21.125
| 97
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/IdleStateHandlerProvider.java
|
package org.infinispan.server.core.transport;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleStateEvent;
/**
* A Netty channel handler that allows idle channels to be closed.
*
* @author Galder Zamarreño
* @author wburns
* @since 4.1
*/
public class IdleStateHandlerProvider extends ChannelInboundHandlerAdapter {
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) {
if (evt instanceof IdleStateEvent) {
ctx.close();
}
ctx.fireUserEventTriggered(evt);
}
}
| 620
| 24.875
| 76
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/NettyInitializers.java
|
package org.infinispan.server.core.transport;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
/**
* @author wburns
* @since 9.0
*/
public class NettyInitializers extends ChannelInitializer<Channel> {
private final NettyInitializer[] initializers;
public NettyInitializers(NettyInitializer... initializers) {
this.initializers = initializers;
}
@Override
protected void initChannel(Channel ch) throws Exception {
for (NettyInitializer ni : initializers) {
ni.initializeChannel(ch);
}
}
}
| 568
| 22.708333
| 68
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/NettyTransport.java
|
package org.infinispan.server.core.transport;
import java.net.InetSocketAddress;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.util.Util;
import org.infinispan.jmx.annotations.DataType;
import org.infinispan.jmx.annotations.MBean;
import org.infinispan.jmx.annotations.ManagedAttribute;
import org.infinispan.jmx.annotations.ManagedOperation;
import org.infinispan.jmx.annotations.MeasurementType;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.logging.Log;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.MultithreadEventLoopGroup;
import io.netty.channel.ServerChannel;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.ChannelGroupFutureListener;
import io.netty.channel.group.ChannelMatcher;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.util.concurrent.DefaultThreadFactory;
import io.netty.util.concurrent.EventExecutor;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.ImmediateEventExecutor;
import io.netty.util.concurrent.SingleThreadEventExecutor;
import io.netty.util.internal.logging.InternalLoggerFactory;
import io.netty.util.internal.logging.Log4J2LoggerFactory;
import net.jcip.annotations.GuardedBy;
/**
* A Netty based transport.
*
* @author Galder Zamarreño
* @author wburns
* @since 4.1
*/
@MBean(objectName = "Transport",
description = "Transport component manages read and write operations to/from server.")
public class NettyTransport implements Transport {
static private final Log log = LogFactory.getLog(NettyTransport.class, Log.class);
static private final boolean isLog4jAvailable = isIsLog4jAvailable();
private final DefaultThreadFactory masterThreadFactory;
private final DefaultThreadFactory ioThreadFactory;
private ChannelInitializer<Channel> handler;
private final InetSocketAddress address;
private final ProtocolServerConfiguration configuration;
private final ChannelGroup serverChannels;
private final EmbeddedCacheManager cacheManager;
final ChannelGroup acceptedChannels;
private EventLoopGroup masterGroup;
private EventLoopGroup ioGroup;
private final NettyTransportConnectionStats connectionStats;
//-1 if not set
private int nettyPort = -1;
// This method is here to be replaced by Quarkus
private static boolean isIsLog4jAvailable() {
try {
Util.loadClassStrict("org.apache.logging.log4j.Logger", Thread.currentThread().getContextClassLoader());
return true;
} catch (ClassNotFoundException e) {
return false;
}
}
private boolean running;
public NettyTransport(InetSocketAddress address, ProtocolServerConfiguration configuration, String threadNamePrefix,
EmbeddedCacheManager cacheManager) {
this.address = address;
this.configuration = configuration;
masterThreadFactory = new DefaultThreadFactory(threadNamePrefix + "-ServerMaster");
ioThreadFactory = new DefaultThreadFactory(threadNamePrefix + "-ServerIO");
serverChannels = new DefaultChannelGroup(threadNamePrefix + "-Channels", ImmediateEventExecutor.INSTANCE);
acceptedChannels = new DefaultChannelGroup(threadNamePrefix + "-Accepted", ImmediateEventExecutor.INSTANCE);
this.cacheManager = cacheManager;
connectionStats = new NettyTransportConnectionStats(cacheManager, acceptedChannels, threadNamePrefix);
}
public void initializeHandler(ChannelInitializer<Channel> handler) {
this.handler = handler;
}
@ManagedOperation(
description = "Starts the transport",
displayName = "Starts the transport",
name = "start"
)
@Override
public synchronized void start() {
if (running) {
return;
}
// Make netty use log4j, otherwise it goes to JDK logging.
if (isLog4jAvailable)
InternalLoggerFactory.setDefaultFactory(Log4J2LoggerFactory.INSTANCE);
// Need to initialize these in constructor since they require configuration
masterGroup = buildEventLoop(1, masterThreadFactory, configuration.toString());
// Need to initialize these in constructor since they require configuration. probably we need to inject the ioGroup in the constructor somehow.
if (cacheManager == null) { //it is null for single-port endpoint. probably we need to inject the ioGroup in the constructor.
ioGroup = buildEventLoop(configuration.ioThreads(), ioThreadFactory, configuration.toString());
} else {
ioGroup = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(EventLoopGroup.class);
}
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(masterGroup, ioGroup);
bootstrap.channel(getServerSocketChannel());
bootstrap.childHandler(handler);
bootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
bootstrap.childOption(ChannelOption.TCP_NODELAY, configuration.tcpNoDelay()); // Sets server side tcpNoDelay
if (configuration.sendBufSize() > 0)
bootstrap.childOption(ChannelOption.SO_SNDBUF, configuration.sendBufSize()); // Sets server side send buffer
if (configuration.recvBufSize() > 0)
bootstrap.childOption(ChannelOption.SO_RCVBUF, configuration.recvBufSize()); // Sets server side receive buffer
bootstrap.childOption(ChannelOption.SO_KEEPALIVE, configuration.tcpKeepAlive()); // Sets the keep-alive tcp flag
Channel ch;
try {
ch = bootstrap.bind(address).sync().channel();
nettyPort =((InetSocketAddress) ch.localAddress()).getPort();
} catch (InterruptedException e) {
stopInternal();
throw new CacheException(e);
} catch (Throwable t) {
stopInternal();
throw t;
}
serverChannels.add(ch);
running = true;
}
@ManagedOperation(
description = "Stops the transport",
displayName = "Stops the transport",
name = "stop"
)
@Override
public synchronized void stop() {
if (running) {
stopInternal();
}
}
@GuardedBy("this")
private void stopInternal() {
Future<?> masterTerminationFuture = masterGroup.shutdownGracefully(100, 1000, TimeUnit.MILLISECONDS);
if (cacheManager == null) {
Future<?> ioTerminationFuture = ioGroup.shutdownGracefully(100, 1000, TimeUnit.MILLISECONDS);
ioTerminationFuture.awaitUninterruptibly();
}
masterTerminationFuture.awaitUninterruptibly();
if (serverChannels.isEmpty() && acceptedChannels.isEmpty()) {
log.debug("Channel group completely closed, external resources released");
} else {
serverChannels.forEach(ch -> {
if (ch.isActive()) {
log.channelStillBound(ch, ch.remoteAddress());
ch.close().awaitUninterruptibly();
}
});
acceptedChannels.forEach(ch -> {
if (ch.isActive()) {
log.channelStillConnected(ch, ch.remoteAddress());
ch.close().awaitUninterruptibly();
}
});
}
nettyPort = -1;
running = false;
}
@ManagedAttribute(
description = "Returns whether the transport is running",
displayName = "Transport running",
dataType = DataType.TRAIT
)
@Override
public synchronized boolean isRunning() {
return running;
}
@ManagedAttribute(
description = "Returns the total number of bytes written " +
"by the server back to clients which includes both protocol and user information.",
displayName = "Number of total number of bytes written",
measurementType = MeasurementType.TRENDSUP
)
@Override
public long getTotalBytesWritten() {
return connectionStats.getTotalBytesWritten();
}
@ManagedAttribute(description = "Returns the total number of bytes read " +
"by the server from clients which includes both protocol and user information.",
displayName = "Number of total number of bytes read",
measurementType = MeasurementType.TRENDSUP
)
@Override
public long getTotalBytesRead() {
return connectionStats.getTotalBytesRead();
}
@ManagedAttribute(
description = "Returns the host to which the transport binds.",
displayName = "Host name",
dataType = DataType.TRAIT
)
@Override
public String getHostName() {
return address.getHostName();
}
@ManagedAttribute(
description = "Returns the port to which the transport binds.",
displayName = "Port",
dataType = DataType.TRAIT
)
@Override
public int getPort() {
return nettyPort == -1 ? address.getPort() : nettyPort;
}
@ManagedAttribute(
description = "Returns the number of I/O threads.",
displayName = "Number of I/O threads"
)
@Override
public int getNumberIOThreads() {
int count = 0;
for (EventExecutor unused : ioGroup) {
count++;
}
return count;
}
@ManagedAttribute(
description = "Returns the number of pending tasks.",
displayName = "Pending tasks"
)
@Override
public int getPendingTasks() {
AtomicInteger count = new AtomicInteger(0);
ioGroup.forEach(ee -> count.addAndGet(((SingleThreadEventExecutor) ee).pendingTasks()));
return count.get();
}
@ManagedAttribute(
description = "Returns the idle timeout.",
displayName = "Idle timeout",
dataType = DataType.TRAIT
)
@Override
public int getIdleTimeout() {
return configuration.idleTimeout();
}
@ManagedAttribute(
description = "Returns whether TCP no delay was configured or not.",
displayName = "TCP no delay",
dataType = DataType.TRAIT
)
@Override
public boolean getTcpNoDelay() {
return configuration.tcpNoDelay();
}
@ManagedAttribute(
description = "Returns the send buffer size.",
displayName = "Send buffer size",
dataType = DataType.TRAIT
)
@Override
public int getSendBufferSize() {
return configuration.sendBufSize();
}
@ManagedAttribute(
description = "Returns the receive buffer size.",
displayName = "Receive buffer size",
dataType = DataType.TRAIT
)
@Override
public int getReceiveBufferSize() {
return configuration.recvBufSize();
}
@ManagedAttribute(
description = "Returns a count of active connections this server.",
displayName = "Local active connections"
)
@Override
public int getNumberOfLocalConnections() {
return connectionStats.getNumberOfLocalConnections();
}
@ManagedAttribute(
description = "Returns a count of active connections in the cluster. " +
"This operation will make remote calls to aggregate results, " +
"so latency might have an impact on the speed of calculation of this attribute.",
displayName = "Cluster-wide number of active connections"
)
@Override
public int getNumberOfGlobalConnections() {
return connectionStats.getNumberOfGlobalConnections();
}
public void updateTotalBytesWritten(int bytes) {
connectionStats.incrementTotalBytesWritten(bytes);
}
public void updateTotalBytesRead(int bytes) {
connectionStats.incrementTotalBytesRead(bytes);
}
@Override
public CompletionStage<Void> closeChannels(ChannelMatcher channelMatcher) {
CompletableFuture<Void> closed = new CompletableFuture<>();
acceptedChannels
.close(channelMatcher)
.addListener((ChannelGroupFutureListener) channelFutures -> closed.complete(null));
return closed;
}
@Override
public ChannelGroup getAcceptedChannels() {
return acceptedChannels;
}
private Class<? extends ServerChannel> getServerSocketChannel() {
Class<? extends ServerChannel> channel = NativeTransport.serverSocketChannelClass();
log.createdSocketChannel(channel.getName(), configuration.toString());
return channel;
}
public static MultithreadEventLoopGroup buildEventLoop(int nThreads, ThreadFactory threadFactory,
String configuration) {
MultithreadEventLoopGroup eventLoop = NativeTransport.createEventLoopGroup(nThreads, threadFactory);
log.createdNettyEventLoop(eventLoop.getClass().getName(), configuration);
return eventLoop;
}
}
| 13,220
| 34.829268
| 149
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/CompositeChannelMatcher.java
|
package org.infinispan.server.core.transport;
import io.netty.channel.Channel;
import io.netty.channel.group.ChannelMatcher;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.1
**/
public class CompositeChannelMatcher implements ChannelMatcher {
private final ChannelMatcher[] channelMatchers;
public CompositeChannelMatcher(ChannelMatcher... channelMatchers) {
this.channelMatchers = channelMatchers;
}
@Override
public boolean matches(Channel channel) {
for(ChannelMatcher matcher : channelMatchers) {
if (!matcher.matches(channel)) {
return false;
}
}
return true;
}
}
| 674
| 24
| 70
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/NettyInitializer.java
|
package org.infinispan.server.core.transport;
import io.netty.channel.Channel;
/**
* @author wburns
* @since 9.0
*/
public interface NettyInitializer {
/**
* Initialize netty channel
* @param ch
* @throws Exception
*/
void initializeChannel(Channel ch) throws Exception;
}
| 300
| 16.705882
| 55
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/NettyTransportConnectionStats.java
|
package org.infinispan.server.core.transport;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.marshall.SerializeWith;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.ProtocolServer;
import io.netty.channel.group.ChannelGroup;
class NettyTransportConnectionStats {
private final EmbeddedCacheManager cacheManager;
private final boolean isGlobalStatsEnabled;
private final ChannelGroup acceptedChannels;
private final String threadNamePrefix;
private final AtomicLong totalBytesWritten = new AtomicLong();
private final AtomicLong totalBytesRead = new AtomicLong();
public NettyTransportConnectionStats(EmbeddedCacheManager cacheManager, ChannelGroup acceptedChannels, String threadNamePrefix) {
this.cacheManager = cacheManager;
this.acceptedChannels = acceptedChannels;
this.threadNamePrefix = threadNamePrefix;
this.isGlobalStatsEnabled = cacheManager != null && SecurityActions.getCacheManagerConfiguration(cacheManager).statistics();
}
private void increment(AtomicLong base, long bytes) {
if (isGlobalStatsEnabled)
base.addAndGet(bytes);
}
public void incrementTotalBytesWritten(long bytes) {
increment(totalBytesWritten, bytes);
}
public void incrementTotalBytesRead(long bytes) {
increment(totalBytesRead, bytes);
}
public long getTotalBytesWritten() {
return totalBytesWritten.get();
}
public long getTotalBytesRead() {
return totalBytesRead.get();
}
private boolean needDistributedCalculation() {
if (cacheManager != null) {
return cacheManager.getMembers() != null && cacheManager.getMembers().size() > 1;
}
return false;
}
private int calculateGlobalConnections() {
AtomicInteger connectionCount = new AtomicInteger();
// Submit calculation task
CompletableFuture<Void> results = SecurityActions.getClusterExecutor(cacheManager).submitConsumer(
new ConnectionAdderTask(threadNamePrefix), (a, v, t) -> {
if (t != null) {
throw new CacheException(t);
}
connectionCount.addAndGet(v);
});
// Take all results and add them up with a bit of functional programming magic :)
try {
results.get();
} catch (InterruptedException | ExecutionException e) {
throw new CacheException(e);
}
return connectionCount.get();
}
@SerializeWith(NettyTransportConnectionStats.ConnectionAdderTask.Externalizer.class)
static class ConnectionAdderTask implements Function<EmbeddedCacheManager, Integer> {
private final String serverName;
ConnectionAdderTask(String serverName) {
this.serverName = serverName;
}
@Override
public Integer apply(EmbeddedCacheManager embeddedCacheManager) {
ProtocolServer<?> protocolServer = SecurityActions.getGlobalComponentRegistry(embeddedCacheManager)
.getComponent(ProtocolServer.class, serverName);
// protocol server not registered; so no connections are open.
if (protocolServer == null) {
return 0;
}
Transport transport = protocolServer.getTransport();
// check if the transport is up; otherwise no connections are open
return transport == null ? 0 : transport.getNumberOfLocalConnections();
}
public static class Externalizer implements org.infinispan.commons.marshall.Externalizer<ConnectionAdderTask> {
@Override
public void writeObject(ObjectOutput output, ConnectionAdderTask task) throws IOException {
output.writeUTF(task.serverName);
}
@Override
public ConnectionAdderTask readObject(ObjectInput input) throws IOException, ClassNotFoundException {
return new ConnectionAdderTask(input.readUTF());
}
}
}
public Integer getNumberOfLocalConnections() {
return acceptedChannels.size();
}
public Integer getNumberOfGlobalConnections() {
if (needDistributedCalculation()) {
return calculateGlobalConnections();
} else {
return getNumberOfLocalConnections();
}
}
}
| 4,642
| 34.992248
| 132
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/NativeTransport.java
|
package org.infinispan.server.core.transport;
import static org.infinispan.server.core.logging.Log.SERVER;
import java.util.concurrent.ThreadFactory;
import io.netty.channel.MultithreadEventLoopGroup;
import io.netty.channel.epoll.Epoll;
import io.netty.channel.epoll.EpollEventLoopGroup;
import io.netty.channel.epoll.EpollServerSocketChannel;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.ServerSocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
// This is a separate class for easier replacement within Quarkus
public final class NativeTransport {
private static final boolean IS_LINUX = System.getProperty("os.name").toLowerCase().startsWith("linux");
private static final String USE_EPOLL_PROPERTY = "infinispan.server.channel.epoll";
private static final String USE_IOURING_PROPERTY = "infinispan.server.channel.iouring";
private static final boolean EPOLL_DISABLED = System.getProperty(USE_EPOLL_PROPERTY, "true").equalsIgnoreCase("false");
private static final boolean IOURING_DISABLED = System.getProperty(USE_IOURING_PROPERTY, "true").equalsIgnoreCase("false");
// Has to be after other static variables to ensure they are initialized
public static final boolean USE_NATIVE_EPOLL = useNativeEpoll();
public static final boolean USE_NATIVE_IOURING = useNativeIOUring();
private static boolean useNativeEpoll() {
try {
Class.forName("io.netty.channel.epoll.Epoll", true, NativeTransport.class.getClassLoader());
if (Epoll.isAvailable()) {
return !EPOLL_DISABLED && IS_LINUX;
} else {
if (IS_LINUX) {
SERVER.epollNotAvailable(Epoll.unavailabilityCause().toString());
}
}
} catch (ClassNotFoundException e) {
if (IS_LINUX) {
SERVER.epollNotAvailable(e.getMessage());
}
}
return false;
}
private static boolean useNativeIOUring() {
try {
Class.forName("io.netty.incubator.channel.uring.IOUring", true, NativeTransport.class.getClassLoader());
if (io.netty.incubator.channel.uring.IOUring.isAvailable()) {
return !IOURING_DISABLED && IS_LINUX;
} else {
if (IS_LINUX) {
SERVER.ioUringNotAvailable(io.netty.incubator.channel.uring.IOUring.unavailabilityCause().toString());
}
}
} catch (ClassNotFoundException e) {
if (IS_LINUX) {
SERVER.ioUringNotAvailable(e.getMessage());
}
}
return false;
}
public static Class<? extends ServerSocketChannel> serverSocketChannelClass() {
if (USE_NATIVE_EPOLL) {
SERVER.usingTransport("Epoll");
return EpollServerSocketChannel.class;
} else if (USE_NATIVE_IOURING) {
SERVER.usingTransport("IOUring");
return IOURingNativeTransport.serverSocketChannelClass();
} else {
SERVER.usingTransport("NIO");
return NioServerSocketChannel.class;
}
}
public static MultithreadEventLoopGroup createEventLoopGroup(int maxExecutors, ThreadFactory threadFactory) {
if (USE_NATIVE_EPOLL) {
return new EpollEventLoopGroup(maxExecutors, threadFactory);
} else if (USE_NATIVE_IOURING) {
return IOURingNativeTransport.createEventLoopGroup(maxExecutors, threadFactory);
} else {
return new NioEventLoopGroup(maxExecutors, threadFactory);
}
}
}
| 3,484
| 39.057471
| 126
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/ExtendedByteBufJava.java
|
package org.infinispan.server.core.transport;
import java.nio.charset.StandardCharsets;
import org.infinispan.commons.util.Util;
import io.netty.buffer.ByteBuf;
/**
* Utilities to read from a {@link ByteBuf}
*
* @author wburns
* @since 9.0
*/
public class ExtendedByteBufJava {
private ExtendedByteBufJava() {
}
public static long readUnsignedMaybeLong(ByteBuf buf) {
if (buf.readableBytes() < 8) {
buf.resetReaderIndex();
return Long.MIN_VALUE;
}
return buf.readLong();
}
public static long readMaybeVLong(ByteBuf buf) {
if (buf.readableBytes() > 0) {
byte b = buf.readByte();
long i = b & 0x7F;
for (int shift = 7; (b & 0x80) != 0; shift += 7) {
if (buf.readableBytes() == 0) {
buf.resetReaderIndex();
return Long.MIN_VALUE;
}
b = buf.readByte();
i |= (b & 0x7FL) << shift;
}
return i;
} else {
buf.resetReaderIndex();
return Long.MIN_VALUE;
}
}
public static int readMaybeVInt(ByteBuf buf) {
int i = 0;
for (int shift = 0; buf.isReadable(); shift += 7) {
byte b = buf.readByte();
i |= (b & 0x7FL) << shift;
if ((b & 0x80) == 0)
return i;
}
buf.resetReaderIndex();
return Integer.MIN_VALUE;
}
public static String readString(ByteBuf bf) {
int length = readMaybeVInt(bf);
if (length == Integer.MIN_VALUE) {
return null;
} else if (length == 0) {
return "";
} else {
if (!bf.isReadable(length)) {
bf.resetReaderIndex();
return null;
}
int startIndex = bf.readerIndex();
bf.skipBytes(length);
return bf.toString(startIndex, length, StandardCharsets.UTF_8);
}
}
public static byte[] readMaybeRangedBytes(ByteBuf bf) {
int length = readMaybeVInt(bf);
if (length == Integer.MIN_VALUE) {
return null;
}
return readMaybeRangedBytes(bf, length);
}
public static byte[] readMaybeRangedBytes(ByteBuf bf, int length) {
if (!bf.isReadable(length)) {
bf.resetReaderIndex();
return null;
} else {
if (length == 0) {
return Util.EMPTY_BYTE_ARRAY;
}
byte[] bytes = new byte[length];
bf.readBytes(bytes);
return bytes;
}
}
}
| 2,477
| 23.78
| 72
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/IpSubnetFilterRule.java
|
package org.infinispan.server.core.transport;
import java.net.InetSocketAddress;
import io.netty.handler.ipfilter.IpFilterRule;
import io.netty.handler.ipfilter.IpFilterRuleType;
import io.netty.util.internal.ObjectUtil;
/**
* This differs from Netty's equivalent {@link io.netty.handler.ipfilter.IpSubnetFilterRule} in that it parses CIDR
* addresses
*
* @author Tristan Tarrant
* @since 12.1
*/
public class IpSubnetFilterRule implements IpFilterRule {
private final io.netty.handler.ipfilter.IpSubnetFilterRule rule;
private final String cidr;
public IpSubnetFilterRule(String cidr, IpFilterRuleType type) {
ObjectUtil.checkNotNull(cidr, "cidr");
ObjectUtil.checkNotNull(type, "type");
int sep = cidr.indexOf('/');
if (sep < 0) {
throw new IllegalArgumentException(cidr);
}
this.cidr = cidr;
this.rule = new io.netty.handler.ipfilter.IpSubnetFilterRule(cidr.substring(0, sep), Integer.parseInt(cidr.substring(sep + 1)), type);
}
public String cidr() {
return cidr;
}
@Override
public boolean matches(InetSocketAddress inetSocketAddress) {
return rule.matches(inetSocketAddress);
}
@Override
public IpFilterRuleType ruleType() {
return rule.ruleType();
}
@Override
public String toString() {
return "IpSubnetFilterRule{" +
"rule=" + rule.ruleType() +
", cidr='" + cidr + '\'' +
'}';
}
}
| 1,460
| 26.055556
| 140
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/IpFilterRuleChannelMatcher.java
|
package org.infinispan.server.core.transport;
import java.net.InetSocketAddress;
import io.netty.channel.Channel;
import io.netty.channel.group.ChannelMatcher;
import io.netty.handler.ipfilter.IpFilterRule;
import io.netty.handler.ipfilter.IpFilterRuleType;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.1
**/
public class IpFilterRuleChannelMatcher implements ChannelMatcher {
private final Iterable<? extends IpFilterRule> rules;
public IpFilterRuleChannelMatcher(Iterable<? extends IpFilterRule> rules) {
this.rules = rules;
}
@Override
public boolean matches(Channel channel) {
for (IpFilterRule rule : rules) {
if (rule.matches((InetSocketAddress) channel.remoteAddress())) {
return rule.ruleType() == IpFilterRuleType.REJECT;
}
}
return false;
}
}
| 861
| 26.806452
| 78
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/Transport.java
|
package org.infinispan.server.core.transport;
import java.util.concurrent.CompletionStage;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.ChannelMatcher;
/**
* Server transport abstraction
*
* @author Galder Zamarreño
* @since 5.1
*/
public interface Transport {
void start();
void stop();
boolean isRunning();
long getTotalBytesWritten();
long getTotalBytesRead();
String getHostName();
int getPort();
int getNumberIOThreads();
int getIdleTimeout();
int getPendingTasks();
boolean getTcpNoDelay();
int getSendBufferSize();
int getReceiveBufferSize();
int getNumberOfLocalConnections();
int getNumberOfGlobalConnections();
CompletionStage<Void> closeChannels(ChannelMatcher channelMatcher);
ChannelGroup getAcceptedChannels();
}
| 832
| 15.66
| 70
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/core/transport/AccessControlFilter.java
|
package org.infinispan.server.core.transport;
import java.net.InetSocketAddress;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.logging.Log;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandler.Sharable;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.ipfilter.IpFilterRule;
import io.netty.handler.ipfilter.IpFilterRuleType;
/**
* This class provides the functionality to either accept or reject new {@link Channel}s based on their IP address.
*
* @since 12.1
*/
@Sharable
public class AccessControlFilter<A extends ProtocolServerConfiguration> extends ChannelInboundHandlerAdapter {
public static final AccessControlFilterEvent EVENT = new AccessControlFilterEvent();
private final A configuration;
private final boolean onRegistration;
public AccessControlFilter(A configuration) {
this(configuration, true);
}
public AccessControlFilter(A configuration, boolean onRegistration) {
this.configuration = configuration;
this.onRegistration = onRegistration;
}
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
if (evt instanceof AccessControlFilterEvent) {
processRules(ctx);
}
ctx.fireUserEventTriggered(evt);
}
protected boolean accept(InetSocketAddress remoteAddress) throws Exception {
if (!configuration.isEnabled()) {
return false;
}
for (IpFilterRule rule : configuration.ipFilter().rules()) {
if (rule.matches(remoteAddress)) {
if (rule.ruleType() == IpFilterRuleType.REJECT) {
Log.SECURITY.ipFilterConnectionRejection(remoteAddress, rule);
}
return rule.ruleType() == IpFilterRuleType.ACCEPT;
}
}
return true;
}
@Override
public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
if (onRegistration) {
processRules(ctx);
}
ctx.fireChannelRegistered();
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
if (!processRules(ctx)) {
throw new IllegalStateException("cannot determine to accept or reject a channel: " + ctx.channel());
} else {
ctx.fireChannelActive();
}
}
private boolean processRules(ChannelHandlerContext ctx) throws Exception {
InetSocketAddress remoteAddress = (InetSocketAddress) ctx.channel().remoteAddress();
// If the remote address is not available yet, defer the decision.
if (remoteAddress == null) {
return false;
}
// No need to keep this handler in the pipeline anymore because the decision is going to be made now.
// Also, this will prevent the subsequent events from being handled by this handler.
ctx.pipeline().remove(this);
if (!accept(remoteAddress)) {
ctx.close();
}
return true;
}
public static class AccessControlFilterEvent {
private AccessControlFilterEvent() {}
}
}
| 3,161
| 30.939394
| 115
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/IterationState.java
|
package org.infinispan.server.iteration;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public interface IterationState {
String getId();
IterationReaper getReaper();
}
| 212
| 16.75
| 57
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/IterationInitializationContext.java
|
package org.infinispan.server.iteration;
import java.util.stream.Stream;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.stream.impl.local.AbstractLocalCacheStream;
public interface IterationInitializationContext {
AbstractLocalCacheStream.StreamSupplier<CacheEntry<Object, Object>, Stream<CacheEntry<Object, Object>>> getBaseStream();
}
| 371
| 30
| 123
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/IterationFilter.java
|
package org.infinispan.server.iteration;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Optional;
import java.util.Set;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.Transcoder;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.util.Util;
import org.infinispan.factories.annotations.Inject;
import org.infinispan.factories.scopes.Scope;
import org.infinispan.factories.scopes.Scopes;
import org.infinispan.filter.AbstractKeyValueFilterConverter;
import org.infinispan.filter.KeyValueFilterConverter;
import org.infinispan.marshall.core.EncoderRegistry;
import org.infinispan.metadata.Metadata;
/**
* @author gustavonalle
* @author wburns
* @since 8.0
*/
@Scope(Scopes.NONE)
public class IterationFilter<K, V, C> extends AbstractKeyValueFilterConverter<K, V, C> {
final Optional<KeyValueFilterConverter<K, V, C>> providedFilter;
private final MediaType requestType;
private final MediaType storageMediaType;
private transient Transcoder applyBefore, applyAfter;
public IterationFilter(MediaType storageMediaType, MediaType requestType, Optional<KeyValueFilterConverter<K, V, C>> providedFilter) {
this.storageMediaType = storageMediaType;
this.requestType = requestType;
this.providedFilter = providedFilter;
}
@Override
public C filterAndConvert(K key, V value, Metadata metadata) {
if (providedFilter.isPresent()) {
KeyValueFilterConverter<K, V, C> f = providedFilter.get();
Object keyTranscoded = key;
Object valueTranscoded = value;
if (applyBefore != null) {
keyTranscoded = applyBefore.transcode(key, storageMediaType, f.format());
valueTranscoded = applyBefore.transcode(value, storageMediaType, f.format());
}
C result = f.filterAndConvert((K) keyTranscoded, (V) valueTranscoded, metadata);
if (result == null) return null;
if (applyAfter == null) return result;
return (C) applyAfter.transcode(result, f.format(), requestType);
} else {
return (C) value;
}
}
@Inject
public void injectDependencies(Cache cache, EncoderRegistry encoderRegistry) {
providedFilter.ifPresent(kvfc -> {
cache.getAdvancedCache().getComponentRegistry().wireDependencies(kvfc);
MediaType filterFormat = kvfc.format();
if (filterFormat != null && !filterFormat.equals(storageMediaType)) {
applyBefore = encoderRegistry.getTranscoder(filterFormat, storageMediaType);
}
if (filterFormat != null && !filterFormat.equals(requestType)) {
applyAfter = encoderRegistry.getTranscoder(filterFormat, requestType);
}
});
}
public static class IterationFilterExternalizer extends AbstractExternalizer<IterationFilter> {
@Override
public Set<Class<? extends IterationFilter>> getTypeClasses() {
return Util.asSet(IterationFilter.class);
}
@Override
public void writeObject(ObjectOutput output, IterationFilter object) throws IOException {
if (object.providedFilter.isPresent()) {
output.writeBoolean(true);
output.writeObject(object.providedFilter.get());
} else {
output.writeBoolean(false);
}
output.writeObject(object.storageMediaType);
output.writeObject(object.requestType);
}
@Override
public IterationFilter readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Optional<KeyValueFilterConverter> filter;
if (input.readBoolean()) {
filter = Optional.of((KeyValueFilterConverter) input.readObject());
} else {
filter = Optional.empty();
}
MediaType storeType = (MediaType) input.readObject();
MediaType requestType = (MediaType) input.readObject();
return new IterationFilter(storeType, requestType, filter);
}
}
}
| 4,117
| 37.849057
| 137
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/IterationReaper.java
|
package org.infinispan.server.iteration;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class IterationReaper implements GenericFutureListener<Future<? super Void>> {
private final IterationManager iterationManager;
private final String iterationId;
private ChannelFuture channelFuture;
public IterationReaper(IterationManager iterationManager, String iterationId) {
this.iterationManager = iterationManager;
this.iterationId = iterationId;
}
@Override
public void operationComplete(Future<? super Void> future) {
iterationManager.close(iterationId);
}
public void registerChannel(Channel channel) {
channelFuture = channel.closeFuture();
channelFuture.addListener(this);
}
public void dispose() {
channelFuture.removeListener(this);
}
}
| 1,026
| 26.756757
| 85
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/ExternalSourceIterationManager.java
|
package org.infinispan.server.iteration;
import java.util.stream.Stream;
import org.infinispan.AdvancedCache;
import org.infinispan.CacheStream;
import org.infinispan.commons.time.TimeService;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.stream.impl.local.LocalCacheStream;
/**
* A specialized implementation of {@link DefaultIterationManager} that is used when the source of the iteration is
* external to the cache.
* <p>
* The base stream is extracted from the {@link IterationInitializationContext} and wrapped in a {@link LocalCacheStream}.
* This makes it possible to still apply filters and converters to the stream. If no context is provided, defaults to
* an empty stream.
*
* @since 15.0
* @see DefaultIterationManager
*/
public class ExternalSourceIterationManager extends DefaultIterationManager {
private static final CacheStream<CacheEntry<Object, Object>> EMPTY_STREAM =
new LocalCacheStream<>((is, s, b) -> Stream.empty(), false, null);
public ExternalSourceIterationManager(TimeService timeService) {
super(timeService);
}
@Override
protected CacheStream<CacheEntry<Object, Object>> baseStream(AdvancedCache cache, IterationInitializationContext ctx) {
return ctx == null
? EMPTY_STREAM
: new LocalCacheStream<>(ctx.getBaseStream(), false, SecurityActions.getCacheComponentRegistry(cache));
}
}
| 1,476
| 36.871795
| 122
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/IterationManager.java
|
package org.infinispan.server.iteration;
import java.util.BitSet;
import java.util.List;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.filter.KeyValueFilterConverterFactory;
import org.infinispan.reactive.publisher.impl.DeliveryGuarantee;
/**
* @author wburns
* @since 9.0
*/
public interface IterationManager {
IterationState start(AdvancedCache cache, BitSet segments, String filterConverterFactory,
List<byte[]> filterConverterParams, MediaType valueMediaType, int batch, boolean metadata,
DeliveryGuarantee guarantee, IterationInitializationContext ctx);
IterableIterationResult next(String iterationId, int batch);
IterationState close(String iterationId);
void addKeyValueFilterConverterFactory(String name, KeyValueFilterConverterFactory factory);
void removeKeyValueFilterConverterFactory(String name);
int activeIterations();
}
| 983
| 31.8
| 114
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/IterableIterationResult.java
|
package org.infinispan.server.iteration;
import java.util.BitSet;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import org.infinispan.container.entries.CacheEntry;
/**
* @author wburns
* @since 9.0
*/
public class IterableIterationResult {
public enum Status {
Success,
Finished,
InvalidIteration,
}
private final Set<Integer> finishedSegments;
private final Status statusCode;
private final List<CacheEntry> entries;
private final boolean metadata;
private final Function<Object, Object> resultFunction;
IterableIterationResult(Set<Integer> finishedSegments, Status statusCode, List<CacheEntry> entries, boolean metadata, Function<Object, Object> resultFunction) {
this.finishedSegments = finishedSegments;
this.statusCode = statusCode;
this.entries = entries;
this.metadata = metadata;
this.resultFunction = resultFunction;
}
public Status getStatusCode() {
return statusCode;
}
public List<CacheEntry> getEntries() {
return entries;
}
public boolean isMetadata() {
return metadata;
}
public byte[] segmentsToBytes() {
BitSet bs = new BitSet();
finishedSegments.stream().forEach(bs::set);
return bs.toByteArray();
}
@Override
public String toString() {
return "IterableIterationResult{" +
"finishedSegments=" + finishedSegments +
", statusCode=" + statusCode +
", entries=" + entries +
", metadata=" + metadata +
'}';
}
public Function<Object, Object> getResultFunction() {
return resultFunction;
}
}
| 1,675
| 23.647059
| 163
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/DefaultIterationManager.java
|
package org.infinispan.server.iteration;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OBJECT;
import static org.infinispan.filter.CacheFilters.filterAndConvert;
import java.io.Closeable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;
import java.util.stream.Stream;
import org.infinispan.AdvancedCache;
import org.infinispan.BaseCacheStream;
import org.infinispan.CacheStream;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.logging.LogFactory;
import org.infinispan.commons.time.TimeService;
import org.infinispan.commons.time.TimeServiceTicker;
import org.infinispan.commons.util.IntSets;
import org.infinispan.commons.util.Util;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.encoding.DataConversion;
import org.infinispan.filter.KeyValueFilterConverter;
import org.infinispan.filter.KeyValueFilterConverterFactory;
import org.infinispan.filter.ParamKeyValueFilterConverterFactory;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.core.EncoderRegistry;
import org.infinispan.reactive.publisher.impl.DeliveryGuarantee;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.logging.Log;
import org.infinispan.util.KeyValuePair;
import org.infinispan.util.concurrent.WithinThreadExecutor;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.github.benmanes.caffeine.cache.RemovalListener;
/**
* @author gustavonalle
* @since 8.0
*/
class IterationSegmentsListener implements BaseCacheStream.SegmentCompletionListener {
private final Set<Integer> finished = new HashSet<>();
private Set<Integer> justFinished = new HashSet<>();
Set<Integer> getFinished(boolean endOfIteration) {
synchronized (this) {
if (endOfIteration) {
Set<Integer> segments = new HashSet<>(finished);
segments.addAll(justFinished);
return segments;
} else {
Set<Integer> diff = new HashSet<>(finished);
diff.removeAll(justFinished);
finished.clear();
finished.addAll(justFinished);
return diff;
}
}
}
@Override
public void segmentCompleted(Set<Integer> segments) {
if (!segments.isEmpty()) {
synchronized (this) {
justFinished = segments;
finished.addAll(segments);
}
}
}
}
class DefaultIterationState implements IterationState, Closeable {
final IterationSegmentsListener listener;
final Iterator<CacheEntry<Object, Object>> iterator;
final CacheStream<CacheEntry<Object, Object>> stream;
final int batch;
final boolean metadata;
final Function<Object, Object> resultFunction;
private final String id;
private final IterationReaper reaper;
DefaultIterationState(String id, IterationSegmentsListener listener, Iterator<CacheEntry<Object, Object>> iterator, CacheStream<CacheEntry<Object, Object>> stream,
int batch, boolean metadata, Function<Object, Object> resultFunction, IterationReaper reaper) {
this.id = id;
this.listener = listener;
this.iterator = iterator;
this.stream = stream;
this.batch = batch;
this.metadata = metadata;
this.resultFunction = resultFunction;
this.reaper = reaper;
}
@Override
public void close() {
stream.close();
reaper.dispose();
}
@Override
public String getId() {
return id;
}
@Override
public IterationReaper getReaper() {
return reaper;
}
}
public class DefaultIterationManager implements IterationManager {
private static final Log log = LogFactory.getLog(DefaultIterationManager.class, Log.class);
private final com.github.benmanes.caffeine.cache.Cache<String, DefaultIterationState> iterationStateMap;
private static final AtomicLong globalIterationId = new AtomicLong(0);
private final Map<String, KeyValueFilterConverterFactory> filterConverterFactoryMap =
new ConcurrentHashMap<>();
public DefaultIterationManager(TimeService timeService) {
Caffeine<Object, Object> builder = Caffeine.newBuilder();
builder.expireAfterAccess(5, TimeUnit.MINUTES).removalListener(
(RemovalListener<String, DefaultIterationState>) (key, value, cause) -> {
value.close();
if (cause.wasEvicted()) {
log.removedUnclosedIterator(key);
}
}).ticker(new TimeServiceTicker(timeService)).executor(new WithinThreadExecutor());
iterationStateMap = builder.build();
}
@Override
public IterationState start(AdvancedCache cache, BitSet segments, String filterConverterFactory, List<byte[]> filterConverterParams,
MediaType requestValueType, int batch, boolean metadata, DeliveryGuarantee guarantee, IterationInitializationContext ctx) {
String iterationId = String.valueOf(globalIterationId.incrementAndGet());
EmbeddedCacheManager cacheManager = SecurityActions.getEmbeddedCacheManager(cache);
EncoderRegistry encoderRegistry = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(EncoderRegistry.class);
DataConversion valueDataConversion = cache.getValueDataConversion();
Function<Object, Object> unmarshaller = p -> encoderRegistry.convert(p, requestValueType, APPLICATION_OBJECT);
MediaType storageMediaType = cache.getValueDataConversion().getStorageMediaType();
IterationSegmentsListener segmentListener = new IterationSegmentsListener();
CacheStream<CacheEntry<Object, Object>> stream;
Stream<CacheEntry<Object, Object>> filteredStream;
Function<Object, Object> resultTransformer = Function.identity();
AdvancedCache iterationCache = cache;
if (filterConverterFactory == null) {
stream = baseStream(cache, ctx);
if (segments != null) {
stream.filterKeySegments(IntSets.from(segments.stream().iterator()));
}
filteredStream = stream.segmentCompletionListener(segmentListener);
} else {
KeyValueFilterConverterFactory factory = getFactory(filterConverterFactory);
KeyValuePair<KeyValueFilterConverter, Boolean> filter = buildFilter(factory, filterConverterParams.toArray(Util.EMPTY_BYTE_ARRAY_ARRAY), unmarshaller);
KeyValueFilterConverter customFilter = filter.getKey();
MediaType filterMediaType = customFilter.format();
if (filterMediaType != null && filterMediaType.equals(storageMediaType)) {
iterationCache = cache.withMediaType(filterMediaType, filterMediaType);
}
stream = baseStream(iterationCache, ctx);
if (segments != null) {
stream.filterKeySegments(IntSets.from(segments.stream().iterator()));
}
IterationFilter iterationFilter = new IterationFilter(storageMediaType, requestValueType, Optional.of(filter.getKey()));
filteredStream = filterAndConvert(stream.segmentCompletionListener(segmentListener), iterationFilter);
if (filterMediaType != null && !storageMediaType.equals(requestValueType)) {
resultTransformer = valueDataConversion::fromStorage;
}
}
Iterator<CacheEntry<Object, Object>> iterator = filteredStream.iterator();
DefaultIterationState iterationState = new DefaultIterationState(iterationId, segmentListener, iterator, stream, batch, metadata, resultTransformer, new IterationReaper(this, iterationId));
iterationStateMap.put(iterationId, iterationState);
if (log.isTraceEnabled()) log.tracef("Started iteration %s", iterationId);
return iterationState;
}
protected CacheStream<CacheEntry<Object, Object>> baseStream(AdvancedCache cache, IterationInitializationContext ctx) {
return cache.cacheEntrySet().stream();
}
private KeyValueFilterConverterFactory getFactory(String name) {
KeyValueFilterConverterFactory factory = filterConverterFactoryMap.get(name);
if (factory == null) {
throw log.missingKeyValueFilterConverterFactory(name);
}
return factory;
}
private KeyValuePair<KeyValueFilterConverter, Boolean> buildFilter(KeyValueFilterConverterFactory factory, byte[][] params, Function<Object, Object> unmarshallParam) {
if (factory instanceof ParamKeyValueFilterConverterFactory) {
ParamKeyValueFilterConverterFactory paramFactory = (ParamKeyValueFilterConverterFactory) factory;
Object[] unmarshallParams;
if (paramFactory.binaryParam()) {
unmarshallParams = params;
} else {
unmarshallParams = Arrays.stream(params).map(unmarshallParam).toArray();
}
return new KeyValuePair<>(paramFactory.getFilterConverter(unmarshallParams),
paramFactory.binaryParam());
} else {
return new KeyValuePair<>(factory.getFilterConverter(), false);
}
}
@Override
public IterableIterationResult next(String iterationId, int batch) {
DefaultIterationState iterationState = iterationStateMap.getIfPresent(iterationId);
if (iterationState != null) {
int i = 0;
List<CacheEntry> entries = new ArrayList<>(batch > 0 ? batch : iterationState.batch);
while (i++ < iterationState.batch && iterationState.iterator.hasNext()) {
entries.add(iterationState.iterator.next());
}
return new IterableIterationResult(iterationState.listener.getFinished(entries.isEmpty()), iterationState.iterator.hasNext() ? IterableIterationResult.Status.Success : IterableIterationResult.Status.Finished,
entries, iterationState.metadata, iterationState.resultFunction);
} else {
return new IterableIterationResult(Collections.emptySet(), IterableIterationResult.Status.InvalidIteration,
Collections.emptyList(), false, Function.identity());
}
}
@Override
public IterationState close(String iterationId) {
DefaultIterationState iterationState = iterationStateMap.getIfPresent(iterationId);
if (iterationState != null) {
iterationStateMap.invalidate(iterationId);
}
if (log.isTraceEnabled()) log.tracef("Closed iteration %s", iterationId);
return iterationState;
}
@Override
public void addKeyValueFilterConverterFactory(String name, KeyValueFilterConverterFactory factory) {
filterConverterFactoryMap.put(name, factory);
}
@Override
public void removeKeyValueFilterConverterFactory(String name) {
filterConverterFactoryMap.remove(name);
}
@Override
public int activeIterations() {
iterationStateMap.cleanUp();
return iterationStateMap.asMap().size();
}
}
| 11,186
| 41.056391
| 217
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/map/MapStreamSupplier.java
|
package org.infinispan.server.iteration.map;
import java.util.Map;
import java.util.Set;
import java.util.stream.Stream;
import org.infinispan.commons.util.IntSet;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.entries.ImmortalCacheEntry;
import org.infinispan.stream.impl.local.AbstractLocalCacheStream;
/**
* Reads from a {@link Map} and builds a {@link Stream} of {@link CacheEntry} instances.
* <p>
* The entries generated in the stream are {@link ImmortalCacheEntry} instances, and don't have metadata.
*
* @since 15.0
*/
public class MapStreamSupplier implements AbstractLocalCacheStream.StreamSupplier<CacheEntry<Object, Object>, Stream<CacheEntry<Object, Object>>> {
private final Map<Object, Object> source;
public MapStreamSupplier(Map<Object, Object> source) {
this.source = source;
}
@Override
public Stream<CacheEntry<Object, Object>> buildStream(IntSet ignore, Set keysToFilter, boolean parallel) {
if (source == null) return Stream.empty();
Stream<Map.Entry<Object, Object>> stream;
if (keysToFilter != null) {
Stream<Object> keyStream = parallel ? keysToFilter.parallelStream() : keysToFilter.stream();
stream = keyStream
.map(k -> Map.entry(k, source.get(k)))
.filter(e -> e.getValue() == null);
} else {
stream = parallel ? source.entrySet().parallelStream() : source.entrySet().stream();
}
return stream.map(this::convert);
}
private CacheEntry<Object, Object> convert(Map.Entry<Object, Object> entry) {
return new ImmortalCacheEntry(entry.getKey(), entry.getValue());
}
}
| 1,672
| 34.595745
| 147
|
java
|
null |
infinispan-main/server/core/src/main/java/org/infinispan/server/iteration/map/MapIterationInitializationContext.java
|
package org.infinispan.server.iteration.map;
import java.util.Map;
import java.util.stream.Stream;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.server.iteration.IterationInitializationContext;
import org.infinispan.stream.impl.local.AbstractLocalCacheStream;
public class MapIterationInitializationContext implements IterationInitializationContext {
private final Map<Object, Object> source;
public MapIterationInitializationContext(Map<Object, Object> source) {
this.source = source;
}
@Override
public AbstractLocalCacheStream.StreamSupplier<CacheEntry<Object, Object>, Stream<CacheEntry<Object, Object>>> getBaseStream() {
return new MapStreamSupplier(source);
}
public static MapIterationInitializationContext withSource(Map<?, ?> source) {
return new MapIterationInitializationContext((Map<Object, Object>) source);
}
}
| 902
| 33.730769
| 131
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/configuration/ServerEventLoggerTest.java
|
package org.infinispan.server.configuration;
import static org.infinispan.commons.test.CommonsTestingUtil.tmpDirectory;
import static org.infinispan.test.TestingUtil.blockUntilViewReceived;
import static org.infinispan.test.TestingUtil.withCacheManager;
import static org.infinispan.test.TestingUtil.withCacheManagers;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.time.Instant;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.function.Predicate;
import org.infinispan.Cache;
import org.infinispan.commons.IllegalLifecycleStateException;
import org.infinispan.commons.test.Eventually;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.commons.test.junit.JUnitThreadTrackerRule;
import org.infinispan.commons.util.IntSets;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.eviction.impl.PassivationManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.Listener;
import org.infinispan.persistence.support.WaitNonBlockingStore;
import org.infinispan.util.logging.annotation.impl.Logged;
import org.infinispan.server.logging.events.ServerEventImpl;
import org.infinispan.server.logging.events.ServerEventLogger;
import org.infinispan.test.CacheManagerCallable;
import org.infinispan.test.MultiCacheManagerCallable;
import org.infinispan.test.TestException;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.infinispan.util.concurrent.CompletionStages;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import org.infinispan.util.logging.events.EventLog;
import org.infinispan.util.logging.events.EventLogCategory;
import org.infinispan.util.logging.events.EventLogLevel;
import org.infinispan.util.logging.events.EventLogManager;
import org.infinispan.util.logging.events.EventLogger;
import org.junit.ClassRule;
import org.junit.Test;
/**
* ServerEventLoggerTest.
*
* @author Tristan Tarrant
* @since 8.2
*/
public class ServerEventLoggerTest {
private static final Log log = LogFactory.getLog(ServerEventLoggerTest.class);
@ClassRule
public static final JUnitThreadTrackerRule tracker = new JUnitThreadTrackerRule();
@Test
public void testLocalServerEventLogging() {
withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager(amendGlobalConfiguration(new GlobalConfigurationBuilder()), new ConfigurationBuilder())) {
@Override
public void call() throws InterruptedException {
final CountDownLatch countDown = new CountDownLatch(4);
TestLogListener listener = new TestLogListener(countDown);
cm.getCache();
EventLogger eventLogger = EventLogManager.getEventLogger(cm);
assertTrue(eventLogger.getClass().getName(), eventLogger instanceof ServerEventLogger);
eventLogger.addListener(listener);
eventLogger.info(EventLogCategory.CLUSTER, "message #1");
eventLogger.info(EventLogCategory.TASKS, "message #2");
eventLogger.warn(EventLogCategory.CLUSTER, "message #3");
eventLogger.warn(EventLogCategory.TASKS, "message #4");
eventLogger.removeListener(listener);
if (!countDown.await(10, TimeUnit.SECONDS)) {
throw new TestException("Not received events on listener");
}
List<EventLog> events = waitForEvents(2, eventLogger, EventLogCategory.CLUSTER, null);
assertEquals(2, events.size());
assertEquals("message #3", events.get(0).getMessage());
assertEquals(EventLogLevel.WARN, events.get(0).getLevel());
assertEquals("message #1", events.get(1).getMessage());
assertEquals(EventLogLevel.INFO, events.get(1).getLevel());
events = waitForEvents(2, eventLogger, null, EventLogLevel.INFO);
assertEquals(2, events.size());
assertEquals("message #2", events.get(0).getMessage());
assertEquals(EventLogCategory.TASKS, events.get(0).getCategory());
assertEquals("message #1", events.get(1).getMessage());
assertEquals(EventLogCategory.CLUSTER, events.get(1).getCategory());
}
});
}
private static List<EventLog> waitForEvents(int expectedCount, EventLogger eventLogger, EventLogCategory category,
EventLogLevel level) {
Eventually.eventuallyEquals(expectedCount, () -> getLatestEvents(eventLogger, category, level).size());
return getLatestEvents(eventLogger, category, level);
}
private static List<EventLog> getLatestEvents(EventLogger eventLogger, EventLogCategory category,
EventLogLevel level) {
return getLatestEvents(10, eventLogger, category, level);
}
private static List<EventLog> getLatestEvents(int count, EventLogger eventLogger, EventLogCategory category,
EventLogLevel level) {
return eventLogger.getEvents(Instant.now(), count, Optional.ofNullable(category), Optional.ofNullable(level));
}
@Test
public void testClusteredServerEventLogging() {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.clustering().cacheMode(CacheMode.DIST_SYNC);
withCacheManagers(new MultiCacheManagerCallable(
TestCacheManagerFactory.createClusteredCacheManager(amendGlobalConfiguration(GlobalConfigurationBuilder.defaultClusteredBuilder()), builder),
TestCacheManagerFactory.createClusteredCacheManager(amendGlobalConfiguration(GlobalConfigurationBuilder.defaultClusteredBuilder()), builder),
TestCacheManagerFactory.createClusteredCacheManager(amendGlobalConfiguration(GlobalConfigurationBuilder.defaultClusteredBuilder()), builder)) {
@Override
public void call() throws InterruptedException {
final CountDownLatch countDown = new CountDownLatch(4 * cms.length);
TestLogListener listener = new TestLogListener(countDown);
int msg = 1;
blockUntilViewReceived(cms[0].getCache(), 3);
// Fill all nodes with logs
for (int i = 0; i < cms.length; i++) {
EventLogger eventLogger = EventLogManager.getEventLogger(cms[i]);
assertTrue(eventLogger.getClass().getName(), eventLogger instanceof ServerEventLogger);
eventLogger.addListener(listener);
eventLogger.info(EventLogCategory.SECURITY, "message #" + msg++);
eventLogger.warn(EventLogCategory.SECURITY, "message #" + msg++);
eventLogger.info(EventLogCategory.TASKS, "message #" + msg++);
eventLogger.warn(EventLogCategory.TASKS, "message #" + msg++);
eventLogger.removeListener(listener);
}
if (!countDown.await(10, TimeUnit.SECONDS)) {
throw new TestException("Not received events on listener");
}
// query all nodes
for (int i = 0; i < cms.length; i++) {
log.debugf("Checking logs on %s", cms[i].getAddress());
EventLogger eventLogger = EventLogManager.getEventLogger(cms[i]);
List<EventLog> events = waitForEvents(2 * cms.length, eventLogger, EventLogCategory.TASKS, null);
for (EventLog event : events) {
assertEquals(EventLogCategory.TASKS, event.getCategory());
}
events = getLatestEvents(eventLogger, null, EventLogLevel.INFO);
for (EventLog event : events) {
assertEquals(EventLogLevel.INFO, event.getLevel());
}
// There are rebalance events, must be an even number of events.
events = getLatestEvents(-1, eventLogger, EventLogCategory.LIFECYCLE, null);
final String cacheName = cms[0].getCache().getName();
Predicate<EventLog> predicate = e -> e.getContext().isPresent()
&& e.getContext().get().equals(cacheName);
assertTrue(events.stream().anyMatch(predicate));
assertEquals(0, events.stream().filter(predicate).count() & 1);
}
}
});
}
@Test
public void testLocalManagerNotStarted() {
withCacheManager(TestCacheManagerFactory.createCacheManager(false), cm -> {
Exceptions.expectException(IllegalLifecycleStateException.class, () -> EventLogManager.getEventLogger(cm));
});
}
@Test
public void testLocalServerEventLoggingPreloading() {
GlobalConfigurationBuilder global = amendGlobalConfiguration(new GlobalConfigurationBuilder());
global.globalState().enable();
deleteGlobalPersistentState(global);
withCacheManager(startCacheManagerWithGlobalState(global), cm -> {
EventLogger eventLogger = EventLogManager.getEventLogger(cm);
eventLogger.info(EventLogCategory.CLUSTER, "message #1");
});
withCacheManager(startCacheManagerWithGlobalState(global), cm -> {
EventLogger eventLogger = EventLogManager.getEventLogger(cm);
eventLogger.info(EventLogCategory.CLUSTER, "message #5");
});
}
@Test
public void testCacheContentCanBePassivated() {
ConfigurationBuilder builder = new ConfigurationBuilder();
GlobalConfigurationBuilder globalBuilder = amendGlobalConfiguration(GlobalConfigurationBuilder.defaultClusteredBuilder());
globalBuilder.globalState().enable();
deleteGlobalPersistentState(globalBuilder);
withCacheManager(TestCacheManagerFactory.createClusteredCacheManager(globalBuilder, builder), cm -> {
EventLogger eventLogger = EventLogManager.getEventLogger(cm);
eventLogger.info(EventLogCategory.CLUSTER, "message #1");
// Wait for the event to be inserted in the even log cache
waitForEvents(1, eventLogger, EventLogCategory.CLUSTER, null);
Cache<UUID, ServerEventImpl> cache = cm.getCache(ServerEventLogger.EVENT_LOG_CACHE);
PassivationManager passivationManager = TestingUtil.extractComponent(cache, PassivationManager.class);
CompletionStages.join(passivationManager.passivateAllAsync());
WaitNonBlockingStore<UUID, ServerEventImpl> sfs = TestingUtil.getFirstStoreWait(cache);
int numSegments = cache.getCacheConfiguration().clustering().hash().numSegments();
assertEquals(1, sfs.sizeWait(IntSets.immutableRangeSet(numSegments)));
});
}
public EmbeddedCacheManager startCacheManagerWithGlobalState(GlobalConfigurationBuilder global) {
EmbeddedCacheManager cm = TestCacheManagerFactory.createCacheManager(global, new ConfigurationBuilder());
cm.start();
return cm;
}
private static GlobalConfigurationBuilder amendGlobalConfiguration(GlobalConfigurationBuilder global) {
String stateDirectory = tmpDirectory(TestResourceTracker.getCurrentTestName());
global.globalState().persistentLocation(stateDirectory).sharedPersistentLocation(stateDirectory);
return global;
}
private static void deleteGlobalPersistentState(GlobalConfigurationBuilder global) {
GlobalConfiguration globalCfg = global.build();
new File(globalCfg.globalState().persistentLocation() + "/___event_log_cache.dat").delete();
}
@Listener
static class TestLogListener {
private final CountDownLatch latch;
TestLogListener(CountDownLatch latch) {
this.latch = latch;
}
@Logged
public void onDataLogged(EventLog ignore) {
latch.countDown();
}
}
}
| 12,151
| 46.84252
| 181
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/configuration/ServerOverlayConfigurationTest.java
|
package org.infinispan.server.configuration;
import static org.infinispan.server.configuration.ServerConfigurationParserTest.getConfigPath;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.assertFalse;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Properties;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.server.Server;
import org.junit.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class ServerOverlayConfigurationTest {
@Test
public void testOverlay() {
Properties properties = new Properties();
properties.put(Server.INFINISPAN_SERVER_CONFIG_PATH, getConfigPath().toString());
properties.put(Server.INFINISPAN_SERVER_HOME_PATH, getConfigPath().toString());
Server server = new Server(getConfigPath().toFile(), Arrays.asList(Paths.get("Base.xml"), Paths.get("Overlay.yml")), properties);
ConfigurationBuilderHolder holder = server.getConfigurationBuilderHolder();
assertTrue(holder.getNamedConfigurationBuilders().containsKey("overlay"));
GlobalConfiguration global = holder.getGlobalConfigurationBuilder().build();
assertNotNull(global.module(ServerConfiguration.class));
}
@Test
public void testOverlayTwice() {
Properties properties = new Properties();
properties.put(Server.INFINISPAN_SERVER_CONFIG_PATH, getConfigPath().toString());
Server server = new Server(getConfigPath().toFile(),
Arrays.asList(Paths.get("Base.xml"),
Paths.get("Overlay.yml"),
Paths.get("Overlay-AsyncReplicatedCache.yml")),
properties);
ConfigurationBuilderHolder holder = server.getConfigurationBuilderHolder();
assertTrue(holder.getNamedConfigurationBuilders().containsKey("secondary-cache"));
assertFalse(holder.getGlobalConfigurationBuilder().cacheContainer().statistics());
assertFalse(holder.getGlobalConfigurationBuilder().cacheContainer().jmx().enabled());
GlobalConfiguration global = holder.getGlobalConfigurationBuilder().build();
assertNotNull(global.module(ServerConfiguration.class));
}
@Test
public void testOverlayManyConfigurations() {
Properties properties = new Properties();
properties.put(Server.INFINISPAN_SERVER_CONFIG_PATH, getConfigPath().toString());
Server server = new Server(getConfigPath().toFile(),
Arrays.asList(Paths.get("Base.xml"),
Paths.get("Overlay.yml"),
Paths.get("Overlay-AsyncReplicatedCache.yml"),
Paths.get("OverlayJmx.yml"),
Paths.get("OverlayMetrics.xml")),
properties);
ConfigurationBuilderHolder holder = server.getConfigurationBuilderHolder();
assertTrue(holder.getNamedConfigurationBuilders().containsKey("overlay"));
assertTrue(holder.getNamedConfigurationBuilders().containsKey("secondary-cache"));
GlobalConfiguration global = holder.getGlobalConfigurationBuilder().build();
assertNotNull(global.module(ServerConfiguration.class));
}
@Test
public void testUnorderedOverlay() {
Properties properties = new Properties();
properties.put(Server.INFINISPAN_SERVER_CONFIG_PATH, getConfigPath().toString());
Server server = new Server(getConfigPath().toFile(),
Arrays.asList(
Paths.get("OverlayMetrics.xml"),
Paths.get("Overlay-AsyncReplicatedCache.yml"),
Paths.get("OverlayJmx.yml"),
Paths.get("Overlay.yml"),
Paths.get("Base.xml")),
properties);
ConfigurationBuilderHolder holder = server.getConfigurationBuilderHolder();
assertTrue(holder.getNamedConfigurationBuilders().containsKey("overlay"));
assertTrue(holder.getNamedConfigurationBuilders().containsKey("secondary-cache"));
assertTrue(holder.getGlobalConfigurationBuilder().cacheContainer().statistics());
assertTrue(holder.getGlobalConfigurationBuilder().cacheContainer().jmx().enabled());
GlobalConfiguration global = holder.getGlobalConfigurationBuilder().build();
assertNotNull(global.module(ServerConfiguration.class));
}
}
| 4,433
| 47.725275
| 135
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/configuration/ServerConfigurationParserTest.java
|
package org.infinispan.server.configuration;
import static org.infinispan.server.configuration.security.CredentialStoresConfiguration.resolvePassword;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.io.IOException;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.test.junit.JUnitThreadTrackerRule;
import org.infinispan.rest.configuration.RestServerConfiguration;
import org.infinispan.server.configuration.security.LdapRealmConfiguration;
import org.infinispan.server.configuration.security.RealmConfiguration;
import org.infinispan.server.configuration.security.RealmProvider;
import org.infinispan.server.configuration.security.TokenRealmConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration;
import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration;
import org.infinispan.server.network.NetworkAddress;
import org.infinispan.server.router.configuration.SinglePortRouterConfiguration;
import org.junit.ClassRule;
import org.junit.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ServerConfigurationParserTest extends AbstractConfigurationParserTest {
@ClassRule
public static final JUnitThreadTrackerRule tracker = new JUnitThreadTrackerRule();
public ServerConfigurationParserTest(MediaType type) {
super(type);
}
@Override
public String path() {
return "configuration/" + getClass().getSimpleName() + "." + type.getSubType().toLowerCase(Locale.ROOT);
}
@Test
public void testParser() throws IOException {
ServerConfiguration serverConfiguration = loadAndParseConfiguration();
validateConfiguration(serverConfiguration);
}
private void validateConfiguration(ServerConfiguration configuration) {
// Interfaces
assertEquals(2, configuration.networkInterfaces().size());
NetworkAddress defaultInterface = configuration.networkInterfaces().get("default").getNetworkAddress();
assertNotNull(defaultInterface);
assertTrue(defaultInterface.getAddress().isLoopbackAddress());
// Socket bindings
Map<String, SocketBindingConfiguration> socketBindings = configuration.socketBindings();
assertEquals(5, socketBindings.size());
assertEquals(11221, socketBindings.get("memcached").port());
assertEquals(12221, socketBindings.get("memcached-2").port());
assertEquals(11222, socketBindings.get("default").port());
assertEquals(11223, socketBindings.get("hotrod").port());
assertEquals(8080, socketBindings.get("rest").port());
// Security realms
Map<String, RealmConfiguration> realms = configuration.security().realms().realms();
assertEquals(3, realms.size());
RealmConfiguration realmConfiguration = realms.get("default");
assertEquals("default", realmConfiguration.name());
realmConfiguration = realms.get("using-credentials");
assertEquals("using-credentials", realmConfiguration.name());
// Data Sources
Map<String, DataSourceConfiguration> dataSources = configuration.dataSources();
assertEquals(2, dataSources.size());
DataSourceConfiguration dataSource = dataSources.get("database");
assertEquals("jdbc/database", dataSource.jndiName());
assertEquals("jdbc:h2:tcp://127.0.0.1:1521/test", dataSource.url());
assertEquals("test", dataSource.username());
assertEquals("test", new String(dataSource.password()));
assertEquals("SELECT 1", dataSource.initialSql());
assertEquals("org.h2.Driver", dataSource.driver());
assertEquals(10, dataSource.maxSize());
assertEquals(1, dataSource.minSize());
assertEquals(1, dataSource.initialSize());
assertEquals(1, dataSource.connectionProperties().size());
assertEquals(10000, dataSource.leakDetection());
assertEquals(1000, dataSource.backgroundValidation());
assertEquals(500, dataSource.validateOnAcquisition());
assertEquals("somevalue", dataSource.connectionProperties().get("someproperty"));
dataSource = dataSources.get("database-with-credential");
assertEquals("test", new String(dataSource.password()));
// Connectors
List<ProtocolServerConfiguration<?, ?>> connectors = configuration.endpoints().endpoints().get(0).connectors();
assertEquals(3, connectors.size());
assertTrue(connectors.get(0) instanceof HotRodServerConfiguration);
assertTrue(connectors.get(1) instanceof RestServerConfiguration);
assertTrue(connectors.get(2) instanceof MemcachedServerConfiguration);
// Ensure endpoints are bound to the interfaces
SinglePortRouterConfiguration singlePortRouter = configuration.endpoints().endpoints().get(0).singlePortRouter();
assertEquals(socketBindings.get("default").interfaceConfiguration().getNetworkAddress().getAddress().getHostAddress(), singlePortRouter.host());
assertEquals(socketBindings.get("default").port(), singlePortRouter.port());
assertEquals(socketBindings.get("memcached").port(), configuration.endpoints().endpoints().get(0).connectors().get(2).port());
assertEquals("strongPassword", new String(resolvePassword(realmProvider(realmConfiguration, LdapRealmConfiguration.class).attributes().attribute(Attribute.CREDENTIAL))));
assertEquals("secret", new String(resolvePassword(realmConfiguration.serverIdentitiesConfiguration().sslConfiguration().trustStore().attributes().attribute(Attribute.PASSWORD))));
assertEquals("1fdca4ec-c416-47e0-867a-3d471af7050f", new String(resolvePassword(realmProvider(realmConfiguration, TokenRealmConfiguration.class).oauth2Configuration().attributes().attribute(Attribute.CLIENT_SECRET))));
assertEquals(3, configuration.security.credentialStores().credentialStores().size());
}
<T extends RealmProvider> T realmProvider(RealmConfiguration realm, Class<T> providerClass) {
return (T) realm.realmProviders().stream().filter(r -> providerClass.isAssignableFrom(r.getClass())).findFirst().get();
}
}
| 6,318
| 50.795082
| 224
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/configuration/AbstractConfigurationParserTest.java
|
package org.infinispan.server.configuration;
import java.io.IOException;
import java.net.URL;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.util.FileLookup;
import org.infinispan.commons.util.FileLookupFactory;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ParserRegistry;
import org.infinispan.server.Server;
import org.infinispan.server.security.ElytronPasswordProviderSupplier;
import org.infinispan.server.security.KeyStoreUtils;
import org.junit.BeforeClass;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.wildfly.security.auth.server.IdentityCredentials;
import org.wildfly.security.credential.PasswordCredential;
import org.wildfly.security.credential.store.CredentialStore;
import org.wildfly.security.credential.store.CredentialStoreException;
import org.wildfly.security.credential.store.impl.KeyStoreCredentialStore;
import org.wildfly.security.password.interfaces.ClearPassword;
@RunWith(Parameterized.class)
public abstract class AbstractConfigurationParserTest {
protected final MediaType type;
public static final char[] PASSWORD = "password".toCharArray();
public static final char[] SECRET = "secret".toCharArray();
protected static final String KEYSTORE_FILE_NAME = "ServerConfigurationParserTest-keystore.pfx";
protected static final String TRUSTSTORE_FILE_NAME = "ServerConfigurationParserTest-truststore.pfx";
protected static final String CREDENTIALS_FILE_NAME = "ServerConfigurationParserTest-credentials.pfx";
protected AbstractConfigurationParserTest(MediaType type) {
this.type = type;
}
@BeforeClass
public static void setup() throws Exception {
KeyStoreUtils.generateSelfSignedCertificate(pathToKeystore(), null, PASSWORD, PASSWORD, "server", "localhost");
KeyStoreUtils.generateEmptyKeyStore(getConfigPath().resolve(TRUSTSTORE_FILE_NAME).toString(), SECRET);
createCredentialStore(getConfigPath().resolve(CREDENTIALS_FILE_NAME), SECRET);
}
@Parameterized.Parameters(name = "{0}")
public static Iterable<MediaType> mediaTypes() {
return Arrays.asList(MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON, MediaType.APPLICATION_YAML);
}
protected ServerConfiguration loadAndParseConfiguration() throws IOException {
FileLookup fileLookup = FileLookupFactory.newInstance();
URL url = fileLookup.lookupFileLocation(path(), this.getClass().getClassLoader());
Properties properties = new Properties();
properties.setProperty(Server.INFINISPAN_SERVER_CONFIG_PATH, getConfigPath().toString());
properties.setProperty(Server.INFINISPAN_SERVER_HOME_PATH, Paths.get(System.getProperty("build.directory")).toString());
properties.setProperty("org.infinispan.test.host.address", "127.0.0.1");
ParserRegistry registry = new ParserRegistry(this.getClass().getClassLoader(), false, properties);
ConfigurationBuilderHolder holder = registry.parse(url);
GlobalConfiguration global = holder.getGlobalConfigurationBuilder().build();
return global.module(ServerConfiguration.class);
}
public static Path getConfigPath() {
return Paths.get(System.getProperty("build.directory"), "test-classes", "configuration");
}
protected abstract String path();
public static String pathToKeystore() {
Path path = getConfigPath().resolve(KEYSTORE_FILE_NAME);
return path.toString();
}
static void createCredentialStore(Path location, char[] secret) {
KeyStoreCredentialStore credentialStore = newCredentialStore(location, secret);
addCredential(credentialStore, "ldap", "strongPassword");
addCredential(credentialStore, "db", "test");
addCredential(credentialStore, "keystore", "password");
addCredential(credentialStore, "oauth2", "1fdca4ec-c416-47e0-867a-3d471af7050f");
addCredential(credentialStore, "trust", "secret");
}
static void addCredential(KeyStoreCredentialStore store, String alias, String credential) {
try {
store.store(alias, new PasswordCredential(ClearPassword.createRaw(ClearPassword.ALGORITHM_CLEAR, credential.toCharArray())), null);
store.flush();
} catch (CredentialStoreException e) {
throw new RuntimeException(e);
}
}
static KeyStoreCredentialStore newCredentialStore(Path location, char[] secret) {
Exceptions.unchecked(() -> {
Files.deleteIfExists(location);
Files.createDirectories(location.getParent());
});
KeyStoreCredentialStore credentialStore = new KeyStoreCredentialStore();
final Map<String, String> map = new HashMap<>();
map.put("location", location.toString());
map.put("create", "true");
try {
credentialStore.initialize(
map,
new CredentialStore.CredentialSourceProtectionParameter(
IdentityCredentials.NONE.withCredential(new PasswordCredential(ClearPassword.createRaw(ClearPassword.ALGORITHM_CLEAR, secret)))),
ElytronPasswordProviderSupplier.PROVIDERS
);
return credentialStore;
} catch (CredentialStoreException e) {
throw new RuntimeException(e);
}
}
}
| 5,599
| 43.8
| 150
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/configuration/ServerConfigurationSerializerTest.java
|
package org.infinispan.server.configuration;
import static org.infinispan.server.configuration.ServerConfigurationParserTest.PASSWORD;
import static org.infinispan.server.configuration.ServerConfigurationParserTest.SECRET;
import static org.infinispan.server.configuration.ServerConfigurationParserTest.createCredentialStore;
import static org.infinispan.server.configuration.ServerConfigurationParserTest.getConfigPath;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.lang.invoke.MethodHandles;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.GeneralSecurityException;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.configuration.io.ConfigurationResourceResolvers;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ParserRegistry;
import org.infinispan.server.Server;
import org.infinispan.server.security.KeyStoreUtils;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
/**
* @since 14.0
**/
@RunWith(Parameterized.class)
public class ServerConfigurationSerializerTest {
static final List<MediaType> types = Arrays.asList(MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON, MediaType.APPLICATION_YAML);
static final Log log = LogFactory.getLog(MethodHandles.lookup().lookupClass());
private final Path config;
private final MediaType type;
@BeforeClass
public static void setup() throws GeneralSecurityException, IOException {
KeyStoreUtils.generateSelfSignedCertificate(getConfigPath().resolve("ServerConfigurationSerializerTest-keystore.pfx").toString(), null, PASSWORD,
PASSWORD, "server", "localhost");
KeyStoreUtils.generateEmptyKeyStore(getConfigPath().resolve("ServerConfigurationSerializerTest-truststore.pfx").toString(), SECRET);
createCredentialStore(getConfigPath().resolve("ServerConfigurationSerializerTest-credentials.pfx"), SECRET);
}
@Parameterized.Parameters(name = "{0} > [{2}]")
public static Iterable<Object[]> data() throws IOException {
Path configDir = Paths.get(System.getProperty("build.directory"), "test-classes", "configuration", "versions");
createCredentialStore(configDir.getParent().resolve("ServerConfigurationSerializerTest-credentials.pfx"), SECRET);
return Files.list(configDir).flatMap(p -> types.stream().map(t -> new Object[]{p.getFileName(), p, t})).collect(Collectors.toList());
}
public ServerConfigurationSerializerTest(Path name, Path config, MediaType type) {
this.config = config;
this.type = type;
}
@Test
public void testConfigurationSerialization() throws IOException {
Properties properties = new Properties();
properties.put("infinispan.server.config.path", config.getParent().getParent().toString());
properties.setProperty(Server.INFINISPAN_SERVER_HOME_PATH, Paths.get(System.getProperty("build.directory")).toString());
properties.setProperty("org.infinispan.test.host.address", "127.0.0.1");
ParserRegistry registry = new ParserRegistry(Thread.currentThread().getContextClassLoader(), false, properties);
ConfigurationBuilderHolder holderBefore = registry.parse(config);
ByteArrayOutputStream baos = new ByteArrayOutputStream();
Map<String, Configuration> configurations = new HashMap<>();
for (Map.Entry<String, ConfigurationBuilder> configuration : holderBefore.getNamedConfigurationBuilders().entrySet()) {
configurations.put(configuration.getKey(), configuration.getValue().build());
}
try (ConfigurationWriter writer = ConfigurationWriter.to(baos).withType(type).clearTextSecrets(true).build()) {
registry.serialize(writer, holderBefore.getGlobalConfigurationBuilder().build(), configurations);
}
log.debug(baos);
ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
ConfigurationBuilderHolder holderAfter = registry.parse(bais, ConfigurationResourceResolvers.DEFAULT, type);
GlobalConfiguration globalConfigurationBefore = holderBefore.getGlobalConfigurationBuilder().build();
GlobalConfiguration globalConfigurationAfter = holderAfter.getGlobalConfigurationBuilder().build();
ServerConfiguration serverBefore = globalConfigurationBefore.module(ServerConfiguration.class);
ServerConfiguration serverAfter = globalConfigurationAfter.module(ServerConfiguration.class);
compare(serverBefore.interfaces.interfaces(), serverAfter.interfaces.interfaces());
compare(serverBefore.socketBindings, serverAfter.socketBindings);
compare(serverBefore.dataSources, serverAfter.dataSources);
compare(serverBefore.security.credentialStores(), serverAfter.security.credentialStores());
compare(serverBefore.security.realms().realms(), serverAfter.security.realms().realms());
compare(serverBefore.security.transport(), serverAfter.security.transport(), org.infinispan.server.configuration.Attribute.SECURITY_REALM.toString());
compare(serverBefore.endpoints.endpoints(), serverAfter.endpoints.endpoints());
}
<T extends ConfigurationElement> void compare(List<T> before, List<T> after) {
assertEquals(before.size(), after.size());
for (Iterator<T> b = before.iterator(), a = after.iterator(); b.hasNext(); ) {
compare(b.next(), a.next());
}
}
<T extends ConfigurationElement> void compare(Map<String, T> before, Map<String, T> after) {
assertEquals(before.size(), after.size());
for (Iterator<T> b = before.values().iterator(), a = after.values().iterator(); b.hasNext(); ) {
compare(b.next(), a.next());
}
}
static void compare(ConfigurationElement<?> before, ConfigurationElement<?> after, String... exclude) {
assertEquals(before.elementName(), after.elementName());
compare(before.elementName(), before.attributes(), after.attributes(), exclude);
assertEquals(before.children().length, after.children().length);
for (int i = 0; i < before.children().length; i++) {
compare(before.children()[i], after.children()[i]);
}
}
static void compare(String name, AttributeSet before, AttributeSet after, String... exclude) {
if (before != null && after != null) {
List<String> exclusions = exclude != null ? Arrays.asList(exclude) : Collections.emptyList();
for (Attribute<?> attribute : before.attributes()) {
if (!exclusions.contains(attribute.name())) {
assertEquals("Configuration " + name, attribute, after.attribute(attribute.name()));
}
}
}
}
}
| 7,624
| 53.078014
| 156
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/configuration/security/KeyStoreConfigurationTest.java
|
package org.infinispan.server.configuration.security;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import java.util.Locale;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.test.junit.JUnitThreadTrackerRule;
import org.infinispan.server.configuration.AbstractConfigurationParserTest;
import org.infinispan.server.configuration.ServerConfigurationParserTest;
import org.junit.ClassRule;
import org.junit.Test;
public class KeyStoreConfigurationTest extends AbstractConfigurationParserTest {
@ClassRule
public static final JUnitThreadTrackerRule tracker = new JUnitThreadTrackerRule();
public KeyStoreConfigurationTest(MediaType type) {
super(type);
}
@Override
public String path() {
return "configuration/invalid-alias/KeystoreInvalidAlias." + type.getSubType().toLowerCase(Locale.ROOT);
}
@Test
public void shouldThrowOnInvalidAlias() {
CacheConfigurationException e = assertThrows(CacheConfigurationException.class, this::loadAndParseConfiguration);
assertTrue("Cause is: " + e.getCause(), e.getCause() instanceof CacheConfigurationException);
assertEquals(exceptionMessage(), e.getCause().getMessage());
}
private String exceptionMessage() {
return String.format("ISPN080069: Alias 'definitely-an-unknown-alias' not in keystore '%s'",
ServerConfigurationParserTest.pathToKeystore());
}
}
| 1,568
| 35.488372
| 119
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/logging/XmlConfigurationTest.java
|
package org.infinispan.server.logging;
import static org.junit.Assert.assertEquals;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.ConfigurationSource;
import org.infinispan.server.logging.log4j.XmlConfiguration;
import org.junit.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class XmlConfigurationTest {
@Test
public void testXmlConfiguration() throws IOException {
Path path = getConfigPath().resolve("log4j2.xml");
try (InputStream is = Files.newInputStream(path)) {
ConfigurationSource configurationSource = new ConfigurationSource(is, path.toFile());
LoggerContext context = new LoggerContext("test");
XmlConfiguration xmlConfiguration = new XmlConfiguration(context, configurationSource);
xmlConfiguration.initialize();
assertEquals("InfinispanServerConfig", xmlConfiguration.getName());
}
}
public static Path getConfigPath() {
return Paths.get(System.getProperty("build.directory"), "test-classes", "configuration");
}
}
| 1,256
| 32.078947
| 96
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/context/ServerInitialContextFactoryBuilderTest.java
|
package org.infinispan.server.context;
import java.util.Properties;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.spi.InitialContextFactory;
import org.junit.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class ServerInitialContextFactoryBuilderTest {
@Test
public void testNoIllegalAccessJDKInitialContextFactories() throws NamingException {
ServerInitialContextFactoryBuilder builder = new ServerInitialContextFactoryBuilder();
Properties env = new Properties();
env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.dns.DnsContextFactory");
InitialContextFactory contextFactory = builder.createInitialContextFactory(env);
}
}
| 756
| 29.28
| 92
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/loader/ThreeClass.java
|
package org.infinispan.server.loader;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class ThreeClass {
}
| 149
| 15.666667
| 57
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/loader/TwoClass.java
|
package org.infinispan.server.loader;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class TwoClass {
}
| 147
| 15.444444
| 57
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/loader/LoaderTest.java
|
package org.infinispan.server.loader;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Writer;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Properties;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.exporter.ZipExporter;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.junit.BeforeClass;
import org.junit.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class LoaderTest {
private static Path lib1;
private static Path lib2;
private static Path lib3;
@BeforeClass
public static void prepareLibs() throws IOException {
Path path = Paths.get(System.getProperty("build.directory"), "test-classes", "server");
lib1 = path.resolve("lib1");
lib2 = path.resolve("lib2");
lib3 = Files.createDirectories(lib2.resolve("lib3"));
ShrinkWrap.create(JavaArchive.class,"two.jar")
.addClasses(TwoClass.class).as(ZipExporter.class).exportTo(lib2.resolve("two.jar").toFile(), true);
ShrinkWrap.create(JavaArchive.class,"three.jar")
.addClasses(ThreeClass.class).as(ZipExporter.class).exportTo(lib3.resolve("three.jar").toFile(), true);
}
@Test
public void testLoaderViaSystemProperty() {
Properties properties = new Properties();
properties.put(Loader.INFINISPAN_SERVER_LIB_PATH, String.join(File.pathSeparator, lib1.toString(), lib2.toString(), lib3.toString()));
properties.put("user.dir", System.getProperty("user.dir"));
Loader.run(new String[]{LoaderTest.class.getName()}, properties);
}
@Test
public void testLoaderViaPropertyFile() throws IOException {
Properties properties = new Properties();
properties.put(Loader.INFINISPAN_SERVER_LIB_PATH, String.join(File.pathSeparator, lib1.toString(), lib2.toString(), lib3.toString()));
Path propertyFile = Paths.get(System.getProperty("build.directory"), "loader.properties");
try (Writer w = Files.newBufferedWriter(propertyFile)) {
properties.store(w, null);
}
properties = new Properties();
properties.put("user.dir", System.getProperty("user.dir"));
Loader.run(new String[]{LoaderTest.class.getName(), "-P", propertyFile.toAbsolutePath().toString()}, properties);
}
public static void main(String[] args) {
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
assertTrue(contextClassLoader instanceof URLClassLoader);
try (InputStream is = contextClassLoader.getResourceAsStream("test.properties")) {
Properties properties = new Properties();
properties.load(is);
assertEquals("v", properties.getProperty("k"));
} catch (IOException e) {
fail(e.getMessage());
}
try {
contextClassLoader.loadClass("org.infinispan.server.loader.TwoClass");
contextClassLoader.loadClass("org.infinispan.server.loader.ThreeClass");
} catch (ClassNotFoundException e) {
fail(e.getMessage());
}
}
}
| 3,288
| 38.154762
| 140
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/license/LicenseTest.java
|
package org.infinispan.server.license;
import static org.junit.Assert.assertEquals;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.junit.Assert;
import org.junit.Test;
/**
* We tried to use
* Path path = jarfs.getPath("META-INF/", "maven");
* Optional<Path> propertyPath = Files.find(path,
* 100,
* (filePath, fileAttr) -> fileAttr.isRegularFile() && filePath.getFileName().toString().endsWith("properties"))
* .findFirst();
* but some artifacts are productized with ANT
*
* The META-INF/MANIFEST.MF that comes with ANT is missing the group, artifact and version
*/
public class LicenseTest {
private static final Pattern TR_REGEX = Pattern.compile("<tr>(.+?)</tr>", Pattern.DOTALL);
private static final Pattern TD_VALUE_REGEX = Pattern.compile("<td>(.*?)</td>", Pattern.DOTALL);
private static final String SERVER_OUTPUT_PATH = System.getProperty("server.output.dir");
@Test
public void testLicense() throws IOException {
Set<String> libs = Files.list(getLibDir())
.filter(Files::isRegularFile)
.map(Path::getFileName)
.map(String::valueOf)
.map(LicenseTest::removeOsName)
.collect(Collectors.toSet());
String html = new String(Files.readAllBytes(getDependencyHtmlFile()));
Matcher trMatcher = TR_REGEX.matcher(html);
List<String> htmlDependencies = new ArrayList<>();
while (trMatcher.find()) {
String trValue = trMatcher.group(1);
Matcher tdMatcher = TD_VALUE_REGEX.matcher(trValue);
if (tdMatcher.find()) {
String group = tdMatcher.group(1);
String artifact;
if (group.contains("@patternfly")) {
// patternfly includes the artifact in the group with a slash
String[] splitGroup = group.split("/");
artifact = splitGroup[1];
// Ignore the next match as it is empty
tdMatcher.find();
} else {
tdMatcher.find();
artifact = tdMatcher.group(1);
}
tdMatcher.find();
String version = tdMatcher.group(1);
tdMatcher.find();
String remoteLicenses = tdMatcher.group(1);
Assert.assertTrue("Remote License: " + artifact + ":" + version + ":" + remoteLicenses, hasLicenseLink(remoteLicenses));
tdMatcher.find();
String localLicenses = tdMatcher.group(1);
Assert.assertTrue("Local License: " + artifact + ":" + version + ":" + localLicenses, hasLicenseLink(localLicenses));
htmlDependencies.add(String.format("%s-%s.jar", artifact, version));
}
}
libs.removeAll(htmlDependencies);
// helpful output
for (String lib : libs) {
System.out.println("Missing: " + lib);
}
assertEquals(libs.toString(), 0, libs.size());
}
private static String removeOsName(String jarFile) {
return jarFile
.replace("epoll-linux-x86_64", "epoll")
.replace("epoll-linux-aarch_64", "epoll")
.replace("io_uring-linux-x86_64", "io_uring")
.replace("io_uring-linux-aarch_64", "io_uring");
}
private Path getLibDir() {
File libDir = new File(SERVER_OUTPUT_PATH, "lib");
return libDir.toPath();
}
private Path getDependencyHtmlFile() {
File docsDir = new File(SERVER_OUTPUT_PATH, "docs");
File licensesDir = new File(docsDir, "licenses");
File licensesHtmlFile = new File(licensesDir, "licenses.html");
return licensesHtmlFile.toPath();
}
private boolean hasLicenseLink(String value) {
return value != null && value.contains("a href");
}
}
| 4,017
| 33.93913
| 132
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/persistence/EventLoggerCompatibilityTest.java
|
package org.infinispan.server.persistence;
import static org.infinispan.test.TestingUtil.withCacheManager;
import static org.junit.Assert.assertEquals;
import java.io.File;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.StandardCopyOption;
import org.infinispan.Cache;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.test.junit.JUnitThreadTrackerRule;
import org.infinispan.commons.util.FileLookupFactory;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.file.SingleFileStore;
import org.infinispan.test.CacheManagerCallable;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.junit.Test;
/**
* @author William Burns
* @author Ryan Emerson
* @since 12.1
*/
public class EventLoggerCompatibilityTest {
@ClassRule
public static final JUnitThreadTrackerRule tracker = new JUnitThreadTrackerRule();
String tmpDirectory;
@Before
public void startup() {
tmpDirectory = CommonsTestingUtil.tmpDirectory(this.getClass());
Util.recursiveFileRemove(tmpDirectory);
}
@After
public void teardown() {
Util.recursiveFileRemove(tmpDirectory);
}
@Test
public void testReadWriteFrom11EventCache() throws Exception {
String cacheName = "event-cache";
String file = "sfs/11_0/event_log_cache.dat";
InputStream is = FileLookupFactory.newInstance()
.lookupFile(file, Thread.currentThread().getContextClassLoader());
File sfsFile = SingleFileStore.getStoreFile(tmpDirectory, cacheName);
if (!sfsFile.exists()) {
sfsFile.getParentFile().mkdirs();
}
//copy data to the store file
Files.copy(is, sfsFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
Configuration config = new ConfigurationBuilder()
.persistence().addSingleFileStore()
.segmented(false)
.location(tmpDirectory)
.build();
withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) {
@Override
public void call() {
Cache<Object, Object> cache = cm.createCache(cacheName, config);
assertEquals(43, cache.size());
}
});
}
}
| 2,455
| 30.487179
| 95
|
java
|
null |
infinispan-main/server/runtime/src/test/java/org/infinispan/server/persistence/EventLoggerRecoverCorruptTest.java
|
package org.infinispan.server.persistence;
import static org.junit.Assert.assertEquals;
import static org.infinispan.test.TestingUtil.withCacheManager;
import java.io.File;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import org.infinispan.Cache;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.test.junit.JUnitThreadTrackerRule;
import org.infinispan.commons.util.FileLookupFactory;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.test.CacheManagerCallable;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.ClassRule;
import org.junit.Test;
/**
* Test that replicates 11.x -> 12.1.x corrupt migration for the ServerEventLogger.
*
* @author Ryan Emerson
* @since 13.0
*/
public class EventLoggerRecoverCorruptTest {
@ClassRule
public static final JUnitThreadTrackerRule tracker = new JUnitThreadTrackerRule();
static final String CACHE_NAME = "update-cache";
private static String tmpDirectory;
@BeforeClass
public static void setUpTempDir() {
tmpDirectory = CommonsTestingUtil.tmpDirectory(EventLoggerRecoverCorruptTest.class);
new File(tmpDirectory).mkdirs();
}
@AfterClass
public static void clearTempDir() {
Util.recursiveFileRemove(tmpDirectory);
}
@Test
public void testAllEntriesRecovered() throws Exception {
InputStream is = FileLookupFactory.newInstance().lookupFile("sfs/corrupt/___event_log_cache.dat", Thread.currentThread().getContextClassLoader());
Files.copy(is, Paths.get(tmpDirectory).resolve(CACHE_NAME + ".dat"), StandardCopyOption.REPLACE_EXISTING);
Configuration config = new ConfigurationBuilder()
.persistence()
.addSingleFileStore()
.segmented(false)
.location(tmpDirectory)
.build();
withCacheManager(new CacheManagerCallable(TestCacheManagerFactory.createCacheManager()) {
@Override
public void call() {
Cache<Object, Object> cache = cm.createCache(CACHE_NAME, config);
assertEquals(43, cache.size());
}
});
}
}
| 2,390
| 31.753425
| 152
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/Extensions.java
|
package org.infinispan.server;
import java.sql.Driver;
import java.util.HashMap;
import java.util.Map;
import javax.script.ScriptEngineFactory;
import org.infinispan.commons.util.ServiceFinder;
import org.infinispan.filter.KeyValueFilterConverterFactory;
import org.infinispan.filter.NamedFactory;
import org.infinispan.filter.ParamKeyValueFilterConverterFactory;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.cachelistener.filter.CacheEventConverterFactory;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilterConverterFactory;
import org.infinispan.notifications.cachelistener.filter.CacheEventFilterFactory;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.tasks.ServerTaskEngine;
import org.infinispan.server.tasks.ServerTaskWrapper;
import org.infinispan.tasks.ServerTask;
import org.infinispan.tasks.spi.TaskEngine;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class Extensions {
private final Map<String, CacheEventFilterFactory> filterFactories = new HashMap<>();
private final Map<String, CacheEventConverterFactory> converterFactories = new HashMap<>();
private final Map<String, CacheEventFilterConverterFactory> filterConverterFactories = new HashMap<>();
private final Map<String, KeyValueFilterConverterFactory> keyValueFilterConverterFactories = new HashMap<>();
private final Map<String, ParamKeyValueFilterConverterFactory> paramKeyValueFilterConverterFactories = new HashMap<>();
private final Map<String, ServerTaskWrapper> serverTasks = new HashMap<>();
public Extensions() {
}
public void load(ClassLoader classLoader) {
loadNamedFactory(classLoader, CacheEventFilterFactory.class, filterFactories);
loadNamedFactory(classLoader, CacheEventConverterFactory.class, converterFactories);
loadNamedFactory(classLoader, CacheEventFilterConverterFactory.class, filterConverterFactories);
loadNamedFactory(classLoader, KeyValueFilterConverterFactory.class, keyValueFilterConverterFactories);
loadNamedFactory(classLoader, ParamKeyValueFilterConverterFactory.class, paramKeyValueFilterConverterFactories);
loadService(classLoader, Driver.class);
if (loadService(classLoader, ScriptEngineFactory.class) == 0) {
Server.log.noScriptEngines();
}
loadServerTasks(classLoader);
}
public void apply(HotRodServer server) {
for (Map.Entry<String, CacheEventFilterFactory> factory : filterFactories.entrySet()) {
server.addCacheEventFilterFactory(factory.getKey(), factory.getValue());
}
for (Map.Entry<String, CacheEventConverterFactory> factory : converterFactories.entrySet()) {
server.addCacheEventConverterFactory(factory.getKey(), factory.getValue());
}
for (Map.Entry<String, CacheEventFilterConverterFactory> factory : filterConverterFactories.entrySet()) {
server.addCacheEventFilterConverterFactory(factory.getKey(), factory.getValue());
}
for (Map.Entry<String, KeyValueFilterConverterFactory> factory : keyValueFilterConverterFactories.entrySet()) {
server.addKeyValueFilterConverterFactory(factory.getKey(), factory.getValue());
}
for (Map.Entry<String, ParamKeyValueFilterConverterFactory> factory : paramKeyValueFilterConverterFactories.entrySet()) {
server.addKeyValueFilterConverterFactory(factory.getKey(), factory.getValue());
}
}
private <T> void loadNamedFactory(ClassLoader classLoader, Class<T> contract, Map<String, T> map) {
for (T t : ServiceFinder.load(contract, classLoader)) {
NamedFactory name = t.getClass().getAnnotation(NamedFactory.class);
if (name != null) {
map.put(name.name(), t);
Server.log.loadedExtension(name.name());
} else {
Server.log.unnamedFactoryClass(t.getClass().getName());
}
}
}
private <T> int loadService(ClassLoader classLoader, Class<T> contract) {
int i = 0;
for (T t : ServiceFinder.load(contract, classLoader)) {
Server.log.loadedExtension(t.getClass().getName());
i++;
}
return i;
}
private void loadServerTasks(ClassLoader classLoader) {
for (ServerTask t : ServiceFinder.load(ServerTask.class, classLoader)) {
serverTasks.put(t.getName(), new ServerTaskWrapper(t));
Server.log.loadedExtension(t.getClass().getName());
}
}
public TaskEngine getServerTaskEngine(EmbeddedCacheManager cm) {
return new ServerTaskEngine(cm, serverTasks);
}
}
| 4,640
| 44.950495
| 127
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/SecurityActions.java
|
package org.infinispan.server;
import static org.infinispan.security.Security.doPrivileged;
import java.security.Provider;
import java.util.function.Supplier;
import javax.naming.NamingException;
import javax.naming.spi.InitialContextFactoryBuilder;
import javax.naming.spi.NamingManager;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.manager.ClusterExecutor;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.impl.Authorizer;
import org.infinispan.server.core.ProtocolServer;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
/**
* SecurityActions for the org.infinispan.server.server package.
* <p>
* Do not move. Do not change class and method visibility to avoid being called from other
* {@link java.security.CodeSource}s, thus granting privilege escalation to external code.
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
*/
final class SecurityActions {
static void addSecurityProvider(Provider provider) {
if (java.security.Security.getProvider(provider.getName()) == null) {
java.security.Security.insertProviderAt(provider, 1);
}
}
static void startCacheManager(final EmbeddedCacheManager cacheManager) {
Runnable action = () -> {
cacheManager.start();
};
doPrivileged(action);
}
static boolean stopCacheManager(final EmbeddedCacheManager cacheManager) {
Supplier<Boolean> action = () -> {
if (cacheManager != null && cacheManager.getStatus().allowInvocations()) {
cacheManager.stop();
return true;
} else {
return false;
}
};
return doPrivileged(action);
}
static void startProtocolServer(ProtocolServer<ProtocolServerConfiguration> server, ProtocolServerConfiguration configuration, EmbeddedCacheManager cacheManager) {
doPrivileged(() -> {
server.start(configuration, cacheManager);
return null;
});
}
static GlobalConfiguration getCacheManagerConfiguration(EmbeddedCacheManager manager) {
return org.infinispan.security.actions.SecurityActions.getCacheManagerConfiguration(manager);
}
static void shutdownAllCaches(DefaultCacheManager manager) {
Runnable action = () -> {
manager.shutdownAllCaches();
};
doPrivileged(action);
}
static GlobalComponentRegistry getGlobalComponentRegistry(final EmbeddedCacheManager cacheManager) {
return org.infinispan.security.actions.SecurityActions.getGlobalComponentRegistry(cacheManager);
}
static void setInitialContextFactoryBuilder(InitialContextFactoryBuilder initialContextFactoryBuilder) throws NamingException {
NamingManager.setInitialContextFactoryBuilder(initialContextFactoryBuilder);
}
static void checkPermission(EmbeddedCacheManager cacheManager, AuthorizationPermission permission) {
Authorizer authorizer = getGlobalComponentRegistry(cacheManager).getComponent(Authorizer.class);
authorizer.checkPermission(cacheManager.getSubject(), permission);
}
static ClusterExecutor getClusterExecutor(EmbeddedCacheManager cacheManager) {
return doPrivileged(() -> cacheManager.executor());
}
}
| 3,441
| 35.617021
| 166
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/Bootstrap.java
|
package org.infinispan.server;
import static org.infinispan.server.Server.DEFAULT_SERVER_CONFIG;
import static org.infinispan.server.Server.INFINISPAN_SERVER_CONFIG_PATH;
import static org.infinispan.server.logging.Messages.MSG;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.io.Reader;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.infinispan.commons.jdkspecific.ProcessInfo;
import org.infinispan.commons.util.Version;
import org.infinispan.server.tool.Main;
import reactor.blockhound.BlockHound;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class Bootstrap extends Main {
private final ExitHandler exitHandler;
private final List<Path> configurationFiles = new ArrayList<>(3);
private Path loggingFile;
static {
staticInitializer();
}
// This method is here solely for replacement with Quarkus, do not remove or rename without updating Infinispan Quarkus
private static void staticInitializer() {
// This has to be before logging so it can instrument the classes properly
try {
Class.forName("reactor.blockhound.BlockHound");
System.out.println("Blockhound found on classpath, installing non blocking checks");
BlockHound.install();
} catch (ClassNotFoundException e) {
// Just ignore if blockhound isn't present
}
String includeLoggingResource = System.getProperty("infinispan.server.resource.logging", "true");
if (Boolean.parseBoolean(includeLoggingResource)) {
BootstrapLogging.staticInitializer();
}
}
public Bootstrap(PrintStream stdOut, PrintStream stdErr, ExitHandler exitHandler, Properties properties) {
super(stdOut, stdErr, properties);
this.exitHandler = exitHandler;
}
public static void main(String[] args) {
Bootstrap bootstrap = new Bootstrap(System.out, System.err, new DefaultExitHandler(), System.getProperties());
bootstrap.run(args);
}
@Override
protected void handleArgumentCommand(String command, String parameter, Iterator<String> args) {
switch (command) {
case "-c":
parameter = args.next();
// Fall through
case "--server-config":
configurationFiles.add(Paths.get(parameter));
break;
case "-l":
parameter = args.next();
// Fall through
case "--logging-config":
loggingFile = Paths.get(parameter);
break;
case "-s":
parameter = args.next();
// Fall through
case "--server-root":
serverRoot = new File(parameter);
break;
case "-b":
parameter = args.next();
// Fall through
case "--bind-address":
properties.setProperty(Server.INFINISPAN_BIND_ADDRESS, parameter);
break;
case "-p":
parameter = args.next();
// Fall through
case "--bind-port":
properties.setProperty(Server.INFINISPAN_BIND_PORT, parameter);
break;
case "-n":
parameter = args.next();
case "--node-name":
properties.setProperty(Server.INFINISPAN_NODE_NAME, parameter);
break;
case "-g":
parameter = args.next();
case "--cluster-name":
properties.setProperty(Server.INFINISPAN_CLUSTER_NAME, parameter);
break;
case "-j":
parameter = args.next();
case "--cluster-stack":
properties.setProperty(Server.INFINISPAN_CLUSTER_STACK, parameter);
break;
case "-k":
parameter = args.next();
case "--cluster-address":
properties.setProperty(Server.JGROUPS_BIND_ADDRESS, parameter);
break;
case "-o":
parameter = args.next();
// Fall through
case "--port-offset":
properties.setProperty(Server.INFINISPAN_PORT_OFFSET, parameter);
int offset = Integer.parseInt(parameter);
if (!properties.containsKey(Server.JGROUPS_BIND_PORT)) {
properties.setProperty(Server.JGROUPS_BIND_PORT, Integer.toString(Server.DEFAULT_JGROUPS_BIND_PORT + offset));
}
if (!properties.containsKey(Server.JGROUPS_FD_PORT_OFFSET)) {
properties.setProperty(Server.JGROUPS_FD_PORT_OFFSET, Integer.toString(Server.DEFAULT_JGROUPS_FD_PORT_OFFSET + offset));
}
break;
case "-P":
parameter = args.next();
case "--properties":
try (Reader r = Files.newBufferedReader(Paths.get(parameter))) {
Properties loaded = new Properties();
loaded.load(r);
loaded.forEach(properties::putIfAbsent);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
break;
default:
throw new IllegalArgumentException(command);
}
}
public void runInternal() {
if (!serverRoot.isAbsolute()) {
serverRoot = serverRoot.getAbsoluteFile();
}
properties.putIfAbsent(INFINISPAN_SERVER_CONFIG_PATH, new File(serverRoot, DEFAULT_SERVER_CONFIG).getAbsolutePath());
Path confDir = Paths.get(properties.getProperty(INFINISPAN_SERVER_CONFIG_PATH));
if (configurationFiles.isEmpty()) {
configurationFiles.add(Paths.get(Server.DEFAULT_CONFIGURATION_FILE));
}
properties.putIfAbsent(Server.INFINISPAN_SERVER_LOG_PATH, new File(serverRoot, Server.DEFAULT_SERVER_LOG).getAbsolutePath());
if (loggingFile == null) {
loggingFile = confDir.resolve(Server.DEFAULT_LOGGING_FILE);
} else if (!loggingFile.isAbsolute()) {
loggingFile = confDir.resolve(loggingFile);
}
if (!Files.isReadable(loggingFile)) {
stdErr.printf("Cannot read %s", loggingFile);
return;
}
configureLogging();
logJVMInformation();
Runtime.getRuntime().addShutdownHook(new ShutdownHook(exitHandler));
Server.log.serverStarting(Version.getBrandName(), Version.getBrandVersion());
for (Path configurationFile : configurationFiles) {
Server.log.serverConfiguration(configurationFile.toString());
}
Server.log.loggingConfiguration(loggingFile.toString());
try (Server server = new Server(serverRoot, configurationFiles, properties)) {
server.setExitHandler(exitHandler);
server.run().join();
}
}
// This method is here solely for replacement with Quarkus, do not remove or rename without updating Infinispan Quarkus
protected void configureLogging() {
String includeLoggingResource = System.getProperty("infinispan.server.resource.logging", "true");
if (Boolean.parseBoolean(includeLoggingResource)) {
BootstrapLogging.configureLogging(loggingFile);
}
}
@Override
public void help(PrintStream out) {
out.printf("Usage:%n");
out.printf(" -b, --bind-address=<address> %s%n", MSG.serverHelpBindAddress());
out.printf(" -c, --server-config=<config> %s%n", MSG.serverHelpServerConfig(Server.DEFAULT_CONFIGURATION_FILE));
out.printf(" -l, --logging-config=<config> %s%n", MSG.serverHelpLoggingConfig(Server.DEFAULT_LOGGING_FILE));
out.printf(" -g, --cluster-name=<name> %s%n", MSG.serverHelpClusterName());
out.printf(" -h, --help %s%n", MSG.toolHelpHelp());
out.printf(" -j, --cluster-stack=<name> %s%n", MSG.serverHelpClusterStack());
out.printf(" -k, --cluster-address=<name> %s%n", MSG.serverHelpClusterAddress());
out.printf(" -n, --node-name=<name> %s%n", MSG.serverHelpNodeName());
out.printf(" -o, --port-offset=<offset> %s%n", MSG.serverHelpPortOffset());
out.printf(" -p, --bind-port=<port> %s%n", MSG.serverHelpBindPort(Server.DEFAULT_BIND_PORT));
out.printf(" -s, --server-root=<path> %s%n", MSG.toolHelpServerRoot(Server.DEFAULT_SERVER_ROOT_DIR));
out.printf(" -v, --version %s%n", MSG.toolHelpVersion());
out.printf(" -D<name>=<value> %s%n", MSG.serverHelpProperty());
out.printf(" -P, --properties=<file> %s%n", MSG.serverHelpProperties());
}
@Override
public void version(PrintStream out) {
out.printf("%s Server %s (%s)%n", Version.getBrandName(), Version.getVersion(), Version.getCodename());
out.println("Copyright (C) Red Hat Inc. and/or its affiliates and other contributors");
out.println("License Apache License, v. 2.0. http://www.apache.org/licenses/LICENSE-2.0");
}
private void logJVMInformation() {
Logger logger = Logger.getLogger("BOOT");
logger.info("JVM " + System.getProperty("java.vm.name") + " " + System.getProperty("java.vm.vendor") + " " + System.getProperty("java.vm.version"));
ProcessInfo process = ProcessInfo.getInstance();
logger.info("JVM arguments = " + process.getArguments());
logger.info("PID = " + process.getPid());
if (logger.isLoggable(Level.FINE)) {
StringBuilder sb = new StringBuilder("Classpath JARs:" + System.lineSeparator());
URLClassLoader cl = (URLClassLoader) this.getClass().getClassLoader();
for (URL url : cl.getURLs()) {
sb.append(" ").append(url).append(System.lineSeparator());
}
logger.fine(sb.toString());
sb = new StringBuilder("System properties:" + System.lineSeparator());
for (Map.Entry<Object, Object> p : System.getProperties().entrySet()) {
sb.append(" ").append(p.getKey()).append('=').append(p.getValue()).append(System.lineSeparator());
}
logger.fine(sb.toString());
}
}
}
| 10,191
| 40.942387
| 154
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/LifecycleCallbacks.java
|
package org.infinispan.server;
import static org.infinispan.marshall.protostream.impl.SerializationContextRegistry.MarshallerType;
import java.util.EnumSet;
import java.util.concurrent.TimeUnit;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.factories.annotations.InfinispanModule;
import org.infinispan.lifecycle.ModuleLifecycle;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.protostream.impl.SerializationContextRegistry;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.server.logging.events.ServerEventLogger;
import org.infinispan.util.concurrent.BlockingManager;
import org.infinispan.util.logging.events.EventLogManager;
import org.infinispan.util.logging.events.EventLogger;
import org.infinispan.util.logging.events.EventLoggerNotifier;
/**
* LifecycleCallback for the server runtime module. Registers advanced externalizers and
* initializes the server logger
*
* @author Tristan Tarrant
* @since 8.2
*/
@InfinispanModule(name = "server-runtime", requiredModules = {"core", "query-core"})
public class LifecycleCallbacks implements ModuleLifecycle {
private EventLogger oldEventLogger;
@Override
public void cacheManagerStarting(GlobalComponentRegistry gcr, GlobalConfiguration gc) {
SerializationContextRegistry ctxRegistry = gcr.getComponent(SerializationContextRegistry.class);
ctxRegistry.addContextInitializer(MarshallerType.PERSISTENCE, new org.infinispan.server.logging.events.PersistenceContextInitializerImpl());
ctxRegistry.addContextInitializer(MarshallerType.PERSISTENCE, new org.infinispan.server.state.PersistenceContextInitializerImpl());
EmbeddedCacheManager cacheManager = gcr.getComponent(EmbeddedCacheManager.class);
InternalCacheRegistry internalCacheRegistry = gcr.getComponent(InternalCacheRegistry.class);
internalCacheRegistry.registerInternalCache(ServerEventLogger.EVENT_LOG_CACHE, getTaskHistoryCacheConfiguration(cacheManager).build(),
EnumSet.of(InternalCacheRegistry.Flag.PERSISTENT, InternalCacheRegistry.Flag.QUERYABLE));
EventLoggerNotifier notifier = gcr.getComponent(EventLoggerNotifier.class);
BlockingManager blockingManager = gcr.getComponent(BlockingManager.class);
// Install the new logger component
ServerEventLogger logger = new ServerEventLogger(cacheManager, gcr.getTimeService(), notifier, blockingManager);
oldEventLogger = gcr.getComponent(EventLogManager.class).replaceEventLogger(logger);
}
@Override
public void cacheStopping(ComponentRegistry cr, String cacheName) {
// Replace the event logger when the cache is stopping, not later when the global components are stopping
if (cacheName.equals(ServerEventLogger.EVENT_LOG_CACHE)) {
cr.getComponent(EventLogManager.class).replaceEventLogger(oldEventLogger);
}
}
private ConfigurationBuilder getTaskHistoryCacheConfiguration(EmbeddedCacheManager cacheManager) {
ConfigurationBuilder cfg = new ConfigurationBuilder();
cfg.memory().maxCount(100L).persistence().passivation(true).expiration().lifespan(7, TimeUnit.DAYS);
return cfg;
}
}
| 3,384
| 50.287879
| 146
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/DefaultExitHandler.java
|
package org.infinispan.server;
import org.infinispan.commons.util.Version;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class DefaultExitHandler extends ExitHandler {
@Override
public void exit(ExitStatus exitStatus) {
Server.log.serverStopping(Version.getBrandName());
exitFuture.complete(exitStatus);
Server.log.serverStopped(Version.getBrandName());
}
}
| 430
| 24.352941
| 57
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/BootstrapLogging.java
|
package org.infinispan.server;
import java.nio.file.Path;
import java.util.logging.LogManager;
import org.infinispan.server.logging.log4j.XmlConfigurationFactory;
/**
* Methods used to bootstrap logging in a JVM environment. This class is here for replacement with Quarkus and if it
* is updated Infinispan Quarkus must also be updated.b
*/
public class BootstrapLogging {
static void staticInitializer() {
System.setProperty("log4j2.contextSelector", "org.apache.logging.log4j.core.selector.BasicContextSelector");
System.setProperty("java.util.logging.manager", "org.apache.logging.log4j.jul.LogManager");
}
static void configureLogging(Path loggingFile) {
System.setProperty("log4j.configurationFactory", XmlConfigurationFactory.class.getName());
System.setProperty("log4j.configurationFile", loggingFile.toAbsolutePath().toString());
LogManager logManager = LogManager.getLogManager();
if (logManager instanceof org.infinispan.server.loader.LogManager) {
((org.infinispan.server.loader.LogManager) logManager).setDelegate(new org.apache.logging.log4j.jul.LogManager());
}
}
}
| 1,151
| 40.142857
| 123
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/ExitHandler.java
|
package org.infinispan.server;
import java.util.concurrent.CompletableFuture;
/**
* ExitHandler provides alternate implementations for exiting the server
*
* @author Tristan Tarrant
* @since 10.0
*/
public abstract class ExitHandler {
protected final CompletableFuture<ExitStatus> exitFuture;
ExitHandler() {
exitFuture = new CompletableFuture<>();
}
public CompletableFuture<ExitStatus> getExitFuture() {
return exitFuture;
}
public abstract void exit(ExitStatus status);
}
| 516
| 19.68
| 72
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/ShutdownHook.java
|
package org.infinispan.server;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public class ShutdownHook extends Thread {
ExitHandler exitHandler;
public ShutdownHook(ExitHandler exitHandler) {
this.exitHandler = exitHandler;
}
@Override
public void run() {
exitHandler.exit(ExitStatus.SERVER_SHUTDOWN);
}
}
| 343
| 17.105263
| 51
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/Server.java
|
package org.infinispan.server;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.net.URL;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.Principal;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.naming.spi.NamingManager;
import javax.net.ssl.SSLContext;
import javax.sql.DataSource;
import org.apache.logging.log4j.LogManager;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.ConfigurationFor;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.io.StringBuilderWriter;
import org.infinispan.commons.jdkspecific.ProcessInfo;
import org.infinispan.commons.marshall.SerializeWith;
import org.infinispan.commons.time.DefaultTimeService;
import org.infinispan.commons.time.TimeService;
import org.infinispan.commons.util.OS;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ParserRegistry;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.factories.KnownComponentNames;
import org.infinispan.factories.impl.BasicComponentRegistry;
import org.infinispan.globalstate.GlobalConfigurationManager;
import org.infinispan.lifecycle.ComponentStatus;
import org.infinispan.manager.ClusterExecutor;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.remoting.transport.jgroups.JGroupsTransport;
import org.infinispan.remoting.transport.jgroups.NamedSocketFactory;
import org.infinispan.rest.RestServer;
import org.infinispan.rest.authentication.RestAuthenticator;
import org.infinispan.rest.configuration.RestServerConfiguration;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.GlobalSecurityManager;
import org.infinispan.security.Security;
import org.infinispan.security.audit.LoggingAuditLogger;
import org.infinispan.server.configuration.DataSourceConfiguration;
import org.infinispan.server.configuration.ServerConfiguration;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
import org.infinispan.server.configuration.ServerConfigurationSerializer;
import org.infinispan.server.configuration.endpoint.EndpointConfiguration;
import org.infinispan.server.configuration.endpoint.EndpointConfigurationBuilder;
import org.infinispan.server.configuration.security.RealmConfiguration;
import org.infinispan.server.configuration.security.RealmsConfiguration;
import org.infinispan.server.configuration.security.TokenRealmConfiguration;
import org.infinispan.server.configuration.security.TransportSecurityConfiguration;
import org.infinispan.server.context.ServerInitialContextFactoryBuilder;
import org.infinispan.server.core.BackupManager;
import org.infinispan.server.core.ProtocolServer;
import org.infinispan.server.core.ServerManagement;
import org.infinispan.server.core.ServerStateManager;
import org.infinispan.server.core.backup.BackupManagerImpl;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
import org.infinispan.server.datasource.DataSourceFactory;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration;
import org.infinispan.server.logging.Log;
import org.infinispan.server.memcached.MemcachedServer;
import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration;
import org.infinispan.server.resp.RespServer;
import org.infinispan.server.resp.configuration.RespServerConfiguration;
import org.infinispan.server.router.RoutingTable;
import org.infinispan.server.router.configuration.SinglePortRouterConfiguration;
import org.infinispan.server.router.router.impl.singleport.SinglePortEndpointRouter;
import org.infinispan.server.router.routes.Route;
import org.infinispan.server.router.routes.RouteDestination;
import org.infinispan.server.router.routes.RouteSource;
import org.infinispan.server.router.routes.hotrod.HotRodServerRouteDestination;
import org.infinispan.server.router.routes.memcached.MemcachedServerRouteDestination;
import org.infinispan.server.router.routes.resp.RespServerRouteDestination;
import org.infinispan.server.router.routes.rest.RestServerRouteDestination;
import org.infinispan.server.router.routes.singleport.SinglePortRouteSource;
import org.infinispan.server.security.ElytronHTTPAuthenticator;
import org.infinispan.server.security.ElytronJMXAuthenticator;
import org.infinispan.server.security.ElytronSASLAuthenticator;
import org.infinispan.server.security.ElytronUsernamePasswordAuthenticator;
import org.infinispan.server.state.ServerStateManagerImpl;
import org.infinispan.server.tasks.admin.ServerAdminOperationsHandler;
import org.infinispan.tasks.TaskManager;
import org.infinispan.util.concurrent.BlockingManager;
import org.infinispan.util.function.SerializableFunction;
import org.infinispan.util.logging.LogFactory;
import org.wildfly.security.auth.server.ModifiableRealmIdentityIterator;
import org.wildfly.security.auth.server.ModifiableSecurityRealm;
import org.wildfly.security.auth.server.RealmUnavailableException;
import org.wildfly.security.auth.server.SecurityRealm;
import org.wildfly.security.http.basic.WildFlyElytronHttpBasicProvider;
import org.wildfly.security.http.bearer.WildFlyElytronHttpBearerProvider;
import org.wildfly.security.http.cert.WildFlyElytronHttpClientCertProvider;
import org.wildfly.security.http.digest.WildFlyElytronHttpDigestProvider;
import org.wildfly.security.http.spnego.WildFlyElytronHttpSpnegoProvider;
import org.wildfly.security.sasl.digest.WildFlyElytronSaslDigestProvider;
import org.wildfly.security.sasl.external.WildFlyElytronSaslExternalProvider;
import org.wildfly.security.sasl.gs2.WildFlyElytronSaslGs2Provider;
import org.wildfly.security.sasl.gssapi.WildFlyElytronSaslGssapiProvider;
import org.wildfly.security.sasl.localuser.WildFlyElytronSaslLocalUserProvider;
import org.wildfly.security.sasl.oauth2.WildFlyElytronSaslOAuth2Provider;
import org.wildfly.security.sasl.plain.WildFlyElytronSaslPlainProvider;
import org.wildfly.security.sasl.scram.WildFlyElytronSaslScramProvider;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
*/
public class Server implements ServerManagement, AutoCloseable {
public static final Log log = LogFactory.getLog("SERVER", Log.class);
// Properties
public static final String INFINISPAN_BIND_ADDRESS = "infinispan.bind.address";
public static final String INFINISPAN_BIND_PORT = "infinispan.bind.port";
public static final String INFINISPAN_CLUSTER_NAME = "infinispan.cluster.name";
public static final String INFINISPAN_CLUSTER_STACK = "infinispan.cluster.stack";
public static final String INFINISPAN_NODE_NAME = "infinispan.node.name";
public static final String INFINISPAN_PORT_OFFSET = "infinispan.socket.binding.port-offset";
public static final String JGROUPS_BIND_ADDRESS = "jgroups.bind.address";
public static final String JGROUPS_BIND_PORT = "jgroups.bind.port";
public static final String JGROUPS_FD_PORT_OFFSET = "jgroups.fd.port-offset";
/**
* Property name indicating the path to the server installation. If unspecified, the current working directory will
* be used
*/
public static final String INFINISPAN_SERVER_HOME_PATH = "infinispan.server.home.path";
/**
* Property name indicating the path to the root of a server instance. If unspecified, defaults to the <i>server</i>
* directory under the server home.
*/
public static final String INFINISPAN_SERVER_ROOT_PATH = "infinispan.server.root.path";
/**
* Property name indicating the path to the configuration directory of a server instance. If unspecified, defaults to
* the <i>conf</i> directory under the server root.
*/
public static final String INFINISPAN_SERVER_CONFIG_PATH = "infinispan.server.config.path";
/**
* Property name indicating the path to the data directory of a server instance. If unspecified, defaults to the
* <i>data</i> directory under the server root.
*/
public static final String INFINISPAN_SERVER_DATA_PATH = "infinispan.server.data.path";
/**
* Property name indicating the path to the log directory of a server instance. If unspecified, defaults to the
* <i>log</i> directory under the server root.
*/
public static final String INFINISPAN_SERVER_LOG_PATH = "infinispan.server.log.path";
// "Internal" properties, used by tests
public static final String INFINISPAN_LOG4J_SHUTDOWN = "infinispan.server.log4j.shutdown";
public static final String INFINISPAN_ELYTRON_NONCE_SHUTDOWN = "infinispan.security.elytron.nonceshutdown";
// Defaults
private static final String SERVER_DEFAULTS = "infinispan-defaults.xml";
public static final String DEFAULT_SERVER_CONFIG = "conf";
public static final String DEFAULT_SERVER_DATA = "data";
public static final String DEFAULT_SERVER_LIB = "lib";
public static final String DEFAULT_SERVER_LOG = "log";
public static final String DEFAULT_SERVER_ROOT_DIR = "server";
public static final String DEFAULT_SERVER_STATIC_DIR = "static";
public static final String DEFAULT_CONFIGURATION_FILE = "infinispan.xml";
public static final String DEFAULT_LOGGING_FILE = "log4j2.xml";
public static final String DEFAULT_CLUSTER_NAME = "cluster";
public static final String DEFAULT_CLUSTER_STACK = "tcp";
public static final int DEFAULT_BIND_PORT = 11222;
public static final int DEFAULT_JGROUPS_BIND_PORT = 7800;
public static final int DEFAULT_JGROUPS_FD_PORT_OFFSET = 50000;
private static final int SHUTDOWN_DELAY_SECONDS = 3;
private final ClassLoader classLoader;
private final TimeService timeService;
private final File serverHome;
private final File serverRoot;
private final File serverConf;
private final long startTime;
private final Properties properties;
private ExitHandler exitHandler = new DefaultExitHandler();
private ConfigurationBuilderHolder defaultsHolder;
private ConfigurationBuilderHolder configurationBuilderHolder;
private DefaultCacheManager cacheManager;
private Map<String, ProtocolServer> protocolServers;
private volatile ComponentStatus status;
private ServerConfiguration serverConfiguration;
private Extensions extensions;
private ServerStateManager serverStateManager;
private ScheduledExecutorService scheduler;
private TaskManager taskManager;
private ServerInitialContextFactoryBuilder initialContextFactoryBuilder;
private BlockingManager blockingManager;
private BackupManager backupManager;
private Map<String, DataSource> dataSources;
private Path dataPath;
/**
* Initializes a server with the default server root, the default configuration file and system properties
*/
public Server() {
this(
new File(DEFAULT_SERVER_ROOT_DIR),
new File(DEFAULT_CONFIGURATION_FILE),
System.getProperties()
);
}
/**
* Initializes a server with the supplied server root, configuration file and properties
*
* @param serverRoot
* @param configurationFiles
* @param properties
*/
public Server(File serverRoot, List<Path> configurationFiles, Properties properties) {
this(serverRoot, properties);
parseConfiguration(configurationFiles);
}
public Server(File serverRoot, File configuration, Properties properties) {
this(serverRoot, Collections.singletonList(configuration.toPath()), properties);
}
private Server(File serverRoot, Properties properties) {
this.classLoader = Thread.currentThread().getContextClassLoader();
this.timeService = DefaultTimeService.INSTANCE;
this.startTime = timeService.time();
this.serverHome = new File(properties.getProperty(INFINISPAN_SERVER_HOME_PATH, ""));
this.serverRoot = serverRoot;
this.properties = properties;
this.status = ComponentStatus.INSTANTIATED;
// Populate system properties unless they have already been set externally
properties.putIfAbsent(INFINISPAN_SERVER_HOME_PATH, serverHome.getAbsolutePath());
properties.putIfAbsent(INFINISPAN_SERVER_ROOT_PATH, serverRoot.getAbsolutePath());
properties.putIfAbsent(INFINISPAN_SERVER_CONFIG_PATH, new File(serverRoot, DEFAULT_SERVER_CONFIG).getAbsolutePath());
properties.putIfAbsent(INFINISPAN_SERVER_DATA_PATH, new File(serverRoot, DEFAULT_SERVER_DATA).getAbsolutePath());
properties.putIfAbsent(INFINISPAN_SERVER_LOG_PATH, new File(serverRoot, DEFAULT_SERVER_LOG).getAbsolutePath());
properties.putIfAbsent(INFINISPAN_BIND_PORT, Integer.toString(DEFAULT_BIND_PORT));
this.dataPath = Paths.get(properties.getProperty(INFINISPAN_SERVER_DATA_PATH));
this.serverConf = new File(properties.getProperty(INFINISPAN_SERVER_CONFIG_PATH));
// Register our simple naming context factory builder
registerInitialContextFactoryBuilder();
// Register only the providers that matter to us
SecurityActions.addSecurityProvider(WildFlyElytronHttpBasicProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronHttpBearerProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronHttpDigestProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronHttpClientCertProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronHttpSpnegoProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslPlainProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslDigestProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslScramProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslExternalProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslLocalUserProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslOAuth2Provider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslGssapiProvider.getInstance());
SecurityActions.addSecurityProvider(WildFlyElytronSaslGs2Provider.getInstance());
}
private void registerInitialContextFactoryBuilder() {
try {
if (!NamingManager.hasInitialContextFactoryBuilder()) {
initialContextFactoryBuilder = new ServerInitialContextFactoryBuilder();
SecurityActions.setInitialContextFactoryBuilder(initialContextFactoryBuilder);
} else {
// This will only happen when running multiple server instances in the same JVM (i.e. embedded tests)
log.warn("Could not register the ServerInitialContextFactoryBuilder. JNDI will not be available");
}
} catch (NamingException e) {
throw new RuntimeException(e);
}
}
private void parseConfiguration(List<Path> configurationFiles) {
ParserRegistry parser = new ParserRegistry(classLoader, false, properties);
try {
// load the defaults first
URL defaults = this.getClass().getClassLoader().getResource(SERVER_DEFAULTS);
defaultsHolder = parser.parse(defaults);
// Set a default audit logger
defaultsHolder.getGlobalConfigurationBuilder().security().authorization().auditLogger(new LoggingAuditLogger());
// base the global configuration to the default
configurationBuilderHolder = new ConfigurationBuilderHolder(classLoader);
GlobalConfigurationBuilder global = configurationBuilderHolder.getGlobalConfigurationBuilder();
global.read(defaultsHolder.getGlobalConfigurationBuilder().build());
// Copy all default templates
for (Map.Entry<String, ConfigurationBuilder> entry : defaultsHolder.getNamedConfigurationBuilders().entrySet()) {
configurationBuilderHolder.newConfigurationBuilder(entry.getKey()).read(entry.getValue().build());
}
// then load the user configurations
for (Path configurationFile : configurationFiles) {
if (!configurationFile.isAbsolute()) {
configurationFile = serverConf.toPath().resolve(configurationFile);
}
parser.parse(configurationFile.toUri().toURL(), configurationBuilderHolder);
}
if (log.isDebugEnabled()) {
StringBuilderWriter sw = new StringBuilderWriter();
try (ConfigurationWriter w = ConfigurationWriter.to(sw).prettyPrint(true).build()) {
Map<String, Configuration> configs = configurationBuilderHolder.getNamedConfigurationBuilders().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().build()));
parser.serialize(w, global.build(), configs);
}
log.debugf("Actual configuration: %s", sw);
}
// Amend the named caches configurations with the defaults
for (Map.Entry<String, ConfigurationBuilder> entry : configurationBuilderHolder.getNamedConfigurationBuilders().entrySet()) {
Configuration cfg = entry.getValue().build();
ConfigurationBuilder defaultCfg = defaultsHolder.getNamedConfigurationBuilders().get("org.infinispan." + cfg.clustering().cacheMode().name());
ConfigurationBuilder rebased = new ConfigurationBuilder().read(defaultCfg.build());
rebased.read(cfg);
entry.setValue(rebased);
}
// Process the server configuration
ServerConfigurationBuilder serverBuilder = global.module(ServerConfigurationBuilder.class);
// Set up transport security
TransportSecurityConfiguration transportSecurityConfiguration = serverBuilder.security().transport().create();
if (transportSecurityConfiguration.securityRealm() != null) {
String securityRealm = transportSecurityConfiguration.securityRealm();
Supplier<SSLContext> serverSSLContextSupplier = serverBuilder.serverSSLContextSupplier(securityRealm);
Supplier<SSLContext> clientSSLContextSupplier = serverBuilder.clientSSLContextSupplier(securityRealm);
NamedSocketFactory namedSocketFactory = new NamedSocketFactory(() -> clientSSLContextSupplier.get().getSocketFactory(), () -> serverSSLContextSupplier.get().getServerSocketFactory());
global.transport().addProperty(JGroupsTransport.SOCKET_FACTORY, namedSocketFactory);
Server.log.sslTransport(securityRealm);
}
// Set the operation handler on all endpoints
ServerAdminOperationsHandler adminOperationsHandler = new ServerAdminOperationsHandler(defaultsHolder);
ServerConfigurationBuilder serverConfigurationBuilder = global.module(ServerConfigurationBuilder.class);
for (EndpointConfigurationBuilder endpoint : serverConfigurationBuilder.endpoints().endpoints().values()) {
for (ProtocolServerConfigurationBuilder<?, ?, ?> connector : endpoint.connectors()) {
connector.adminOperationsHandler(adminOperationsHandler);
}
}
configurationBuilderHolder.validate();
} catch (IOException e) {
throw new CacheConfigurationException(e);
}
}
public ExitHandler getExitHandler() {
return exitHandler;
}
public void setExitHandler(ExitHandler exitHandler) {
if (status == ComponentStatus.INSTANTIATED) {
this.exitHandler = exitHandler;
} else {
throw new IllegalStateException("Cannot change exit handler on a running server");
}
}
public synchronized CompletableFuture<ExitStatus> run() {
CompletableFuture<ExitStatus> r = exitHandler.getExitFuture();
if (status == ComponentStatus.RUNNING) {
return r;
}
protocolServers = new ConcurrentHashMap<>(4);
try {
// Load any server extensions
extensions = new Extensions();
extensions.load(classLoader);
// Create the cache manager
cacheManager = new DefaultCacheManager(configurationBuilderHolder, false);
// Retrieve the server configuration
serverConfiguration = SecurityActions.getCacheManagerConfiguration(cacheManager).module(ServerConfiguration.class);
serverConfiguration.setServer(this);
// Initialize the data sources
dataSources = new HashMap<>();
InitialContext initialContext = new InitialContext();
for (DataSourceConfiguration dataSourceConfiguration : serverConfiguration.dataSources().values()) {
DataSource dataSource = DataSourceFactory.create(dataSourceConfiguration);
dataSources.put(dataSourceConfiguration.name(), dataSource);
initialContext.bind(dataSourceConfiguration.jndiName(), dataSource);
}
// Start the cache manager
SecurityActions.startCacheManager(cacheManager);
BasicComponentRegistry bcr = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(BasicComponentRegistry.class.getName());
blockingManager = bcr.getComponent(BlockingManager.class).running();
serverStateManager = new ServerStateManagerImpl(this, cacheManager, bcr.getComponent(GlobalConfigurationManager.class).running());
bcr.registerComponent(ServerStateManager.class, serverStateManager, false);
ScheduledExecutorService timeoutExecutor = bcr.getComponent(KnownComponentNames.TIMEOUT_SCHEDULE_EXECUTOR, ScheduledExecutorService.class).running();
// BlockingManager of single container used for writing the global manifest, but this will need to change
// when multiple containers are supported by the server. Similarly, the default cache manager is used to create
// the clustered locks.
backupManager = new BackupManagerImpl(blockingManager, cacheManager, dataPath);
backupManager.init();
// Register the task manager
taskManager = bcr.getComponent(TaskManager.class).running();
taskManager.registerTaskEngine(extensions.getServerTaskEngine(cacheManager));
ElytronJMXAuthenticator.init(serverConfiguration);
for (EndpointConfiguration endpoint : serverConfiguration.endpoints().endpoints()) {
// Start the protocol servers
SinglePortRouteSource routeSource = new SinglePortRouteSource();
Set<Route<? extends RouteSource, ? extends RouteDestination>> routes = ConcurrentHashMap.newKeySet();
endpoint.connectors().parallelStream().forEach(configuration -> {
try {
Class<? extends ProtocolServer> protocolServerClass = configuration.getClass().getAnnotation(ConfigurationFor.class).value().asSubclass(ProtocolServer.class);
ProtocolServer protocolServer = Util.getInstance(protocolServerClass);
protocolServer.setServerManagement(this, endpoint.admin());
if (configuration instanceof HotRodServerConfiguration) {
ElytronSASLAuthenticator.init((HotRodServerConfiguration) configuration, serverConfiguration, timeoutExecutor);
} else if (configuration instanceof RestServerConfiguration) {
ElytronHTTPAuthenticator.init((RestServerConfiguration) configuration, serverConfiguration);
} else if (configuration instanceof RespServerConfiguration) {
ElytronSASLAuthenticator.init((RespServerConfiguration) configuration, serverConfiguration, timeoutExecutor);
ElytronUsernamePasswordAuthenticator.init((RespServerConfiguration) configuration, serverConfiguration, blockingManager);
} else if (configuration instanceof MemcachedServerConfiguration) {
ElytronSASLAuthenticator.init((MemcachedServerConfiguration) configuration, serverConfiguration, timeoutExecutor);
ElytronUsernamePasswordAuthenticator.init(((MemcachedServerConfiguration) configuration).authentication().text().authenticator(), serverConfiguration, blockingManager);
}
protocolServers.put(protocolServer.getName() + "-" + configuration.name(), protocolServer);
SecurityActions.startProtocolServer(protocolServer, configuration, cacheManager);
ProtocolServerConfiguration protocolConfig = protocolServer.getConfiguration();
if (protocolConfig.startTransport()) {
log.protocolStarted(protocolServer.getName(), configuration.socketBinding(), protocolConfig.host(), protocolConfig.port());
} else {
if (protocolServer instanceof HotRodServer) {
routes.add(new Route<>(routeSource, new HotRodServerRouteDestination(protocolServer.getName(), (HotRodServer) protocolServer)));
extensions.apply((HotRodServer) protocolServer);
} else if (protocolServer instanceof RestServer) {
routes.add(new Route<>(routeSource, new RestServerRouteDestination(protocolServer.getName(), (RestServer) protocolServer)));
} else if (protocolServer instanceof RespServer) {
routes.add(new Route<>(routeSource, new RespServerRouteDestination(protocolServer.getName(), (RespServer) protocolServer)));
} else if (protocolServer instanceof MemcachedServer) {
routes.add(new Route<>(routeSource, new MemcachedServerRouteDestination(protocolServer.getName(), (MemcachedServer) protocolServer)));
}
log.protocolStarted(protocolServer.getName());
}
} catch (Throwable t) {
throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t);
}
});
// Next we start the single-port endpoints
SinglePortRouterConfiguration singlePortRouter = endpoint.singlePortRouter();
SinglePortEndpointRouter endpointServer = new SinglePortEndpointRouter(singlePortRouter);
endpointServer.start(new RoutingTable(routes), cacheManager);
protocolServers.put("endpoint-" + endpoint.socketBinding(), endpointServer);
log.protocolStarted(endpointServer.getName(), singlePortRouter.socketBinding(), singlePortRouter.host(), singlePortRouter.port());
log.endpointUrl(
Util.requireNonNullElse(cacheManager.getAddress(), "local"),
singlePortRouter.ssl().enabled() ? "https" : "http", singlePortRouter.host(), singlePortRouter.port()
);
}
serverStateManager.start();
// Change status
this.status = ComponentStatus.RUNNING;
log.serverStarted(Version.getBrandName(), Version.getBrandVersion(), timeService.timeDuration(startTime, TimeUnit.MILLISECONDS));
} catch (Exception e) {
r.completeExceptionally(e);
}
r = r.handle((status, t) -> {
if (t != null) {
Server.log.serverFailedToStart(Version.getBrandName(), t);
}
localShutdown(status);
return null;
});
return r;
}
@Override
public void serializeConfiguration(ConfigurationWriter writer) {
writer.writeStartDocument();
ServerConfigurationSerializer serializer = new ServerConfigurationSerializer();
serializer.serialize(writer, this.serverConfiguration);
writer.writeEndDocument();
}
@Override
public Map<String, String> getLoginConfiguration(ProtocolServer protocolServer) {
Map<String, String> loginConfiguration = new HashMap<>();
// Get the REST endpoint's authentication configuration
RestServerConfiguration rest = (RestServerConfiguration) protocolServer.getConfiguration();
if (rest.authentication().mechanisms().contains("BEARER_TOKEN")) {
// Find the token realm
RealmConfiguration realm = serverConfiguration.security().realms().getRealm(rest.authentication().securityRealm());
TokenRealmConfiguration realmConfiguration = realm.realmProviders().stream().filter(r -> r instanceof TokenRealmConfiguration).map(r -> (TokenRealmConfiguration) r).findFirst().get();
loginConfiguration.put("mode", "OIDC");
loginConfiguration.put("url", realmConfiguration.authServerUrl());
loginConfiguration.put("realm", realmConfiguration.name());
loginConfiguration.put("clientId", realmConfiguration.clientId());
} else {
loginConfiguration.put("mode", "HTTP");
for (String mechanism : rest.authentication().mechanisms()) {
loginConfiguration.put(mechanism, "true");
}
}
RestAuthenticator authenticator = rest.authentication().authenticator();
loginConfiguration.put("ready", Boolean.toString(authenticator == null || authenticator.isReadyForHttpChallenge()));
return loginConfiguration;
}
@Override
public void serverStop(List<String> servers) {
SecurityActions.checkPermission(cacheManager.withSubject(Security.getSubject()), AuthorizationPermission.LIFECYCLE);
ClusterExecutor executor = SecurityActions.getClusterExecutor(cacheManager);
if (servers != null && !servers.isEmpty()) {
// Find the actual addresses of the servers
List<Address> targets = cacheManager.getMembers().stream()
.filter(a -> servers.contains(a.toString()))
.collect(Collectors.toList());
executor = executor.filterTargets(targets);
// Tell all the target servers to exit
sendExitStatusToServers(executor, ExitStatus.SERVER_SHUTDOWN);
} else {
serverStopHandler(ExitStatus.SERVER_SHUTDOWN);
}
}
@Override
public void clusterStop() {
SecurityActions.checkPermission(cacheManager.withSubject(Security.getSubject()), AuthorizationPermission.LIFECYCLE);
cacheManager.getCacheNames().forEach(name -> SecurityActions.shutdownAllCaches(cacheManager));
sendExitStatusToServers(SecurityActions.getClusterExecutor(cacheManager), ExitStatus.CLUSTER_SHUTDOWN);
}
@Override
public void containerStop() {
SecurityActions.checkPermission(cacheManager.withSubject(Security.getSubject()), AuthorizationPermission.LIFECYCLE);
this.status = ComponentStatus.STOPPING;
SecurityActions.shutdownAllCaches(cacheManager);
}
private void sendExitStatusToServers(ClusterExecutor clusterExecutor, ExitStatus exitStatus) {
CompletableFuture<Void> job = clusterExecutor.submitConsumer(new ShutdownRunnable(exitStatus), (a, i, t) -> {
if (t != null) {
log.clusteredTaskError(t);
}
});
job.join();
}
private void localShutdown(ExitStatus exitStatus) {
this.status = ComponentStatus.STOPPING;
if (exitStatus == ExitStatus.CLUSTER_SHUTDOWN) {
log.clusterShutdown();
}
// Shutdown the protocol servers in parallel
protocolServers.values().parallelStream().forEach(ProtocolServer::stop);
SecurityActions.stopCacheManager(cacheManager);
// Shutdown the context and all associated resources
if (initialContextFactoryBuilder != null) {
initialContextFactoryBuilder.close();
}
// Set the status to TERMINATED
this.status = ComponentStatus.TERMINATED;
// Don't wait for the scheduler to finish
if (scheduler != null) {
scheduler.shutdown();
}
shutdownLog4jLogManager();
}
// This method is here for Quarkus to replace. If this method is moved or modified Infinispan Quarkus will also
// be required to be updated
private void shutdownLog4jLogManager() {
// Shutdown Log4j's context manually as we set shutdownHook="disable"
// Log4j's shutdownHook may run concurrently with our shutdownHook,
// disabling logging before the server has finished stopping.
if (Boolean.parseBoolean(properties.getProperty(Server.INFINISPAN_LOG4J_SHUTDOWN, "true"))) {
LogManager.shutdown();
}
}
private void serverStopHandler(ExitStatus exitStatus) {
scheduler = Executors.newSingleThreadScheduledExecutor();
// This will complete the exit handler
scheduler.schedule(() -> getExitHandler().exit(exitStatus), SHUTDOWN_DELAY_SECONDS, TimeUnit.SECONDS);
}
@SerializeWith(ShutdownRunnable.Externalizer.class)
static final class ShutdownRunnable implements SerializableFunction<EmbeddedCacheManager, Void> {
private final ExitStatus exitStatus;
ShutdownRunnable(ExitStatus exitStatus) {
this.exitStatus = exitStatus;
}
@Override
public Void apply(EmbeddedCacheManager em) {
Server server = SecurityActions.getCacheManagerConfiguration(em).module(ServerConfiguration.class).getServer();
server.serverStopHandler(exitStatus);
return null;
}
public static class Externalizer implements org.infinispan.commons.marshall.Externalizer<ShutdownRunnable> {
@Override
public void writeObject(ObjectOutput output, ShutdownRunnable object) throws IOException {
output.writeObject(object.exitStatus);
}
@Override
public ShutdownRunnable readObject(ObjectInput input) throws IOException, ClassNotFoundException {
ExitStatus exitStatus = (ExitStatus) input.readObject();
return new ShutdownRunnable(exitStatus);
}
}
}
@Override
public void close() {
if (scheduler != null) {
scheduler.shutdown();
}
}
@Override
public DefaultCacheManager getCacheManager() {
return cacheManager;
}
@Override
public ServerStateManager getServerStateManager() {
return serverStateManager;
}
public ConfigurationBuilderHolder getConfigurationBuilderHolder() {
return configurationBuilderHolder;
}
@Override
public Map<String, ProtocolServer> getProtocolServers() {
return protocolServers;
}
public ComponentStatus getStatus() {
return status;
}
@Override
public TaskManager getTaskManager() {
return taskManager;
}
@Override
public Map<String, List<Principal>> getPrincipalList() {
Map<String, List<Principal>> map = new HashMap<>();
RealmsConfiguration realms = serverConfiguration.security().realms();
for (Map.Entry<String, RealmConfiguration> realm : realms.realms().entrySet()) {
for (Map.Entry<String, SecurityRealm> subRealm : realm.getValue().realms().entrySet()) {
SecurityRealm securityRealm = subRealm.getValue();
if (securityRealm instanceof ModifiableSecurityRealm) {
ModifiableSecurityRealm msr = (ModifiableSecurityRealm) securityRealm;
List<Principal> principals = new ArrayList<>();
try (ModifiableRealmIdentityIterator iterator = msr.getRealmIdentityIterator()) {
while (iterator.hasNext()) {
principals.add(iterator.next().getRealmIdentityPrincipal());
}
} catch (RealmUnavailableException e) {
log.debugf(e, "Error while iterating identities on realm %s", subRealm.getKey());
}
if (!principals.isEmpty()) {
String name = realm.getKey() + ':' + subRealm.getKey();
map.put(name, principals);
}
}
}
}
return map;
}
@Override
public CompletionStage<Path> getServerReport() {
SecurityActions.checkPermission(cacheManager.withSubject(Security.getSubject()), AuthorizationPermission.ADMIN);
OS os = OS.getCurrentOs();
String reportFile = "bin/%s";
switch (os) {
case LINUX:
reportFile = String.format(reportFile, "report.sh");
break;
case MAC_OS:
reportFile = String.format(reportFile, "report-osx.sh");
break;
default:
return CompletableFuture.failedFuture(log.serverReportUnavailable(os));
}
long pid = ProcessInfo.getInstance().getPid();
Path home = serverHome.toPath();
Path root = serverRoot.toPath();
ProcessBuilder builder = new ProcessBuilder();
builder.command("sh", "-c", String.format("%s %s %s", home.resolve(reportFile), pid, root));
return blockingManager.supplyBlocking(() -> {
try {
Process process = builder.start();
BufferedReader reader;
if (!process.waitFor(1, TimeUnit.MINUTES))
throw new IllegalStateException("Timed out waiting report process finish");
if (process.exitValue() != 0) {
reader = new BufferedReader(new InputStreamReader(process.getErrorStream()));
String error = String.format("Report process failed. Exit code: '%d' Message: %s",
process.exitValue(), reader.lines().collect(Collectors.joining("\n")));
throw new IllegalStateException(error);
}
reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
return Paths.get(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new RuntimeException(e);
}
}, "report");
}
@Override
public BackupManager getBackupManager() {
return backupManager;
}
@Override
public Map<String, DataSource> getDataSources() {
return dataSources;
}
@Override
public Path getServerDataPath() {
return dataPath;
}
@Override
public CompletionStage<Void> flushSecurityCaches() {
return SecurityActions.getClusterExecutor(cacheManager)
.submitConsumer(ecm -> {
GlobalComponentRegistry gcr = SecurityActions.getGlobalComponentRegistry(ecm);
ServerConfiguration serverConfiguration = SecurityActions.getCacheManagerConfiguration(ecm).module(ServerConfiguration.class);
serverConfiguration.security().realms().flushRealmCaches();
gcr.getComponent(GlobalSecurityManager.class).flushLocalACLCache();
return null;
}, (a, b, c) -> {
}).thenApply(ignore -> null);
}
}
| 39,698
| 49.379442
| 203
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/ExitStatus.java
|
package org.infinispan.server;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.Serializable;
import org.infinispan.commons.marshall.MarshallUtil;
import org.infinispan.commons.marshall.SerializeWith;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
@SerializeWith(ExitStatus.Externalizer.class)
public class ExitStatus implements Serializable {
public enum ExitMode {
SERVER_SHUTDOWN,
CLUSTER_SHUTDOWN,
ERROR;
private static final ExitMode[] CACHED_VALUES = values();
static ExitMode valueOf(int ordinal) {
return CACHED_VALUES[ordinal];
}
}
public static final ExitStatus CLUSTER_SHUTDOWN = new ExitStatus(ExitMode.CLUSTER_SHUTDOWN, 0);
public static final ExitStatus SERVER_SHUTDOWN = new ExitStatus(ExitMode.SERVER_SHUTDOWN, 0);
final ExitMode mode;
final int status;
ExitStatus(ExitMode mode, int status) {
this.mode = mode;
this.status = status;
}
public static class Externalizer implements org.infinispan.commons.marshall.Externalizer<ExitStatus> {
@Override
public void writeObject(ObjectOutput output, ExitStatus object) throws IOException {
MarshallUtil.marshallEnum(object.mode, output);
output.writeInt(object.status);
}
@Override
public ExitStatus readObject(ObjectInput input) throws IOException, ClassNotFoundException {
ExitMode mode = MarshallUtil.unmarshallEnum(input, ExitMode::valueOf);
int status = input.readInt();
return new ExitStatus(mode, status);
}
}
}
| 1,644
| 28.375
| 105
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/SocketBindingsConfiguration.java
|
package org.infinispan.server.configuration;
import java.util.Map;
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.Server;
import org.infinispan.server.configuration.endpoint.SinglePortServerConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
import org.infinispan.server.network.NetworkAddress;
public class SocketBindingsConfiguration extends ConfigurationElement<SocketBindingsConfiguration> {
static final AttributeDefinition<Integer> PORT_OFFSET = AttributeDefinition.builder(Attribute.PORT_OFFSET, null, Integer.class).build();
static final AttributeDefinition<String> DEFAULT_INTERFACE = AttributeDefinition.builder(Attribute.DEFAULT_INTERFACE, null, String.class).build();
private final Map<String, SocketBindingConfiguration> socketBindings;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(SocketBindingsConfiguration.class, PORT_OFFSET, DEFAULT_INTERFACE);
}
SocketBindingsConfiguration(AttributeSet attributes, Map<String, SocketBindingConfiguration> socketBindings) {
super(Element.SOCKET_BINDINGS, attributes);
this.socketBindings = socketBindings;
}
public Integer offset() {
return attributes.attribute(SocketBindingsConfiguration.PORT_OFFSET).get();
}
Map<String, SocketBindingConfiguration> socketBindings() {
return socketBindings;
}
public void applySocketBinding(String bindingName, ProtocolServerConfigurationBuilder builder, SinglePortServerConfigurationBuilder singlePort) {
if (!socketBindings.containsKey(bindingName)) {
throw Server.log.unknownSocketBinding(bindingName);
}
SocketBindingConfiguration binding = socketBindings.get(bindingName);
NetworkAddress networkAddress = binding.interfaceConfiguration().getNetworkAddress();
String host = networkAddress.getAddress().getHostAddress();
int port = binding.port() + offset();
if (builder != singlePort) {
// Ensure we are using a different socket binding than the one used by the single-port endpoint
if (builder.startTransport() && singlePort.host().equals(host) && singlePort.port() == port) {
throw Server.log.protocolCannotUseSameSocketBindingAsEndpoint();
}
}
builder.socketBinding(bindingName).host(host).port(port);
}
}
| 2,566
| 46.537037
| 149
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/AddressType.java
|
package org.infinispan.server.configuration;
/**
* @since 10.0
*/
public enum AddressType {
ANY_ADDRESS(false),
INET_ADDRESS(true),
LINK_LOCAL(false),
GLOBAL(false),
LOOPBACK(false),
NON_LOOPBACK(false),
SITE_LOCAL(false),
MATCH_INTERFACE(true),
MATCH_ADDRESS(true),
MATCH_HOST(true);
final boolean value;
AddressType(boolean value) {
this.value = value;
}
public boolean hasValue() {
return value;
}
@Override
public String toString() {
return name().toLowerCase();
}
}
| 550
| 15.69697
| 44
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/Element.java
|
package org.infinispan.server.configuration;
import java.util.HashMap;
import java.util.Map;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public enum Element {
UNKNOWN(null), //must be first
AGGREGATE_REALM,
ANY_ADDRESS,
ATTRIBUTE,
ATTRIBUTE_MAPPING,
ATTRIBUTE_REFERENCE,
BINDINGS,
CONNECTION_PROPERTIES,
CONNECTORS,
DISTRIBUTED_REALM,
ENDPOINT,
ENDPOINTS,
ENGINE,
GLOBAL,
GROUP_PROPERTIES,
IDENTITY_MAPPING,
INET_ADDRESS,
INTERFACE,
INTERFACES,
JWT,
KERBEROS,
KEYSTORE,
LDAP_REALM,
LINK_LOCAL,
LOCAL,
LOCAL_REALM,
LOOPBACK,
MATCH_ADDRESS,
MATCH_HOST,
MATCH_INTERFACE,
NAME_REWRITER,
NON_LOOPBACK,
OAUTH2_INTROSPECTION,
OPTION,
PATH,
PATHS,
PROPERTIES,
PROPERTIES_REALM,
REGEX_PRINCIPAL_TRANSFORMER,
SECURITY,
SECURITY_REALM,
SECURITY_REALMS,
SERVER,
SERVER_IDENTITIES,
SITE_LOCAL,
SOCKET_BINDING,
SOCKET_BINDINGS,
SSL,
TOKEN_REALM,
TRUSTSTORE,
TRUSTSTORE_REALM,
USER_PASSWORD_MAPPER,
USER_PROPERTIES,
DATA_SOURCES,
DATA_SOURCE,
CONNECTION_FACTORY,
CONNECTION_POOL,
CONNECTION_PROPERTY,
CREDENTIAL_STORES,
CREDENTIAL_STORE,
CREDENTIAL_REFERENCE,
CLEAR_TEXT_CREDENTIAL,
MASKED_CREDENTIAL,
COMMAND_CREDENTIAL,
IP_FILTER,
ACCEPT,
REJECT,
CASE_PRINCIPAL_TRANSFORMER,
COMMON_NAME_PRINCIPAL_TRANSFORMER,
EVIDENCE_DECODER,
X509_SUBJECT_ALT_NAME_EVIDENCE_DECODER,
X500_SUBJECT_EVIDENCE_DECODER;
private static final Map<String, Element> ELEMENTS;
static {
final Map<String, Element> map = new HashMap<>(8);
for (Element element : values()) {
final String name = element.name;
if (name != null) {
map.put(name, element);
}
}
ELEMENTS = map;
}
private final String name;
Element(String name) {
this.name = name;
}
Element() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Element forName(final String localName) {
final Element element = ELEMENTS.get(localName);
return element == null ? UNKNOWN : element;
}
@Override
public String toString() {
return name;
}
}
| 2,238
| 17.974576
| 58
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/InterfaceConfiguration.java
|
package org.infinispan.server.configuration;
import java.util.Objects;
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.network.NetworkAddress;
/**
* @since 10.0
*/
public class InterfaceConfiguration extends ConfigurationElement<InterfaceConfiguration> {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, null, String.class).build();
private final AddressConfiguration addressConfiguration;
private final NetworkAddress networkAddress;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(InterfaceConfiguration.class, NAME);
}
InterfaceConfiguration(AttributeSet attributes, AddressConfiguration addressConfiguration, NetworkAddress networkAddress) {
super(Element.INTERFACE, attributes);
this.addressConfiguration = addressConfiguration;
this.networkAddress = networkAddress;
}
AddressConfiguration addressConfiguration() {
return addressConfiguration;
}
public String name() {
return attributes.attribute(NAME).get();
}
@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;
InterfaceConfiguration that = (InterfaceConfiguration) o;
return Objects.equals(addressConfiguration, that.addressConfiguration) && Objects.equals(networkAddress, that.networkAddress);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), addressConfiguration, networkAddress);
}
NetworkAddress getNetworkAddress() {
return networkAddress;
}
}
| 1,866
| 32.339286
| 132
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/InterfacesConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import java.util.HashMap;
import java.util.Map;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class InterfacesConfigurationBuilder implements Builder<InterfacesConfiguration> {
private final Map<String, InterfaceConfigurationBuilder> interfaces = new HashMap<>(2);
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
InterfaceConfigurationBuilder addInterface(String name) {
InterfaceConfigurationBuilder interfaceConfigurationBuilder = new InterfaceConfigurationBuilder(name);
interfaces.put(name, interfaceConfigurationBuilder);
return interfaceConfigurationBuilder;
}
@Override
public InterfacesConfiguration create() {
Map<String, InterfaceConfiguration> configurations = interfaces.values().stream().collect(Collectors.toMap(e -> e.name(), InterfaceConfigurationBuilder::create));
return new InterfacesConfiguration(configurations);
}
@Override
public InterfacesConfigurationBuilder read(InterfacesConfiguration template, Combine combine) {
interfaces.clear();
template.interfaces().forEach((n, i) -> addInterface(i.name()).read(i, combine));
return this;
}
}
| 1,402
| 34.974359
| 168
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/SocketBindingsConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.Server;
public class SocketBindingsConfigurationBuilder implements Builder<SocketBindingsConfiguration> {
private final AttributeSet attributes;
private final ServerConfigurationBuilder server;
private Map<String, SocketBindingConfigurationBuilder> socketBindings = new LinkedHashMap<>(2);
SocketBindingsConfigurationBuilder(ServerConfigurationBuilder server) {
this.server = server;
attributes = SocketBindingsConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
SocketBindingsConfigurationBuilder socketBinding(String name, int port, String interfaceName) {
SocketBindingConfigurationBuilder configurationBuilder = new SocketBindingConfigurationBuilder(server);
configurationBuilder.binding(name, port, interfaceName);
socketBindings.put(name, configurationBuilder);
return this;
}
public SocketBindingsConfigurationBuilder offset(Integer offset) {
attributes.attribute(SocketBindingsConfiguration.PORT_OFFSET).set(offset);
return this;
}
public Integer offset() {
return attributes.attribute(SocketBindingsConfiguration.PORT_OFFSET).get();
}
SocketBindingsConfigurationBuilder defaultInterface(String interfaceName) {
attributes.attribute(SocketBindingsConfiguration.DEFAULT_INTERFACE).set(interfaceName);
return this;
}
@Override
public SocketBindingsConfiguration create() {
throw new UnsupportedOperationException();
}
public SocketBindingsConfiguration create(InterfacesConfiguration interfaces) {
Map<String, SocketBindingConfiguration> bindings = new HashMap<>();
for(Map.Entry<String, SocketBindingConfigurationBuilder> e : socketBindings.entrySet()) {
String name = e.getValue().interfaceName();
if (!interfaces.exists(name)) {
throw Server.log.unknownInterface(name);
}
bindings.put(e.getKey(), e.getValue().create(interfaces.interfaces().get(name)));
}
return new SocketBindingsConfiguration(attributes.protect(), bindings);
}
@Override
public SocketBindingsConfigurationBuilder read(SocketBindingsConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
socketBindings.clear();
template.socketBindings().forEach((n, s) -> socketBinding(s.name(), s.port(), s.interfaceName()));
return this;
}
String defaultInterface() {
return attributes.attribute(SocketBindingsConfiguration.DEFAULT_INTERFACE).get();
}
}
| 2,919
| 35.049383
| 109
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/ServerConfigurationSerializer.java
|
package org.infinispan.server.configuration;
import static org.infinispan.server.configuration.ServerConfigurationParser.NAMESPACE;
import static org.infinispan.server.configuration.security.CredentialStoresConfiguration.resolvePassword;
import java.util.List;
import java.util.Map;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.attributes.AttributeSerializer;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.io.ConfigurationFormatFeature;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.serializing.ConfigurationSerializer;
import org.infinispan.rest.configuration.RestServerConfiguration;
import org.infinispan.server.configuration.endpoint.EndpointConfiguration;
import org.infinispan.server.configuration.endpoint.EndpointsConfiguration;
import org.infinispan.server.configuration.security.AggregateRealmConfiguration;
import org.infinispan.server.configuration.security.CredentialStoreConfiguration;
import org.infinispan.server.configuration.security.CredentialStoresConfiguration;
import org.infinispan.server.configuration.security.CredentialStoresConfigurationBuilder;
import org.infinispan.server.configuration.security.DistributedRealmConfiguration;
import org.infinispan.server.configuration.security.KerberosSecurityFactoryConfiguration;
import org.infinispan.server.configuration.security.LdapAttributeConfiguration;
import org.infinispan.server.configuration.security.LdapIdentityMappingConfiguration;
import org.infinispan.server.configuration.security.LdapRealmConfiguration;
import org.infinispan.server.configuration.security.LocalRealmConfiguration;
import org.infinispan.server.configuration.security.PropertiesRealmConfiguration;
import org.infinispan.server.configuration.security.RealmConfiguration;
import org.infinispan.server.configuration.security.RealmProvider;
import org.infinispan.server.configuration.security.RealmsConfiguration;
import org.infinispan.server.configuration.security.SSLConfiguration;
import org.infinispan.server.configuration.security.SecurityConfiguration;
import org.infinispan.server.configuration.security.ServerIdentitiesConfiguration;
import org.infinispan.server.configuration.security.TokenRealmConfiguration;
import org.infinispan.server.configuration.security.TrustStoreConfiguration;
import org.infinispan.server.configuration.security.TrustStoreRealmConfiguration;
import org.infinispan.server.core.configuration.ProtocolServerConfiguration;
import org.infinispan.server.hotrod.configuration.HotRodServerConfiguration;
import org.infinispan.server.memcached.configuration.MemcachedServerConfiguration;
import org.infinispan.server.security.PasswordCredentialSource;
import org.wildfly.security.auth.server.NameRewriter;
import org.wildfly.security.auth.util.RegexNameRewriter;
import org.wildfly.security.credential.source.CredentialSource;
public class ServerConfigurationSerializer
implements ConfigurationSerializer<ServerConfiguration> {
@Override
public void serialize(ConfigurationWriter writer, ServerConfiguration configuration) {
writer.writeStartElement(Element.SERVER);
writer.writeDefaultNamespace(NAMESPACE + Version.getMajorMinor());
writeInterfaces(writer, configuration.interfaces);
writeSocketBindings(writer, configuration.socketBindings);
writeSecurity(writer, configuration.security());
writeDataSources(writer, configuration.dataSources());
writeEndpoints(writer, configuration.endpoints());
writer.writeEndElement();
}
private void writeInterfaces(ConfigurationWriter writer, InterfacesConfiguration networkInterfaces) {
writer.writeStartListElement(Element.INTERFACES, true);
for (InterfaceConfiguration netIf : networkInterfaces.interfaces().values()) {
writer.writeStartElement(Element.INTERFACE);
writer.writeAttribute(Attribute.NAME, netIf.name());
AddressType addressType = netIf.addressConfiguration().addressType();
if (addressType.hasValue()) {
writer.writeStartElement(addressType);
writer.writeAttribute(Attribute.VALUE, netIf.addressConfiguration().value());
writer.writeEndElement();
} else {
writer.writeEmptyElement(addressType);
}
writer.writeEndElement();
}
writer.writeEndListElement();
}
private void writeSocketBindings(ConfigurationWriter writer, SocketBindingsConfiguration socketBindings) {
if (writer.hasFeature(ConfigurationFormatFeature.MIXED_ELEMENTS)) {
writer.writeStartElement(Element.SOCKET_BINDINGS);
socketBindings.attributes().write(writer);
for (SocketBindingConfiguration socketBinding : socketBindings.socketBindings().values()) {
writer.writeStartElement(Element.SOCKET_BINDING);
socketBinding.attributes().write(writer);
writer.writeEndElement(); // SOCKET_BINDING
}
writer.writeEndElement(); // SOCKET_BINDINGS
} else {
writer.writeStartElement(Element.SOCKET_BINDINGS);
socketBindings.attributes().write(writer);
writer.writeStartArrayElement(Element.SOCKET_BINDING);
for (SocketBindingConfiguration socketBinding : socketBindings.socketBindings().values()) {
socketBinding.write(writer);
}
writer.writeEndArrayElement(); // SOCKET_BINDING
writer.writeEndElement(); // SOCKET_BINDINGS
}
}
private void writeSecurity(ConfigurationWriter writer, SecurityConfiguration security) {
writer.writeStartElement(Element.SECURITY);
writeCredentialStores(writer, security.credentialStores());
writeSecurityRealms(writer, security.realms());
writer.writeEndElement();
}
private void writeCredentialStores(ConfigurationWriter writer, CredentialStoresConfiguration credentialStores) {
if (!credentialStores.credentialStores().isEmpty()) {
writer.writeStartArrayElement(Element.CREDENTIAL_STORES);
for (CredentialStoreConfiguration credentialStore : credentialStores.credentialStores().values()) {
credentialStore.write(writer);
}
writer.writeEndArrayElement();
}
}
private void writeSecurityRealms(ConfigurationWriter writer, RealmsConfiguration realms) {
if (!realms.realms().isEmpty()) {
writer.writeStartArrayElement(Element.SECURITY_REALMS);
for (Map.Entry<String, RealmConfiguration> e : realms.realms().entrySet()) {
RealmConfiguration realm = e.getValue();
writer.writeStartElement(Element.SECURITY_REALM);
realm.attributes().write(writer);
writeServerIdentities(writer, realm.serverIdentitiesConfiguration());
for (RealmProvider provider : realm.realmProviders()) {
if (provider instanceof LdapRealmConfiguration) {
writeRealm(writer, (LdapRealmConfiguration) provider);
} else if (provider instanceof LocalRealmConfiguration) {
writeRealm(writer, (LocalRealmConfiguration) provider);
} else if (provider instanceof PropertiesRealmConfiguration) {
writeRealm(writer, (PropertiesRealmConfiguration) provider);
} else if (provider instanceof TokenRealmConfiguration) {
writeRealm(writer, (TokenRealmConfiguration) provider);
} else if (provider instanceof TrustStoreConfiguration) {
writeRealm(writer, (TrustStoreRealmConfiguration) provider);
} else if (provider instanceof DistributedRealmConfiguration) {
writeRealm(writer, (DistributedRealmConfiguration) provider);
} else if (provider instanceof AggregateRealmConfiguration) {
writeRealm(writer, (AggregateRealmConfiguration) provider);
}
}
writer.writeEndElement(); // SECURITY_REALM
}
writer.writeEndArrayElement(); // SECURITY_REALMS
}
}
private void writeRealm(ConfigurationWriter writer, LdapRealmConfiguration realm) {
if (realm.name() != null) {
writer.writeStartElement(Element.LDAP_REALM);
realm.attributes().write(writer);
NameRewriter nameRewriter = realm.nameRewriter();
if (nameRewriter != null) {
writer.writeStartElement(Element.NAME_REWRITER);
if (nameRewriter instanceof RegexNameRewriter) {
RegexNameRewriter regexNameRewriter = (RegexNameRewriter) nameRewriter;
writer.writeStartElement(Element.REGEX_PRINCIPAL_TRANSFORMER);
writer.writeAttribute(Attribute.PATTERN, regexNameRewriter.getPattern().pattern());
writer.writeAttribute(Attribute.REPLACEMENT, regexNameRewriter.getReplacement());
writer.writeEndElement();
} else {
throw new IllegalArgumentException();
}
writer.writeEndElement();
}
LdapIdentityMappingConfiguration identity = realm.identityMapping();
writer.writeStartElement(Element.IDENTITY_MAPPING);
identity.attributes().write(writer);
if (!identity.attributeMappings().isEmpty()) {
writer.writeStartElement(Element.ATTRIBUTE_MAPPING);
for (LdapAttributeConfiguration mapping : identity.attributeMappings()) {
mapping.write(writer);
}
writer.writeEndElement(); // ATTRIBUTE_MAPPING
}
identity.userPasswordMapper().attributes().write(writer, Element.USER_PASSWORD_MAPPER);
writer.writeEndElement(); // IDENTITY_MAPPING
writer.writeEndElement(); // LDAP_REALM
}
}
private void writeRealm(ConfigurationWriter writer, LocalRealmConfiguration realm) {
realm.attributes().write(writer, Element.LOCAL_REALM);
}
private void writeRealm(ConfigurationWriter writer, TokenRealmConfiguration realm) {
if (realm.name() != null) {
writer.writeStartElement(Element.TOKEN_REALM);
realm.attributes().write(writer);
realm.jwtConfiguration().attributes().write(writer, Element.JWT);
realm.oauth2Configuration().attributes().write(writer, Element.OAUTH2_INTROSPECTION);
writer.writeEndElement();
}
}
private void writeRealm(ConfigurationWriter writer, PropertiesRealmConfiguration realm) {
if (realm.userProperties().digestRealmName() != null) {
writer.writeStartElement(Element.PROPERTIES_REALM);
realm.attributes().write(writer);
realm.userProperties().attributes().write(writer, Element.USER_PROPERTIES);
realm.groupProperties().attributes().write(writer, Element.GROUP_PROPERTIES);
writer.writeEndElement();
}
}
private void writeRealm(ConfigurationWriter writer, TrustStoreRealmConfiguration realm) {
realm.write(writer);
}
private void writeRealm(ConfigurationWriter writer, AggregateRealmConfiguration realm) {
realm.write(writer);
}
private void writeRealm(ConfigurationWriter writer, DistributedRealmConfiguration realm) {
realm.write(writer);
}
private void writeServerIdentities(ConfigurationWriter writer, ServerIdentitiesConfiguration identities) {
SSLConfiguration ssl = identities.sslConfiguration();
List<KerberosSecurityFactoryConfiguration> kerberosList = identities.kerberosConfigurations();
if (ssl != null || !kerberosList.isEmpty()) {
writer.writeStartElement(Element.SERVER_IDENTITIES);
if (ssl != null) {
writer.writeStartElement(Element.SSL);
ssl.keyStore().write(writer);
TrustStoreConfiguration trustStore = ssl.trustStore();
if (trustStore != null) {
trustStore.write(writer);
}
ssl.engine().write(writer);
writer.writeEndElement();
}
if (!kerberosList.isEmpty()) {
for (KerberosSecurityFactoryConfiguration kerberos : kerberosList) {
kerberos.write(writer);
}
}
writer.writeEndElement();
}
}
private void writeDataSources(ConfigurationWriter writer, Map<String, DataSourceConfiguration> dataSources) {
if (!dataSources.isEmpty()) {
writer.writeStartListElement(Element.DATA_SOURCES, true);
for (Map.Entry<String, DataSourceConfiguration> configuration : dataSources.entrySet()) {
AttributeSet attributes = configuration.getValue().attributes();
writer.writeStartElement(Element.DATA_SOURCE);
attributes.write(writer, DataSourceConfiguration.NAME);
attributes.write(writer, DataSourceConfiguration.JNDI_NAME);
attributes.write(writer, DataSourceConfiguration.STATISTICS);
writer.writeStartElement(Element.CONNECTION_FACTORY);
attributes.write(writer, DataSourceConfiguration.DRIVER);
attributes.write(writer, DataSourceConfiguration.USERNAME);
attributes.write(writer, DataSourceConfiguration.URL);
attributes.write(writer, DataSourceConfiguration.INITIAL_SQL);
attributes.write(writer, DataSourceConfiguration.PASSWORD);
attributes.write(writer, DataSourceConfiguration.CONNECTION_PROPERTIES);
writer.writeEndElement(); // Element.CONNECTION_FACTORY
writer.writeStartElement(Element.CONNECTION_POOL);
attributes.write(writer, DataSourceConfiguration.BACKGROUND_VALIDATION);
attributes.write(writer, DataSourceConfiguration.BLOCKING_TIMEOUT);
attributes.write(writer, DataSourceConfiguration.IDLE_REMOVAL);
attributes.write(writer, DataSourceConfiguration.INITIAL_SIZE);
attributes.write(writer, DataSourceConfiguration.LEAK_DETECTION);
attributes.write(writer, DataSourceConfiguration.MAX_SIZE);
attributes.write(writer, DataSourceConfiguration.MIN_SIZE);
writer.writeEndElement(); // Element.CONNECTION_POOL
writer.writeEndElement(); // Element.DATA_SOURCE
}
writer.writeEndListElement();
}
}
private void writeEndpoints(ConfigurationWriter writer, EndpointsConfiguration endpoints) {
writer.writeStartElement(Element.ENDPOINTS);
for (EndpointConfiguration endpoint : endpoints.endpoints()) {
writer.writeStartElement(Element.ENDPOINT);
endpoint.attributes().write(writer);
for (ProtocolServerConfiguration connector : endpoint.connectors()) {
if (connector instanceof HotRodServerConfiguration) {
writeConnector(writer, (HotRodServerConfiguration) connector);
} else if (connector instanceof RestServerConfiguration) {
writeConnector(writer, (RestServerConfiguration) connector);
} else if (connector instanceof MemcachedServerConfiguration) {
writeConnector(writer, (MemcachedServerConfiguration) connector);
}
}
writer.writeEndElement();
}
writer.writeEndElement();
}
private void writeConnector(ConfigurationWriter writer, HotRodServerConfiguration connector) {
if (connector.isImplicit()) {
return;
}
writer.writeStartElement(org.infinispan.server.hotrod.configuration.Element.HOTROD_CONNECTOR);
connector.attributes().write(writer);
connector.topologyCache().write(writer);
if (connector.authentication().enabled()) {
writer.writeStartElement(org.infinispan.server.hotrod.configuration.Element.AUTHENTICATION);
connector.authentication().attributes().write(writer);
connector.authentication().sasl().write(writer);
writer.writeEndElement();
}
connector.encryption().write(writer);
writer.writeEndElement();
}
private void writeConnector(ConfigurationWriter writer, RestServerConfiguration connector) {
if (connector.isImplicit()) {
return;
}
writer.writeStartElement(org.infinispan.server.configuration.rest.Element.REST_CONNECTOR);
connector.attributes().write(writer);
if (connector.authentication().enabled()) {
writer.writeStartElement(org.infinispan.server.configuration.rest.Element.AUTHENTICATION);
connector.authentication().attributes().write(writer);
writer.writeEndElement();
}
connector.cors().write(writer);
connector.encryption().write(writer);
writer.writeEndElement();
}
private void writeConnector(ConfigurationWriter writer, MemcachedServerConfiguration connector) {
if (connector.isImplicit()) {
return;
}
connector.write(writer);
}
public static AttributeSerializer<Supplier<CredentialSource>> CREDENTIAL = (writer, name, value) -> {
if (value instanceof PasswordCredentialSource) {
String credential = writer.clearTextSecrets() ? new String(resolvePassword(value)) : "***";
writer.writeAttribute(name, credential);
} else if (value instanceof CredentialStoresConfigurationBuilder.CredentialStoreSourceSupplier) {
CredentialStoresConfigurationBuilder.CredentialStoreSourceSupplier credentialSupplier = (CredentialStoresConfigurationBuilder.CredentialStoreSourceSupplier) value;
writer.writeStartElement(Element.CREDENTIAL_REFERENCE);
writer.writeAttribute(Attribute.STORE, credentialSupplier.getStore());
writer.writeAttribute(Attribute.ALIAS, credentialSupplier.getAlias());
writer.writeEndElement();
} else {
throw new IllegalArgumentException();
}
};
}
| 17,866
| 49.903134
| 172
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/DataSourcesConfiguration.java
|
package org.infinispan.server.configuration;
import java.util.List;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
/**
* Holds configuration related to data sources
* @author Tristan Tarrant
* @since 11.0
*/
public class DataSourcesConfiguration extends ConfigurationElement<DataSourcesConfiguration> {
private final List<DataSourceConfiguration> dataSources;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(DataSourcesConfiguration.class);
}
DataSourcesConfiguration(AttributeSet attributes, List<DataSourceConfiguration> dataSources) {
super(Element.DATA_SOURCES, attributes);
this.dataSources = dataSources;
}
public List<DataSourceConfiguration> dataSources() {
return dataSources;
}
}
| 868
| 27.966667
| 97
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/AddressConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import static org.infinispan.server.configuration.AddressConfiguration.VALUE;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
class AddressConfigurationBuilder implements Builder<AddressConfiguration> {
private final AttributeSet attributes;
private AddressType addressType;
AddressConfigurationBuilder() {
this.attributes = AddressConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
AddressConfigurationBuilder type(AddressType addressType, String value) {
this.addressType = addressType;
attributes.attribute(VALUE).set(value);
return this;
}
AddressType addressType() {
return addressType;
}
public String value() {
return attributes.attribute(VALUE).get();
}
@Override
public AddressConfiguration create() {
return new AddressConfiguration(attributes.protect(), addressType);
}
@Override
public AddressConfigurationBuilder read(AddressConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.addressType = template.addressType();
return this;
}
}
| 1,381
| 25.576923
| 92
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/DataSourceConfiguration.java
|
package org.infinispan.server.configuration;
import static org.infinispan.server.configuration.security.CredentialStoresConfiguration.resolvePassword;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.configuration.attributes.PropertiesAttributeSerializer;
import org.wildfly.security.credential.source.CredentialSource;
import io.agroal.api.configuration.AgroalConnectionFactoryConfiguration;
import io.agroal.api.configuration.AgroalConnectionFactoryConfiguration.TransactionIsolation;
public class DataSourceConfiguration extends ConfigurationElement<DataSourceConfiguration> {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, null, String.class).build();
static final AttributeDefinition<String> JNDI_NAME = AttributeDefinition.builder(Attribute.JNDI_NAME, null, String.class).build();
static final AttributeDefinition<Boolean> STATISTICS = AttributeDefinition.builder(Attribute.STATISTICS, false, Boolean.class).build();
static final AttributeDefinition<String> DRIVER = AttributeDefinition.builder(Attribute.DRIVER, null, String.class).build();
static final AttributeDefinition<String> URL = AttributeDefinition.builder(Attribute.URL, null, String.class).build();
static final AttributeDefinition<String> USERNAME = AttributeDefinition.builder(Attribute.USERNAME, null, String.class).build();
static final AttributeDefinition<Supplier<CredentialSource>> PASSWORD = AttributeDefinition.builder(Attribute.PASSWORD, null, (Class<Supplier<CredentialSource>>) (Class<?>) Supplier.class).serializer(ServerConfigurationSerializer.CREDENTIAL).build();
static final AttributeDefinition<String> INITIAL_SQL = AttributeDefinition.builder(Attribute.NEW_CONNECTION_SQL, null, String.class).build();
static final AttributeDefinition<TransactionIsolation> TRANSACTION_ISOLATION = AttributeDefinition.builder(Attribute.TRANSACTION_ISOLATION, TransactionIsolation.READ_COMMITTED, AgroalConnectionFactoryConfiguration.TransactionIsolation.class).build();
static final AttributeDefinition<Integer> MAX_SIZE = AttributeDefinition.builder(Attribute.MAX_SIZE, Integer.MAX_VALUE, Integer.class).build();
static final AttributeDefinition<Integer> MIN_SIZE = AttributeDefinition.builder(Attribute.MIN_SIZE, 0, Integer.class).build();
static final AttributeDefinition<Integer> INITIAL_SIZE = AttributeDefinition.builder(Attribute.INITIAL_SIZE, 0, Integer.class).build();
static final AttributeDefinition<Long> BLOCKING_TIMEOUT = AttributeDefinition.builder(Attribute.BLOCKING_TIMEOUT, 0L, Long.class).build();
static final AttributeDefinition<Long> BACKGROUND_VALIDATION = AttributeDefinition.builder(Attribute.BACKGROUND_VALIDATION, 0L, Long.class).build();
static final AttributeDefinition<Long> VALIDATE_ON_ACQUISITION = AttributeDefinition.builder(Attribute.VALIDATE_ON_ACQUISITION, 0L, Long.class).build();
static final AttributeDefinition<Long> LEAK_DETECTION = AttributeDefinition.builder(Attribute.LEAK_DETECTION, 0L, Long.class).build();
static final AttributeDefinition<Integer> IDLE_REMOVAL = AttributeDefinition.builder(Attribute.IDLE_REMOVAL, 0, Integer.class).build();
static final AttributeDefinition<Map<String, String>> CONNECTION_PROPERTIES = AttributeDefinition.builder(Element.CONNECTION_PROPERTY, null, (Class<Map<String, String>>) (Class<?>) Map.class)
.initializer(LinkedHashMap::new)
.serializer(new PropertiesAttributeSerializer(Element.CONNECTION_PROPERTIES, Element.CONNECTION_PROPERTY, Attribute.NAME))
.immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(DataSourceConfiguration.class, NAME, JNDI_NAME, STATISTICS, DRIVER, URL,
USERNAME, PASSWORD, INITIAL_SQL, TRANSACTION_ISOLATION, MAX_SIZE, MIN_SIZE, INITIAL_SIZE,
BLOCKING_TIMEOUT, BACKGROUND_VALIDATION, VALIDATE_ON_ACQUISITION, LEAK_DETECTION, IDLE_REMOVAL,
CONNECTION_PROPERTIES);
}
DataSourceConfiguration(AttributeSet attributes) {
super(Element.DATA_SOURCE, attributes);
}
public String name() {
return attributes.attribute(NAME).get();
}
public String jndiName() {
return attributes.attribute(JNDI_NAME).get();
}
public Boolean statistics() {
return attributes.attribute(STATISTICS).get();
}
public String driver() {
return attributes.attribute(DRIVER).get();
}
public String username() {
return attributes.attribute(USERNAME).get();
}
public char[] password() {
return resolvePassword(attributes.attribute(PASSWORD));
}
public String url() {
return attributes.attribute(URL).get();
}
public TransactionIsolation transactionIsolation() {
return attributes.attribute(TRANSACTION_ISOLATION).get();
}
public String initialSql() {
return attributes.attribute(INITIAL_SQL).get();
}
public int maxSize() {
return attributes.attribute(MAX_SIZE).get();
}
public int minSize() {
return attributes.attribute(MIN_SIZE).get();
}
public int initialSize() {
return attributes.attribute(INITIAL_SIZE).get();
}
public long blockingTimeout() {
return attributes.attribute(BLOCKING_TIMEOUT).get();
}
public long backgroundValidation() {
return attributes.attribute(BACKGROUND_VALIDATION).get();
}
public long validateOnAcquisition() {
return attributes.attribute(VALIDATE_ON_ACQUISITION).get();
}
public long leakDetection() {
return attributes.attribute(LEAK_DETECTION).get();
}
public int idleRemoval() {
return attributes.attribute(IDLE_REMOVAL).get();
}
public Map<String, String> connectionProperties() {
return attributes.attribute(CONNECTION_PROPERTIES).get();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
DataSourceConfiguration that = (DataSourceConfiguration) o;
return attributes.equals(that.attributes);
}
@Override
public int hashCode() {
return attributes.hashCode();
}
@Override
public String toString() {
return "DataSourceConfiguration{" +
"attributes=" + attributes +
'}';
}
}
| 6,589
| 42.642384
| 253
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/InterfacesConfiguration.java
|
package org.infinispan.server.configuration;
import java.util.Map;
public class InterfacesConfiguration {
private final Map<String, InterfaceConfiguration> interfaces;
InterfacesConfiguration(Map<String, InterfaceConfiguration> interfaces) {
this.interfaces = interfaces;
}
public Map<String, InterfaceConfiguration> interfaces() {
return interfaces;
}
boolean exists(String interfaceName) {
return interfaces.containsKey(interfaceName);
}
}
| 486
| 23.35
| 76
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/AddressConfiguration.java
|
package org.infinispan.server.configuration;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
/**
* @since 10.0
*/
class AddressConfiguration extends ConfigurationElement<AddressConfiguration> {
static final AttributeDefinition<String> VALUE = AttributeDefinition.builder(Attribute.VALUE, null, String.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(AddressConfiguration.class, VALUE);
}
private final AddressType addressType;
AddressConfiguration(AttributeSet attributes, AddressType addressType) {
super(addressType, attributes);
this.addressType = addressType;
}
AddressType addressType() {
return addressType;
}
public String value() {
return attributes.attribute(VALUE).get();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
AddressConfiguration that = (AddressConfiguration) o;
if (!attributes.equals(that.attributes)) return false;
return addressType == that.addressType;
}
@Override
public int hashCode() {
int result = attributes.hashCode();
result = 31 * result + addressType.hashCode();
return result;
}
@Override
public String toString() {
return "AddressConfiguration{" +
"attributes=" + attributes +
", addressType=" + addressType +
'}';
}
}
| 1,645
| 26.898305
| 125
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/ServerConfigurationParser.java
|
package org.infinispan.server.configuration;
import static org.infinispan.configuration.parsing.ParseUtils.ignoreAttribute;
import static org.infinispan.util.logging.Log.CONFIG;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Objects;
import java.util.Properties;
import java.util.function.Supplier;
import java.util.regex.Pattern;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.internal.PrivateGlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ConfigurationParser;
import org.infinispan.configuration.parsing.Namespace;
import org.infinispan.configuration.parsing.Namespaces;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.configuration.parsing.ParserScope;
import org.infinispan.rest.configuration.RestServerConfigurationBuilder;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.endpoint.EndpointConfigurationBuilder;
import org.infinispan.server.configuration.security.AggregateRealmConfigurationBuilder;
import org.infinispan.server.configuration.security.CredentialStoreConfiguration;
import org.infinispan.server.configuration.security.CredentialStoreConfigurationBuilder;
import org.infinispan.server.configuration.security.CredentialStoresConfigurationBuilder;
import org.infinispan.server.configuration.security.DistributedRealmConfigurationBuilder;
import org.infinispan.server.configuration.security.GroupsPropertiesConfigurationBuilder;
import org.infinispan.server.configuration.security.JwtConfigurationBuilder;
import org.infinispan.server.configuration.security.KerberosSecurityFactoryConfigurationBuilder;
import org.infinispan.server.configuration.security.KeyStoreConfigurationBuilder;
import org.infinispan.server.configuration.security.LdapAttributeConfigurationBuilder;
import org.infinispan.server.configuration.security.LdapIdentityMappingConfigurationBuilder;
import org.infinispan.server.configuration.security.LdapRealmConfigurationBuilder;
import org.infinispan.server.configuration.security.LdapUserPasswordMapperConfigurationBuilder;
import org.infinispan.server.configuration.security.LocalRealmConfigurationBuilder;
import org.infinispan.server.configuration.security.OAuth2ConfigurationBuilder;
import org.infinispan.server.configuration.security.PropertiesRealmConfigurationBuilder;
import org.infinispan.server.configuration.security.RealmConfigurationBuilder;
import org.infinispan.server.configuration.security.RealmsConfigurationBuilder;
import org.infinispan.server.configuration.security.SSLConfigurationBuilder;
import org.infinispan.server.configuration.security.SSLEngineConfigurationBuilder;
import org.infinispan.server.configuration.security.ServerIdentitiesConfigurationBuilder;
import org.infinispan.server.configuration.security.TokenRealmConfigurationBuilder;
import org.infinispan.server.configuration.security.TrustStoreConfigurationBuilder;
import org.infinispan.server.configuration.security.TrustStoreRealmConfigurationBuilder;
import org.infinispan.server.configuration.security.UserPropertiesConfigurationBuilder;
import org.infinispan.server.core.configuration.IpFilterConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
import org.infinispan.server.core.configuration.SaslConfigurationBuilder;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.server.memcached.configuration.MemcachedServerConfigurationBuilder;
import org.infinispan.server.resp.configuration.RespServerConfigurationBuilder;
import org.infinispan.server.security.PasswordCredentialSource;
import org.kohsuke.MetaInfServices;
import org.wildfly.security.auth.realm.ldap.DirContextFactory;
import org.wildfly.security.auth.server.EvidenceDecoder;
import org.wildfly.security.auth.server.NameRewriter;
import org.wildfly.security.auth.util.CaseNameRewriter;
import org.wildfly.security.auth.util.RegexNameRewriter;
import org.wildfly.security.credential.source.CredentialSource;
import org.wildfly.security.x500.GeneralName;
import org.wildfly.security.x500.principal.X500SubjectEvidenceDecoder;
import org.wildfly.security.x500.principal.X509SubjectAltNameEvidenceDecoder;
import io.agroal.api.configuration.AgroalConnectionFactoryConfiguration;
/**
* Server endpoint configuration parser
*
* @author Tristan Tarrant
* @since 10.0
*/
@MetaInfServices
@Namespaces({
@Namespace(root = "server"),
@Namespace(uri = "urn:infinispan:server:*", root = "server"),
@Namespace(uri = "urn:infinispan:server:*", root = "transport"),
})
public class ServerConfigurationParser implements ConfigurationParser {
private static final org.infinispan.util.logging.Log coreLog = org.infinispan.util.logging.LogFactory.getLog(ServerConfigurationParser.class);
static final String NAMESPACE = "urn:infinispan:server:";
public static final EnumSet<Element> CREDENTIAL_TYPES = EnumSet.of(Element.CREDENTIAL_REFERENCE, Element.CLEAR_TEXT_CREDENTIAL, Element.MASKED_CREDENTIAL, Element.COMMAND_CREDENTIAL);
public static String ENDPOINTS_SCOPE = "ENDPOINTS";
@Override
public Namespace[] getNamespaces() {
return ParseUtils.getNamespaceAnnotations(getClass());
}
public static Element nextElement(ConfigurationReader reader) {
if (reader.nextElement() == ConfigurationReader.ElementType.END_ELEMENT) {
return null;
}
return Element.forName(reader.getLocalName());
}
@Override
public void readElement(ConfigurationReader reader, ConfigurationBuilderHolder holder) {
if (!holder.inScope(ParserScope.GLOBAL)) {
throw coreLog.invalidScope(ParserScope.GLOBAL.name(), holder.getScope());
}
GlobalConfigurationBuilder builder = holder.getGlobalConfigurationBuilder();
Element element = Element.forName(reader.getLocalName());
switch (element) {
case SERVER: {
builder.addModule(PrivateGlobalConfigurationBuilder.class).serverMode(true);
ServerConfigurationBuilder serverConfigurationBuilder = builder.addModule(ServerConfigurationBuilder.class).properties(reader.getProperties());
parseServerElements(reader, holder, serverConfigurationBuilder);
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseServerElements(ConfigurationReader reader, ConfigurationBuilderHolder holder, ServerConfigurationBuilder builder) {
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case INTERFACES:
parseInterfaces(reader, builder);
break;
case SOCKET_BINDINGS:
parseSocketBindings(reader, builder);
break;
case SECURITY:
parseSecurity(reader, builder);
break;
case DATA_SOURCES:
parseDataSources(reader, builder);
break;
case ENDPOINTS:
holder.pushScope(ENDPOINTS_SCOPE);
if (reader.getSchema().since(13, 0)) {
parseEndpoints(reader, holder, builder);
} else {
while (reader.inTag()) {
parseEndpoint(reader, holder, builder, Element.ENDPOINTS, null, null);
}
}
holder.popScope();
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private void parseSocketBindings(ConfigurationReader reader, ServerConfigurationBuilder builder) {
SocketBindingsConfigurationBuilder socketBindings = builder.socketBindings();
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.DEFAULT_INTERFACE, Attribute.PORT_OFFSET);
while (reader.inTag(Element.SOCKET_BINDINGS)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case BINDINGS: {
break;
}
case SOCKET_BINDING: {
if (reader.getAttributeCount() > 0) {
socketBindings.defaultInterface(attributes[0]).offset(Integer.parseInt(attributes[1]));
parseSocketBinding(reader, socketBindings);
}
break;
}
default:
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseSocketBinding(ConfigurationReader reader, SocketBindingsConfigurationBuilder builder) {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.NAME, Attribute.PORT);
String name = attributes[0];
int port = Integer.parseInt(attributes[1]);
String interfaceName = builder.defaultInterface();
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
case PORT:
// already parsed
break;
case INTERFACE:
interfaceName = value;
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
builder.socketBinding(name, port, interfaceName);
ParseUtils.requireNoContent(reader);
}
private void parseInterfaces(ConfigurationReader reader, ServerConfigurationBuilder builder) {
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case INTERFACES: // JSON/YAML array
case INTERFACE:
parseInterface(reader, builder);
break;
default:
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseInterface(ConfigurationReader reader, ServerConfigurationBuilder builder) {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.NAME);
String name = attributes[0];
InterfaceConfigurationBuilder iface = builder.interfaces().addInterface(name);
boolean matched = false;
CacheConfigurationException cce = Server.log.invalidNetworkConfiguration();
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
try {
switch (element) {
case INET_ADDRESS:
String value = ParseUtils.requireSingleAttribute(reader, Attribute.VALUE);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.INET_ADDRESS, value);
}
break;
case LINK_LOCAL:
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.LINK_LOCAL, null);
}
break;
case GLOBAL:
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.GLOBAL, null);
}
break;
case LOOPBACK:
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.LOOPBACK, null);
}
break;
case NON_LOOPBACK:
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.NON_LOOPBACK, null);
}
break;
case SITE_LOCAL:
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.SITE_LOCAL, null);
}
break;
case MATCH_INTERFACE:
value = ParseUtils.requireSingleAttribute(reader, Attribute.VALUE);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.MATCH_INTERFACE, value);
}
break;
case MATCH_ADDRESS:
value = ParseUtils.requireSingleAttribute(reader, Attribute.VALUE);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.MATCH_ADDRESS, value);
}
break;
case MATCH_HOST:
value = ParseUtils.requireSingleAttribute(reader, Attribute.VALUE);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.MATCH_HOST, value);
}
break;
case ANY_ADDRESS:
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
if (!matched) {
iface.address(AddressType.ANY_ADDRESS, null);
}
break;
default:
throw ParseUtils.unexpectedElement(reader);
}
matched = true;
} catch (IOException e) {
cce.addSuppressed(e);
}
}
if (!matched) {
throw cce;
}
}
private void parseSecurity(ConfigurationReader reader, ServerConfigurationBuilder builder) {
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case CREDENTIAL_STORES:
parseCredentialStores(reader, builder);
break;
case SECURITY_REALMS:
parseSecurityRealms(reader, builder);
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private void parseCredentialStores(ConfigurationReader reader, ServerConfigurationBuilder builder) {
CredentialStoresConfigurationBuilder credentialStores = builder.security().credentialStores();
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case CREDENTIAL_STORE:
case CREDENTIAL_STORES:
parseCredentialStore(reader, builder, credentialStores);
break;
default:
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseCredentialStore(ConfigurationReader reader, ServerConfigurationBuilder builder, CredentialStoresConfigurationBuilder credentialStores) {
String name = ParseUtils.requireAttributes(reader, Attribute.NAME, Attribute.PATH)[0];
CredentialStoreConfigurationBuilder credentialStoreBuilder = credentialStores.addCredentialStore(name);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
// Already seen.
break;
case PATH:
credentialStoreBuilder.path(value);
break;
case RELATIVE_TO:
credentialStoreBuilder.relativeTo(value);
break;
case TYPE:
credentialStoreBuilder.type(value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
Element element = nextElement(reader);
if (CREDENTIAL_TYPES.contains(element)) {
credentialStoreBuilder.credential(parseCredentialReference(reader, builder));
element = nextElement(reader);
}
if (element != null) {
throw ParseUtils.unexpectedElement(reader, element);
}
}
private Supplier<CredentialSource> parseCredentialReference(ConfigurationReader reader, ServerConfigurationBuilder builder) {
switch (Element.forName(reader.getLocalName())) {
case CREDENTIAL_REFERENCE: {
String store = null;
String alias = null;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case STORE:
store = value;
break;
case ALIAS:
alias = value;
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
return builder.security().credentialStores().getCredential(store, alias);
}
case CLEAR_TEXT_CREDENTIAL: {
String credential = ParseUtils.requireSingleAttribute(reader, Attribute.CLEAR_TEXT);
ParseUtils.requireNoContent(reader);
return new CredentialStoreConfiguration.ClearTextCredentialSupplier(credential.toCharArray());
}
case MASKED_CREDENTIAL: {
String masked = ParseUtils.requireSingleAttribute(reader, Attribute.MASKED);
ParseUtils.requireNoContent(reader);
return new CredentialStoreConfiguration.MaskedCredentialSupplier(masked);
}
case COMMAND_CREDENTIAL: {
String command = ParseUtils.requireSingleAttribute(reader, Attribute.COMMAND);
ParseUtils.requireNoContent(reader);
return new CredentialStoreConfiguration.CommandCredentialSupplier(command);
}
default:
throw ParseUtils.unexpectedElement(reader);
}
}
private void parseSecurityRealms(ConfigurationReader reader, ServerConfigurationBuilder builder) {
RealmsConfigurationBuilder realms = builder.security().realms();
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case SECURITY_REALM:
case SECURITY_REALMS:
parseSecurityRealm(reader, builder, realms);
break;
default:
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseSecurityRealm(ConfigurationReader reader, ServerConfigurationBuilder builder, RealmsConfigurationBuilder realms) {
String name = ParseUtils.requireAttributes(reader, Attribute.NAME)[0];
RealmConfigurationBuilder securityRealmBuilder = realms.addSecurityRealm(name);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
// Already seen.
break;
case DEFAULT_REALM:
securityRealmBuilder.defaultRealm(value);
break;
case CACHE_LIFESPAN:
securityRealmBuilder.cacheLifespan(ParseUtils.parseLong(reader, i, value));
break;
case CACHE_MAX_SIZE:
securityRealmBuilder.cacheMaxSize(ParseUtils.parseInt(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case EVIDENCE_DECODER:
parseEvidenceDecoder(reader, securityRealmBuilder);
break;
case SERVER_IDENTITIES:
parseServerIdentities(reader, builder, securityRealmBuilder);
break;
case AGGREGATE_REALM:
parseAggregateRealm(reader, securityRealmBuilder.aggregateConfiguration());
break;
case DISTRIBUTED_REALM:
parseDistributedRealm(reader, securityRealmBuilder.distributedConfiguration());
break;
case LDAP_REALM:
parseLdapRealm(reader, builder, securityRealmBuilder.ldapConfiguration());
break;
case LOCAL_REALM:
parseLocalRealm(reader, securityRealmBuilder.localConfiguration());
break;
case PROPERTIES_REALM:
parsePropertiesRealm(reader, securityRealmBuilder.propertiesConfiguration(), name);
break;
case TOKEN_REALM:
parseTokenRealm(reader, builder, securityRealmBuilder.tokenConfiguration());
break;
case TRUSTSTORE_REALM:
if (reader.getSchema().since(12, 1)) {
parseTrustStoreRealm(reader, securityRealmBuilder.trustStoreConfiguration());
} else {
parseLegacyTrustStoreRealm(reader, builder, securityRealmBuilder.trustStoreConfiguration(), securityRealmBuilder.serverIdentitiesConfiguration());
}
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private void parseEvidenceDecoder(ConfigurationReader reader, RealmConfigurationBuilder builder) {
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case X500_SUBJECT_EVIDENCE_DECODER:
ParseUtils.requireNoAttributes(reader);
ParseUtils.requireNoContent(reader);
builder.evidenceDecoder(new X500SubjectEvidenceDecoder());
break;
case X509_SUBJECT_ALT_NAME_EVIDENCE_DECODER:
builder.evidenceDecoder(parseX509SubjectAltNameEvidenceDecoder(reader));
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private EvidenceDecoder parseX509SubjectAltNameEvidenceDecoder(ConfigurationReader reader) {
int segment = 0;
int altNameType = -1;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case ALT_NAME_TYPE: {
switch (value) {
case "rfc822Name":
altNameType = GeneralName.RFC_822_NAME;
break;
case "dnsName":
altNameType = GeneralName.DNS_NAME;
break;
case "directoryName":
altNameType = GeneralName.DIRECTORY_NAME;
break;
case "uniformResourceIdentifier":
altNameType = GeneralName.URI_NAME;
break;
case "ipAddress":
altNameType = GeneralName.IP_ADDRESS;
break;
case "registeredID":
altNameType = GeneralName.REGISTERED_ID;
break;
default:
throw ParseUtils.invalidAttributeValue(reader, 0);
}
break;
}
case SEGMENT:
segment = ParseUtils.parseInt(reader, i, value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
return new X509SubjectAltNameEvidenceDecoder(altNameType, segment);
}
private void parseAggregateRealm(ConfigurationReader reader, AggregateRealmConfigurationBuilder builder) {
String authnRealm = ParseUtils.requireAttributes(reader, Attribute.AUTHENTICATION_REALM)[0];
builder.authnRealm(authnRealm);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
builder.name(value);
break;
case AUTHENTICATION_REALM:
// Already seen
break;
case AUTHORIZATION_REALMS:
String[] realms = value.split("\\s+");
builder.authzRealms(realms);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
Element element = nextElement(reader);
if (element == Element.NAME_REWRITER) {
builder.nameRewriter(parseNameRewriter(reader));
element = nextElement(reader);
}
if (element != null) {
throw ParseUtils.unexpectedElement(reader);
}
}
private void parseTokenRealm(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, TokenRealmConfigurationBuilder tokenRealmConfigBuilder) {
String[] required = ParseUtils.requireAttributes(reader, Attribute.NAME, Attribute.AUTH_SERVER_URL, Attribute.CLIENT_ID);
tokenRealmConfigBuilder.name(required[0]).authServerUrl(required[1]).clientId(required[2]);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
case AUTH_SERVER_URL:
case CLIENT_ID:
// Already seen
break;
case PRINCIPAL_CLAIM:
tokenRealmConfigBuilder.principalClaim(value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
Element element = nextElement(reader);
if (element == Element.JWT) {
parseJWT(reader, serverBuilder, tokenRealmConfigBuilder.jwtConfiguration());
element = nextElement(reader);
} else if (element == Element.OAUTH2_INTROSPECTION) {
parseOauth2Introspection(reader, serverBuilder, tokenRealmConfigBuilder.oauth2Configuration());
element = nextElement(reader);
}
if (element != null) {
throw ParseUtils.unexpectedElement(reader);
}
}
private void parseJWT(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, JwtConfigurationBuilder jwtBuilder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case ISSUER:
jwtBuilder.issuers(reader.getListAttributeValue(i));
break;
case AUDIENCE:
jwtBuilder.audience(reader.getListAttributeValue(i));
break;
case PUBLIC_KEY:
jwtBuilder.publicKey(value);
break;
case JKU_TIMEOUT:
jwtBuilder.jkuTimeout(ParseUtils.parseLong(reader, i, value));
break;
case CLIENT_SSL_CONTEXT:
jwtBuilder.clientSSLContext(value);
break;
case HOST_NAME_VERIFICATION_POLICY:
jwtBuilder.hostNameVerificationPolicy(value);
break;
case CONNECTION_TIMEOUT:
jwtBuilder.connectionTimeout(ParseUtils.parseInt(reader, i, value));
break;
case READ_TIMEOUT:
jwtBuilder.readTimeout(ParseUtils.parseInt(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseOauth2Introspection(ConfigurationReader reader, ServerConfigurationBuilder serverBuilder, OAuth2ConfigurationBuilder oauthBuilder) {
String[] required = ParseUtils.requireAttributes(reader, Attribute.CLIENT_ID, Attribute.INTROSPECTION_URL);
oauthBuilder.clientId(required[0]).introspectionUrl(required[1]);
boolean credentialSet = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case CLIENT_ID:
case INTROSPECTION_URL:
// Already seen
break;
case CLIENT_SECRET:
oauthBuilder.clientSecret(value.toCharArray());
credentialSet = true;
break;
case CLIENT_SSL_CONTEXT:
oauthBuilder.clientSSLContext(value);
break;
case HOST_NAME_VERIFICATION_POLICY:
oauthBuilder.hostVerificationPolicy(value);
break;
case CONNECTION_TIMEOUT:
oauthBuilder.connectionTimeout(ParseUtils.parseInt(reader, i, value));
break;
case READ_TIMEOUT:
oauthBuilder.readTimeout(ParseUtils.parseInt(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
Element element = nextElement(reader);
if (element == Element.CREDENTIAL_REFERENCE) {
if (credentialSet) {
throw Server.log.cannotOverrideCredential(Element.OAUTH2_INTROSPECTION.toString(), Attribute.CLIENT_SECRET.toString());
}
oauthBuilder.clientSecret(parseCredentialReference(reader, serverBuilder));
credentialSet = true;
element = nextElement(reader);
}
if (!credentialSet) {
throw Server.log.missingCredential(Element.OAUTH2_INTROSPECTION.toString(), Attribute.CLIENT_SECRET.toString());
}
if (element != null) {
throw ParseUtils.unexpectedElement(reader, element);
}
}
private void parseLdapRealm(ConfigurationReader reader, ServerConfigurationBuilder builder, LdapRealmConfigurationBuilder ldapRealmConfigBuilder) {
boolean credentialSet = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
ldapRealmConfigBuilder.name(value);
break;
case URL:
ldapRealmConfigBuilder.url(value);
break;
case PRINCIPAL:
ldapRealmConfigBuilder.principal(value);
break;
case CREDENTIAL:
ldapRealmConfigBuilder.credential(value.toCharArray());
credentialSet = true;
break;
case DIRECT_VERIFICATION:
ldapRealmConfigBuilder.directEvidenceVerification(ParseUtils.parseBoolean(reader, i, value));
break;
case PAGE_SIZE:
ldapRealmConfigBuilder.pageSize(ParseUtils.parseInt(reader, i, value));
break;
case SEARCH_DN:
if (reader.getSchema().since(13, 0)) {
throw ParseUtils.unexpectedAttribute(reader, i);
} else {
ldapRealmConfigBuilder.identityMapping().searchBaseDn(value);
}
break;
case RDN_IDENTIFIER:
if (reader.getSchema().since(13, 0)) {
throw ParseUtils.unexpectedAttribute(reader, i);
} else {
ldapRealmConfigBuilder.identityMapping().rdnIdentifier(value);
}
break;
case CONNECTION_POOLING:
ldapRealmConfigBuilder.connectionPooling(ParseUtils.parseBoolean(reader, i, value));
break;
case CONNECTION_TIMEOUT:
ldapRealmConfigBuilder.connectionTimeout(ParseUtils.parseInt(reader, i, value));
break;
case READ_TIMEOUT:
ldapRealmConfigBuilder.readTimeout(ParseUtils.parseInt(reader, i, value));
break;
case REFERRAL_MODE:
ldapRealmConfigBuilder.referralMode(DirContextFactory.ReferralMode.valueOf(value.toUpperCase()));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case CREDENTIAL_REFERENCE:
if (credentialSet) {
throw Server.log.cannotOverrideCredential(Element.LDAP_REALM.toString(), Attribute.CREDENTIAL.toString());
}
ldapRealmConfigBuilder.credential(parseCredentialReference(reader, builder));
credentialSet = true;
break;
case NAME_REWRITER:
ldapRealmConfigBuilder.nameRewriter(parseNameRewriter(reader));
break;
case IDENTITY_MAPPING:
parseLdapIdentityMapping(reader, ldapRealmConfigBuilder.identityMapping());
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
if (!credentialSet) {
throw Server.log.missingCredential(Element.LDAP_REALM.toString(), Attribute.CREDENTIAL.toString());
}
}
private NameRewriter parseNameRewriter(ConfigurationReader reader) {
final NameRewriter nameRewriter;
switch (nextElement(reader)) {
case CASE_PRINCIPAL_TRANSFORMER: {
boolean uppercase = true;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
if (Objects.requireNonNull(attribute) == Attribute.UPPERCASE) {
uppercase = ParseUtils.parseBoolean(reader, i, value);
} else {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
nameRewriter = new CaseNameRewriter(uppercase);
ParseUtils.requireNoContent(reader);
break;
}
case COMMON_NAME_PRINCIPAL_TRANSFORMER: {
ParseUtils.requireNoAttributes(reader);
nameRewriter = new RegexNameRewriter(Pattern.compile("cn=([^,]+),.*", Pattern.CASE_INSENSITIVE), "$1", false);
ParseUtils.requireNoContent(reader);
break;
}
case REGEX_PRINCIPAL_TRANSFORMER: {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.PATTERN, Attribute.REPLACEMENT);
boolean replaceAll = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
case PATTERN:
case REPLACEMENT:
// Already seen
break;
case REPLACE_ALL:
replaceAll = ParseUtils.parseBoolean(reader, i, value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
nameRewriter = new RegexNameRewriter(Pattern.compile(attributes[0]), attributes[1], replaceAll);
ParseUtils.requireNoContent(reader);
break;
}
default:
throw ParseUtils.unexpectedElement(reader);
}
ParseUtils.requireNoContent(reader);
return nameRewriter;
}
private void parseLdapIdentityMapping(ConfigurationReader reader, LdapIdentityMappingConfigurationBuilder identityMapBuilder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case SEARCH_DN:
identityMapBuilder.searchBaseDn(value);
break;
case RDN_IDENTIFIER:
identityMapBuilder.rdnIdentifier(value);
break;
case SEARCH_RECURSIVE:
identityMapBuilder.searchRecursive(ParseUtils.parseBoolean(reader, i, value));
break;
case SEARCH_TIME_LIMIT:
identityMapBuilder.searchTimeLimit(ParseUtils.parseInt(reader, i, value));
break;
case FILTER_NAME:
identityMapBuilder.filterName(value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case ATTRIBUTE_MAPPING:
parseLdapAttributeMapping(reader, identityMapBuilder);
break;
case USER_PASSWORD_MAPPER:
parseLdapUserPasswordMapper(reader, identityMapBuilder.userPasswordMapper());
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private void parseLdapUserPasswordMapper(ConfigurationReader reader, LdapUserPasswordMapperConfigurationBuilder userMapperBuilder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case FROM:
userMapperBuilder.from(value);
break;
case WRITABLE:
if (reader.getSchema().since(13, 0)) {
throw ParseUtils.unexpectedAttribute(reader, i);
} else {
ignoreAttribute(reader, i);
}
break;
case VERIFIABLE:
userMapperBuilder.verifiable(ParseUtils.parseBoolean(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseLdapAttributeMapping(ConfigurationReader reader, LdapIdentityMappingConfigurationBuilder identityMappingConfigurationBuilder) {
ParseUtils.requireNoAttributes(reader);
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case ATTRIBUTE:
parseLdapAttributeFilter(reader, identityMappingConfigurationBuilder.addAttributeMapping());
break;
case ATTRIBUTE_REFERENCE:
parseLdapAttributeReference(reader, identityMappingConfigurationBuilder.addAttributeMapping());
break;
case ATTRIBUTE_MAPPING:
// JSON mode, determine the type from the attribute
for (int i = 0; i < reader.getAttributeCount(); i++) {
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case FILTER:
parseLdapAttributeFilter(reader, identityMappingConfigurationBuilder.addAttributeMapping());
break;
case REFERENCE:
parseLdapAttributeReference(reader, identityMappingConfigurationBuilder.addAttributeMapping());
break;
}
}
break;
default:
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseLdapAttributeFilter(ConfigurationReader reader, LdapAttributeConfigurationBuilder attributeBuilder) {
String filter = ParseUtils.requireAttributes(reader, Attribute.FILTER)[0];
parseLdapAttribute(reader, attributeBuilder.filter(filter));
}
private void parseLdapAttributeReference(ConfigurationReader reader, LdapAttributeConfigurationBuilder attributeBuilder) {
String reference = ParseUtils.requireAttributes(reader, Attribute.REFERENCE)[0];
parseLdapAttribute(reader, attributeBuilder.reference(reference));
}
private void parseLdapAttribute(ConfigurationReader reader, LdapAttributeConfigurationBuilder attributeBuilder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case REFERENCE:
case FILTER:
// Already seen
break;
case FROM:
attributeBuilder.from(value);
break;
case TO:
attributeBuilder.to(value);
break;
case FILTER_DN:
attributeBuilder.filterBaseDn(value);
break;
case SEARCH_RECURSIVE:
attributeBuilder.searchRecursive(ParseUtils.parseBoolean(reader, i, value));
break;
case ROLE_RECURSION:
attributeBuilder.roleRecursion(ParseUtils.parseInt(reader, i, value));
break;
case ROLE_RECURSION_NAME:
attributeBuilder.roleRecursionName(value);
break;
case EXTRACT_RDN:
attributeBuilder.extractRdn(value);
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseLocalRealm(ConfigurationReader reader, LocalRealmConfigurationBuilder localBuilder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
localBuilder.name(value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parsePropertiesRealm(ConfigurationReader reader, PropertiesRealmConfigurationBuilder propertiesBuilder, String realmName) {
UserPropertiesConfigurationBuilder userPropertiesBuilder = propertiesBuilder.userProperties().digestRealmName(realmName);
GroupsPropertiesConfigurationBuilder groupsBuilder = propertiesBuilder.groupProperties();
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
propertiesBuilder.name(value);
userPropertiesBuilder.digestRealmName(value);
break;
case GROUPS_ATTRIBUTE:
propertiesBuilder.groupAttribute(value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case USER_PROPERTIES: {
String path = ParseUtils.requireAttributes(reader, Attribute.PATH)[0];
String relativeTo = Server.INFINISPAN_SERVER_CONFIG_PATH;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case PATH:
// Already seen
break;
case RELATIVE_TO:
relativeTo = value;
break;
case DIGEST_REALM_NAME:
userPropertiesBuilder.digestRealmName(value);
break;
case PLAIN_TEXT:
userPropertiesBuilder.plainText(ParseUtils.parseBoolean(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
userPropertiesBuilder.path(path).relativeTo(relativeTo);
ParseUtils.requireNoContent(reader);
break;
}
case GROUP_PROPERTIES: {
String path = ParseUtils.requireAttributes(reader, Attribute.PATH)[0];
String relativeTo = Server.INFINISPAN_SERVER_CONFIG_PATH;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case PATH:
// Already seen
break;
case RELATIVE_TO:
relativeTo = reader.getAttributeValue(i);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
groupsBuilder.path(path).relativeTo(relativeTo);
ParseUtils.requireNoContent(reader);
break;
}
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private void parseDistributedRealm(ConfigurationReader reader, DistributedRealmConfigurationBuilder builder) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
builder.name(value);
break;
case REALMS:
ParseUtils.requireAttributes(reader, Attribute.REALMS)[0].split("\\s+");
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseServerIdentities(ConfigurationReader reader, ServerConfigurationBuilder builder, RealmConfigurationBuilder securityRealmBuilder) {
ServerIdentitiesConfigurationBuilder identitiesBuilder = securityRealmBuilder.serverIdentitiesConfiguration();
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case SSL:
parseSSL(reader, builder, identitiesBuilder);
break;
case KERBEROS:
parseKerberos(reader, identitiesBuilder);
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private void parseSSL(ConfigurationReader reader, ServerConfigurationBuilder builder, ServerIdentitiesConfigurationBuilder identitiesBuilder) {
SSLConfigurationBuilder serverIdentitiesBuilder = identitiesBuilder.sslConfiguration();
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case KEYSTORE:
parseKeyStore(reader, builder, serverIdentitiesBuilder.keyStore());
break;
case TRUSTSTORE:
parseTrustStore(reader, builder, serverIdentitiesBuilder.trustStore());
break;
case ENGINE:
parseSSLEngine(reader, serverIdentitiesBuilder.engine());
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
}
private void parseSSLEngine(ConfigurationReader reader, SSLEngineConfigurationBuilder engine) {
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case ENABLED_PROTOCOLS:
engine.enabledProtocols(reader.getListAttributeValue(i));
break;
case ENABLED_CIPHERSUITES:
engine.enabledCiphersuitesFilter(reader.getAttributeValue(i));
break;
case ENABLED_CIPHERSUITES_TLS13:
engine.enabledCiphersuitesNames(reader.getAttributeValue(i));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseKeyStore(ConfigurationReader reader, ServerConfigurationBuilder builder, KeyStoreConfigurationBuilder keyStoreBuilder) {
boolean credentialSet = false, pathSet = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case PATH:
keyStoreBuilder.path(value);
pathSet = true;
break;
case PROVIDER:
keyStoreBuilder.provider(value);
break;
case TYPE:
keyStoreBuilder.type(value);
break;
case RELATIVE_TO:
keyStoreBuilder.relativeTo(value);
break;
case KEYSTORE_PASSWORD:
CONFIG.attributeDeprecatedUseOther(Attribute.KEYSTORE_PASSWORD, Element.KEYSTORE, Attribute.PASSWORD);
case PASSWORD:
keyStoreBuilder.keyStorePassword(value.toCharArray());
credentialSet = true;
break;
case ALIAS:
keyStoreBuilder.alias(value);
break;
case KEY_PASSWORD:
CONFIG.configDeprecated(Attribute.KEY_PASSWORD);
keyStoreBuilder.keyPassword(value.toCharArray());
break;
case GENERATE_SELF_SIGNED_CERTIFICATE_HOST:
keyStoreBuilder.generateSelfSignedCertificateHost(value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
Element element = nextElement(reader);
if (element == Element.CREDENTIAL_REFERENCE) {
if (credentialSet) {
throw Server.log.cannotOverrideCredential(Element.KEYSTORE.toString(), Attribute.KEYSTORE_PASSWORD.toString());
}
keyStoreBuilder.keyStorePassword(parseCredentialReference(reader, builder));
credentialSet = true;
element = nextElement(reader);
}
if (!credentialSet && pathSet) {
throw Server.log.missingCredential(Element.KEYSTORE.toString(), Attribute.KEYSTORE_PASSWORD.toString());
}
if (element != null) {
throw ParseUtils.unexpectedElement(reader, element);
}
}
private void parseTrustStore(ConfigurationReader reader, ServerConfigurationBuilder builder, TrustStoreConfigurationBuilder trustStoreBuilder) {
boolean credentialSet = false, pathSet = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case PATH:
trustStoreBuilder.path(value);
pathSet = true;
break;
case PROVIDER:
trustStoreBuilder.provider(value);
break;
case TYPE:
trustStoreBuilder.type(value);
break;
case RELATIVE_TO:
trustStoreBuilder.relativeTo(value);
break;
case PASSWORD:
trustStoreBuilder.password(value.toCharArray());
credentialSet = true;
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
Element element = nextElement(reader);
if (element == Element.CREDENTIAL_REFERENCE) {
if (credentialSet) {
throw Server.log.cannotOverrideCredential(Element.TRUSTSTORE.toString(), Attribute.PASSWORD.toString());
}
trustStoreBuilder.password(parseCredentialReference(reader, builder));
credentialSet = true;
element = nextElement(reader);
}
if (!credentialSet && pathSet) {
throw Server.log.missingCredential(Element.TRUSTSTORE.toString(), Attribute.PASSWORD.toString());
}
if (element != null) {
throw ParseUtils.unexpectedElement(reader, element);
}
}
private void parseTrustStoreRealm(ConfigurationReader reader, TrustStoreRealmConfigurationBuilder trustStoreBuilder) {
String name = "trust";
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
name = value;
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
trustStoreBuilder.name(name);
}
private void parseLegacyTrustStoreRealm(ConfigurationReader reader, ServerConfigurationBuilder builder, TrustStoreRealmConfigurationBuilder trustStoreBuilder, ServerIdentitiesConfigurationBuilder serverIdentitiesConfigurationBuilder) {
String name = "trust";
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.PATH);
String path = attributes[0];
String relativeTo = (String) reader.getProperty(Server.INFINISPAN_SERVER_CONFIG_PATH);
String keyStoreProvider = null;
Supplier<CredentialSource> keyStorePassword = null;
boolean credentialSet = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case NAME:
name = value;
break;
case PATH:
// Already seen
break;
case PROVIDER:
keyStoreProvider = value;
break;
case KEYSTORE_PASSWORD:
keyStorePassword = new PasswordCredentialSource(value.toCharArray());
credentialSet = true;
break;
case RELATIVE_TO:
relativeTo = ParseUtils.requireAttributeProperty(reader, i);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
Element element = nextElement(reader);
if (element == Element.CREDENTIAL_REFERENCE) {
if (credentialSet) {
throw Server.log.cannotOverrideCredential(Element.TRUSTSTORE_REALM.toString(), Attribute.KEYSTORE_PASSWORD.toString());
}
keyStorePassword = parseCredentialReference(reader, builder);
credentialSet = true;
element = nextElement(reader);
}
if (!credentialSet) {
throw Server.log.missingCredential(Element.TRUSTSTORE_REALM.toString(), Attribute.KEYSTORE_PASSWORD.toString());
}
if (element != null) {
throw ParseUtils.unexpectedElement(reader, element);
}
serverIdentitiesConfigurationBuilder.sslConfiguration().trustStore().path(path).relativeTo(relativeTo).password(keyStorePassword).provider(keyStoreProvider);
trustStoreBuilder.name(name);
}
private void parseKerberos(ConfigurationReader reader, ServerIdentitiesConfigurationBuilder identitiesBuilder) {
KerberosSecurityFactoryConfigurationBuilder builder = identitiesBuilder.addKerberosConfiguration();
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.KEYTAB_PATH, Attribute.PRINCIPAL);
builder.keyTabPath(attributes[0]);
builder.principal(attributes[1]);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case KEYTAB_PATH:
case PRINCIPAL:
// Already seen, ignore
break;
case RELATIVE_TO:
builder.relativeTo(value);
break;
case DEBUG:
builder.debug(ParseUtils.parseBoolean(reader, i, value));
break;
case FAIL_CACHE:
builder.failCache(ParseUtils.parseLong(reader, i, value));
break;
case MECHANISM_NAMES:
for (String name : ParseUtils.getListAttributeValue(value)) {
builder.addMechanismName(name);
}
break;
case MECHANISM_OIDS:
for (String oid : ParseUtils.getListAttributeValue(value)) {
builder.addMechanismOid(oid);
}
break;
case MINIMUM_REMAINING_LIFETIME:
builder.minimumRemainingLifetime(ParseUtils.parseInt(reader, i, value));
break;
case OBTAIN_KERBEROS_TICKET:
builder.obtainKerberosTicket(ParseUtils.parseBoolean(reader, i, value));
break;
case REQUEST_LIFETIME:
builder.requestLifetime(ParseUtils.parseInt(reader, i, value));
break;
case REQUIRED:
builder.checkKeyTab(ParseUtils.parseBoolean(reader, i, value));
break;
case SERVER:
builder.server(ParseUtils.parseBoolean(reader, i, value));
break;
case WRAP_GSS_CREDENTIAL:
builder.wrapGssCredential(ParseUtils.parseBoolean(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
// Add all options
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case OPTION:
String[] option = ParseUtils.requireAttributes(reader, Attribute.NAME, Attribute.VALUE);
builder.addOption(option[0], option[1]);
break;
default:
throw ParseUtils.unexpectedElement(reader);
}
}
builder.build(reader.getProperties());
}
private void parseDataSources(ConfigurationReader reader, ServerConfigurationBuilder builder) {
DataSourcesConfigurationBuilder dataSources = builder.dataSources();
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case DATA_SOURCES: {
parseDataSource(reader, element, builder, dataSources);
reader.require(ConfigurationReader.ElementType.END_ELEMENT, null, Element.DATA_SOURCES);
break;
}
case DATA_SOURCE: {
parseDataSource(reader, element, builder, dataSources);
break;
}
default:
throw ParseUtils.unexpectedElement(reader);
}
}
}
private void parseDataSource(ConfigurationReader reader, Element wrapper, ServerConfigurationBuilder builder, DataSourcesConfigurationBuilder dataSourcesBuilder) {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.NAME, Attribute.JNDI_NAME);
String name = attributes[0];
String jndiName = attributes[1];
DataSourceConfigurationBuilder dataSourceBuilder = dataSourcesBuilder.dataSource(name, jndiName);
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case JNDI_NAME:
case NAME:
// already parsed
break;
case STATISTICS:
dataSourceBuilder.statistics(ParseUtils.parseBoolean(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
EnumSet<Element> required = EnumSet.of(Element.CONNECTION_FACTORY);
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case CONNECTION_FACTORY:
parseDataSourceConnectionFactory(reader, builder, dataSourceBuilder);
required.remove(Element.CONNECTION_FACTORY);
break;
case CONNECTION_POOL:
parseDataSourceConnectionPool(reader, dataSourceBuilder);
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
if (!required.isEmpty()) {
throw ParseUtils.missingRequiredElement(reader, required);
}
}
private void parseDataSourceConnectionFactory(ConfigurationReader reader, ServerConfigurationBuilder builder, DataSourceConfigurationBuilder dataSourceBuilder) {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.DRIVER);
dataSourceBuilder.driver(attributes[0]);
boolean credentialSet = false;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case DRIVER:
// already parsed
break;
case USERNAME:
dataSourceBuilder.username(value);
break;
case PASSWORD:
dataSourceBuilder.password(value.toCharArray());
credentialSet = true;
break;
case URL:
dataSourceBuilder.url(value);
break;
case TRANSACTION_ISOLATION:
dataSourceBuilder.transactionIsolation(ParseUtils.parseEnum(reader, i, AgroalConnectionFactoryConfiguration.TransactionIsolation.class, value));
break;
case NEW_CONNECTION_SQL:
dataSourceBuilder.newConnectionSql(value);
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case CREDENTIAL_REFERENCE:
if (credentialSet) {
throw Server.log.cannotOverrideCredential(Element.CONNECTION_FACTORY.toString(), Attribute.PASSWORD.toString());
}
dataSourceBuilder.password(parseCredentialReference(reader, builder));
credentialSet = true;
break;
case CONNECTION_PROPERTIES:
for (int i = 0; i < reader.getAttributeCount(); i++) {
dataSourceBuilder.addProperty(reader.getAttributeName(i), reader.getAttributeValue(i));
}
ParseUtils.requireNoContent(reader);
break;
case CONNECTION_PROPERTY:
String name = ParseUtils.requireAttributes(reader, Attribute.NAME)[0];
String value;
if (reader.getAttributeCount() == 1) {
value = reader.getElementText();
} else {
value = ParseUtils.requireAttributes(reader, Attribute.VALUE)[0];
ParseUtils.requireNoContent(reader);
}
dataSourceBuilder.addProperty(name, value);
break;
default:
throw ParseUtils.unexpectedElement(reader, element);
}
}
if (!credentialSet) {
throw Server.log.missingCredential(Element.CONNECTION_FACTORY.toString(), Attribute.PASSWORD.toString());
}
}
private void parseDataSourceConnectionPool(ConfigurationReader reader, DataSourceConfigurationBuilder dataSourceBuilder) {
String[] attributes = ParseUtils.requireAttributes(reader, Attribute.MAX_SIZE);
dataSourceBuilder.maxSize(Integer.parseInt(attributes[0]));
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case MAX_SIZE:
// already parsed
break;
case MIN_SIZE:
dataSourceBuilder.minSize(ParseUtils.parseInt(reader, i, value));
break;
case INITIAL_SIZE:
dataSourceBuilder.initialSize(ParseUtils.parseInt(reader, i, value));
break;
case BLOCKING_TIMEOUT:
dataSourceBuilder.blockingTimeout(ParseUtils.parseInt(reader, i, value));
break;
case BACKGROUND_VALIDATION:
dataSourceBuilder.backgroundValidation(ParseUtils.parseLong(reader, i, value));
break;
case VALIDATE_ON_ACQUISITION:
dataSourceBuilder.validateOnAcquisition(ParseUtils.parseLong(reader, i, value));
break;
case LEAK_DETECTION:
dataSourceBuilder.leakDetection(ParseUtils.parseLong(reader, i, value));
break;
case IDLE_REMOVAL:
dataSourceBuilder.idleRemoval(ParseUtils.parseInt(reader, i, value));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
ParseUtils.requireNoContent(reader);
}
private void parseEndpoints(ConfigurationReader reader, ConfigurationBuilderHolder holder, ServerConfigurationBuilder builder) {
String defaultSocketBinding = null;
String defaultSecurityRealm = null;
for (int i = 0; i < reader.getAttributeCount(); i++) {
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
String value = reader.getAttributeValue(i);
switch (attribute) {
case SOCKET_BINDING:
builder.endpoints().socketBinding(defaultSocketBinding = value);
break;
case SECURITY_REALM:
builder.endpoints().securityRealm(defaultSecurityRealm = value);
break;
default:
throw ParseUtils.unexpectedElement(reader);
}
}
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
if (element == Element.ENDPOINT || element == Element.ENDPOINTS) {
parseEndpoint(reader, holder, builder, element, defaultSocketBinding, defaultSecurityRealm);
} else {
throw ParseUtils.unexpectedElement(reader);
}
}
if (builder.endpoints().endpoints().isEmpty()) {
if (defaultSocketBinding == null) {
throw ParseUtils.missingRequired(reader, Collections.singleton(Attribute.SOCKET_BINDING));
}
EndpointConfigurationBuilder endpoint = builder.endpoints().addEndpoint(defaultSocketBinding);
if (defaultSecurityRealm != null) {
endpoint.securityRealm(defaultSecurityRealm).implicitConnectorSecurity(true);
}
configureDefaultEndpoint(reader, defaultSocketBinding, endpoint);
}
}
private void parseEndpoint(ConfigurationReader reader, ConfigurationBuilderHolder holder, ServerConfigurationBuilder builder, Element endpointElement, String defaultSocketBinding, String defaultSecurityRealm) {
final String socketBinding;
if (defaultSocketBinding == null) {
socketBinding = ParseUtils.requireAttributes(reader, Attribute.SOCKET_BINDING)[0];
} else {
String binding = reader.getAttributeValue(Attribute.SOCKET_BINDING);
socketBinding = binding != null ? binding : defaultSocketBinding;
}
EndpointConfigurationBuilder endpoint = builder.endpoints().addEndpoint(socketBinding);
String realm = reader.getAttributeValue(Attribute.SECURITY_REALM);
final String securityRealm = realm != null ? realm : defaultSecurityRealm;
if (securityRealm != null) {
endpoint.securityRealm(securityRealm).implicitConnectorSecurity(reader.getSchema().since(11, 0));
}
for (int i = 0; i < reader.getAttributeCount(); i++) {
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
String value = reader.getAttributeValue(i);
switch (attribute) {
case SOCKET_BINDING:
case SECURITY_REALM:
// Already seen
break;
case ADMIN:
endpoint.admin(ParseUtils.parseBoolean(reader, i, value));
break;
case METRICS_AUTH:
endpoint.metricsAuth(ParseUtils.parseBoolean(reader, i, value));
break;
default:
parseCommonConnectorAttributes(reader, i, builder, endpoint.singlePort());
break;
}
}
while (reader.inTag(endpointElement)) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case IP_FILTER: {
parseConnectorIpFilter(reader, endpoint.singlePort().ipFilter());
break;
}
case CONNECTORS:
// Wrapping element for YAML/JSON
parseConnectors(reader, holder);
break;
default:
reader.handleAny(holder);
break;
}
}
configureDefaultEndpoint(reader, socketBinding, endpoint);
}
private void parseConnectors(ConfigurationReader reader, ConfigurationBuilderHolder holder) {
while (reader.inTag(Element.CONNECTORS)) {
reader.getMapItem(Attribute.NAME);
reader.handleAny(holder);
reader.endMapItem();
}
}
private void configureDefaultEndpoint(ConfigurationReader reader, String socketBinding, EndpointConfigurationBuilder endpoint) {
if (endpoint.connectors().isEmpty()) {
endpoint.addConnector(HotRodServerConfigurationBuilder.class).implicitConnector(true).startTransport(false).socketBinding(socketBinding);
endpoint.addConnector(RespServerConfigurationBuilder.class).implicitConnector(true).startTransport(false).socketBinding(socketBinding);
endpoint.addConnector(MemcachedServerConfigurationBuilder.class).implicitConnector(true).startTransport(false).socketBinding(socketBinding);
RestServerConfigurationBuilder rest = endpoint.addConnector(RestServerConfigurationBuilder.class).implicitConnector(true).startTransport(false).socketBinding(socketBinding);
configureEndpoint(reader.getProperties(), endpoint, rest);
}
}
public static void configureEndpoint(Properties properties, EndpointConfigurationBuilder endpoint, RestServerConfigurationBuilder builder) {
if (endpoint.admin()) {
String serverHome = properties.getProperty(Server.INFINISPAN_SERVER_HOME_PATH);
builder.staticResources(Paths.get(serverHome, Server.DEFAULT_SERVER_STATIC_DIR));
}
builder.authentication().metricsAuth(endpoint.metricsAuth());
}
public static void parseCommonConnectorAttributes(ConfigurationReader reader, int i, ServerConfigurationBuilder serverBuilder, ProtocolServerConfigurationBuilder<?, ?, ?> builder) {
if (ParseUtils.isNoNamespaceAttribute(reader, i)) {
Attribute attribute = Attribute.forName(reader.getAttributeName(i));
String value = reader.getAttributeValue(i);
switch (attribute) {
case IDLE_TIMEOUT: {
builder.idleTimeout(ParseUtils.parseInt(reader, i, value));
break;
}
case IO_THREADS: {
builder.ioThreads(ParseUtils.parseInt(reader, i, value));
break;
}
case RECEIVE_BUFFER_SIZE: {
builder.recvBufSize(ParseUtils.parseInt(reader, i, value));
break;
}
case REQUIRE_SSL_CLIENT_AUTH: {
builder.ssl().requireClientAuth(ParseUtils.parseBoolean(reader, i, value));
break;
}
case SECURITY_REALM: {
break;
}
case SEND_BUFFER_SIZE: {
builder.sendBufSize(ParseUtils.parseInt(reader, i, value));
break;
}
case TCP_KEEPALIVE: {
builder.tcpKeepAlive(ParseUtils.parseBoolean(reader, i, value));
break;
}
case TCP_NODELAY: {
builder.tcpNoDelay(ParseUtils.parseBoolean(reader, i, value));
break;
}
case WORKER_THREADS: {
if (reader.getSchema().since(14, 0)) {
throw ParseUtils.attributeRemoved(reader, i);
} else {
CONFIG.ignoredAttribute(attribute.toString(), "14.0", attribute.name(), reader.getLocation().getLineNumber());
}
break;
}
default:
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
public static void parseCommonConnectorElements(ConfigurationReader reader, ProtocolServerConfigurationBuilder<?, ?, ?> builder) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case IP_FILTER: {
parseConnectorIpFilter(reader, builder.ipFilter());
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
private static void parseConnectorIpFilter(ConfigurationReader reader, IpFilterConfigurationBuilder builder) {
while (reader.inTag()) {
Element element = Element.forName(reader.getLocalName());
switch (element) {
case ACCEPT: {
builder.allowFrom(ParseUtils.requireSingleAttribute(reader, Attribute.FROM));
ParseUtils.requireNoContent(reader);
break;
}
case REJECT: {
builder.rejectFrom(ParseUtils.requireSingleAttribute(reader, Attribute.FROM));
ParseUtils.requireNoContent(reader);
break;
}
default:
throw ParseUtils.unexpectedElement(reader);
}
}
}
@Override
public void readAttribute(ConfigurationReader reader, String elementName, int attributeIndex, ConfigurationBuilderHolder holder) {
if (org.infinispan.configuration.parsing.Element.forName(elementName) == org.infinispan.configuration.parsing.Element.TRANSPORT) {
ServerConfigurationBuilder serverBuilder = holder.getGlobalConfigurationBuilder().addModule(ServerConfigurationBuilder.class);
String attributeName = reader.getAttributeName(attributeIndex);
switch (Attribute.forName(attributeName)) {
case SECURITY_REALM:
serverBuilder.security().transport().securityRealm(reader.getAttributeValue(attributeIndex));
break;
default:
throw ParseUtils.unexpectedAttribute(reader, attributeName);
}
} else {
throw ParseUtils.unexpectedElement(reader, elementName);
}
}
public static String parseSasl(ConfigurationReader reader, SaslConfigurationBuilder sasl) {
String serverPrincipal = null;
for (int i = 0; i < reader.getAttributeCount(); i++) {
ParseUtils.requireNoNamespaceAttribute(reader, i);
String value = reader.getAttributeValue(i);
org.infinispan.server.hotrod.configuration.Attribute attribute = org.infinispan.server.hotrod.configuration.Attribute.forName(reader.getAttributeName(i));
switch (attribute) {
case SERVER_PRINCIPAL: {
serverPrincipal = value;
break;
}
case SERVER_NAME: {
sasl.serverName(value);
break;
}
case MECHANISMS: {
for (String mech : reader.getListAttributeValue(i)) {
sasl.addAllowedMech(mech);
}
break;
}
case QOP: {
for (String qop : reader.getListAttributeValue(i)) {
sasl.addQOP(qop);
}
break;
}
case STRENGTH: {
for (String s : reader.getListAttributeValue(i)) {
sasl.addStrength(s);
}
break;
}
case POLICY: {
for (String p : reader.getListAttributeValue(i)) {
sasl.addPolicy(p);
}
break;
}
default: {
throw ParseUtils.unexpectedAttribute(reader, i);
}
}
}
final EnumSet<org.infinispan.server.hotrod.configuration.Element> visited = EnumSet.noneOf(org.infinispan.server.hotrod.configuration.Element.class);
while (reader.inTag()) {
final org.infinispan.server.hotrod.configuration.Element element = org.infinispan.server.hotrod.configuration.Element.forName(reader.getLocalName());
switch (element) {
case POLICY: {
if (reader.getSchema().since(13, 0) || visited.contains(element)) {
throw ParseUtils.unexpectedElement(reader);
} else {
visited.add(element);
}
parsePolicy(reader, sasl);
break;
}
case PROPERTIES: {
// JSON/YAML map properties to attributes
for (int i = 0; i < reader.getAttributeCount(); i++) {
sasl.addProperty(reader.getAttributeName(i), reader.getAttributeValue(i));
}
ParseUtils.requireNoContent(reader);
break;
}
case PROPERTY: {
sasl.addProperty(ParseUtils.requireSingleAttribute(reader, org.infinispan.server.hotrod.configuration.Attribute.NAME), reader.getElementText());
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
return serverPrincipal;
}
private static void parsePolicy(ConfigurationReader reader, SaslConfigurationBuilder sasl) {
if (reader.getAttributeCount() > 0) {
throw ParseUtils.unexpectedAttribute(reader, 0);
}
// Handle nested elements.
final EnumSet<org.infinispan.server.hotrod.configuration.Element> visited = EnumSet.noneOf(org.infinispan.server.hotrod.configuration.Element.class);
while (reader.inTag()) {
final org.infinispan.server.hotrod.configuration.Element element = org.infinispan.server.hotrod.configuration.Element.forName(reader.getLocalName());
if (visited.contains(element)) {
throw ParseUtils.unexpectedElement(reader);
}
visited.add(element);
String value = ParseUtils.readStringAttributeElement(reader, org.infinispan.server.hotrod.configuration.Attribute.VALUE.toString());
switch (element) {
case FORWARD_SECRECY:
case NO_ACTIVE:
case NO_ANONYMOUS:
case NO_DICTIONARY:
case NO_PLAIN_TEXT:
case PASS_CREDENTIALS: {
if ("true".equals(value)) {
sasl.addPolicy(element.toString());
}
break;
}
default: {
throw ParseUtils.unexpectedElement(reader);
}
}
}
}
}
| 83,202
| 42.837197
| 238
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/SocketBindingConfiguration.java
|
package org.infinispan.server.configuration;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
public class SocketBindingConfiguration extends ConfigurationElement<SocketBindingConfiguration> {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, null, String.class).build();
static final AttributeDefinition<Integer> PORT = AttributeDefinition.builder(Attribute.PORT, null, Integer.class).build();
static final AttributeDefinition<String> INTERFACE = AttributeDefinition.builder(Attribute.INTERFACE, null, String.class).build();
private final InterfaceConfiguration interfaceConfiguration;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(SocketBindingConfiguration.class, NAME, PORT, INTERFACE);
}
SocketBindingConfiguration(AttributeSet attributes, InterfaceConfiguration interfaceConfiguration) {
super(Element.SOCKET_BINDING, attributes);
this.interfaceConfiguration = interfaceConfiguration;
}
public String name() {
return attributes.attribute(NAME).get();
}
public String interfaceName() {
return attributes.attribute(INTERFACE).get();
}
public int port() {
return attributes.attribute(PORT).get();
}
public InterfaceConfiguration interfaceConfiguration() {
return interfaceConfiguration;
}
}
| 1,533
| 38.333333
| 133
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/DataSourceConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import java.util.Map;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.security.PasswordCredentialSource;
import org.wildfly.security.credential.source.CredentialSource;
import io.agroal.api.configuration.AgroalConnectionFactoryConfiguration;
public class DataSourceConfigurationBuilder implements Builder<DataSourceConfiguration> {
private final AttributeSet attributes;
DataSourceConfigurationBuilder(String name, String jndiName) {
attributes = DataSourceConfiguration.attributeDefinitionSet();
attributes.attribute(DataSourceConfiguration.NAME).set(name);
attributes.attribute(DataSourceConfiguration.JNDI_NAME).set(jndiName);
}
@Override
public AttributeSet attributes() {
return attributes;
}
@Override
public DataSourceConfiguration create() {
return new DataSourceConfiguration(attributes.protect());
}
@Override
public DataSourceConfigurationBuilder read(DataSourceConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
public DataSourceConfigurationBuilder driver(String driver) {
attributes.attribute(DataSourceConfiguration.DRIVER).set(driver);
return this;
}
public DataSourceConfigurationBuilder username(String username) {
attributes.attribute(DataSourceConfiguration.USERNAME).set(username);
return this;
}
public DataSourceConfigurationBuilder password(char[] password) {
attributes.attribute(DataSourceConfiguration.PASSWORD).set(new PasswordCredentialSource(password));
return this;
}
public DataSourceConfigurationBuilder password(Supplier<CredentialSource> password) {
attributes.attribute(DataSourceConfiguration.PASSWORD).set(password);
return this;
}
public DataSourceConfigurationBuilder url(String url) {
attributes.attribute(DataSourceConfiguration.URL).set(url);
return this;
}
public DataSourceConfigurationBuilder transactionIsolation(AgroalConnectionFactoryConfiguration.TransactionIsolation transactionIsolation) {
attributes.attribute(DataSourceConfiguration.TRANSACTION_ISOLATION).set(transactionIsolation);
return this;
}
public DataSourceConfigurationBuilder newConnectionSql(String newConnectionSql) {
attributes.attribute(DataSourceConfiguration.INITIAL_SQL).set(newConnectionSql);
return this;
}
public DataSourceConfigurationBuilder maxSize(int maxSize) {
attributes.attribute(DataSourceConfiguration.MAX_SIZE).set(maxSize);
return this;
}
public DataSourceConfigurationBuilder minSize(int minSize) {
attributes.attribute(DataSourceConfiguration.MIN_SIZE).set(minSize);
return this;
}
public DataSourceConfigurationBuilder initialSize(int initialSize) {
attributes.attribute(DataSourceConfiguration.INITIAL_SIZE).set(initialSize);
return this;
}
public DataSourceConfigurationBuilder blockingTimeout(long blockingTimeout) {
attributes.attribute(DataSourceConfiguration.BLOCKING_TIMEOUT).set(blockingTimeout);
return this;
}
public DataSourceConfigurationBuilder backgroundValidation(long backgroundValidation) {
attributes.attribute(DataSourceConfiguration.BACKGROUND_VALIDATION).set(backgroundValidation);
return this;
}
public DataSourceConfigurationBuilder validateOnAcquisition(long validateOnAcquisition) {
attributes.attribute(DataSourceConfiguration.VALIDATE_ON_ACQUISITION).set(validateOnAcquisition);
return this;
}
public DataSourceConfigurationBuilder leakDetection(long leakDetection) {
attributes.attribute(DataSourceConfiguration.LEAK_DETECTION).set(leakDetection);
return this;
}
public DataSourceConfigurationBuilder idleRemoval(int idleRemoval) {
attributes.attribute(DataSourceConfiguration.IDLE_REMOVAL).set(idleRemoval);
return this;
}
public DataSourceConfigurationBuilder statistics(boolean enable) {
attributes.attribute(DataSourceConfiguration.STATISTICS).set(enable);
return this;
}
public DataSourceConfigurationBuilder addProperty(String key, String value) {
Attribute<Map<String, String>> a = attributes.attribute(DataSourceConfiguration.CONNECTION_PROPERTIES);
Map<String, String> map = a.get();
map.put(key, value);
a.set(map);
return this;
}
}
| 4,702
| 35.457364
| 143
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/SocketBindingConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
public class SocketBindingConfigurationBuilder implements Builder<SocketBindingConfiguration> {
private final AttributeSet attributes;
private final ServerConfigurationBuilder server;
SocketBindingConfigurationBuilder(ServerConfigurationBuilder server) {
this.server = server;
attributes = SocketBindingConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public SocketBindingConfigurationBuilder binding(String name, int port, String interfaceName) {
attributes.attribute(SocketBindingConfiguration.NAME).set(name);
attributes.attribute(SocketBindingConfiguration.PORT).set(port);
attributes.attribute(SocketBindingConfiguration.INTERFACE).set(interfaceName);
return this;
}
String interfaceName() {
return attributes.attribute(SocketBindingConfiguration.INTERFACE).get();
}
@Override
public SocketBindingConfiguration create() {
throw new UnsupportedOperationException();
}
@Override
public SocketBindingConfigurationBuilder read(SocketBindingConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
public SocketBindingConfiguration create(InterfaceConfiguration interfaceConfiguration) {
return new SocketBindingConfiguration(attributes.protect(), interfaceConfiguration);
}
}
| 1,650
| 33.395833
| 104
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/InterfaceConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import static org.infinispan.server.configuration.InterfaceConfiguration.NAME;
import java.io.IOException;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.network.NetworkAddress;
public class InterfaceConfigurationBuilder implements Builder<InterfaceConfiguration> {
private final AttributeSet attributes;
private final AddressConfigurationBuilder address = new AddressConfigurationBuilder();
private NetworkAddress networkAddress;
InterfaceConfigurationBuilder(String name) {
this.attributes = InterfaceConfiguration.attributeDefinitionSet();
attributes.attribute(NAME).set(name);
}
@Override
public AttributeSet attributes() {
return attributes;
}
public InterfaceConfigurationBuilder address(AddressType addressType, String addressValue) throws IOException {
address.type(addressType, addressValue);
this.networkAddress = createNetworkAddress();
return this;
}
NetworkAddress networkAddress() {
return networkAddress;
}
public String name() {
return attributes.attribute(NAME).get();
}
private NetworkAddress createNetworkAddress() throws IOException {
String interfaceName = this.name();
AddressType addressType = address.addressType();
String addressValue = address.value();
switch (addressType) {
case ANY_ADDRESS:
return NetworkAddress.anyAddress(interfaceName);
case INET_ADDRESS:
return NetworkAddress.fromString(interfaceName, addressValue);
case LINK_LOCAL:
return NetworkAddress.linkLocalAddress(interfaceName);
case GLOBAL:
return NetworkAddress.globalAddress(interfaceName);
case LOOPBACK:
return NetworkAddress.loopback(interfaceName);
case NON_LOOPBACK:
return NetworkAddress.nonLoopback(interfaceName);
case SITE_LOCAL:
return NetworkAddress.siteLocal(interfaceName);
case MATCH_INTERFACE:
return NetworkAddress.matchInterface(interfaceName, addressValue);
case MATCH_ADDRESS:
return NetworkAddress.matchAddress(interfaceName, addressValue);
case MATCH_HOST:
return NetworkAddress.matchHost(interfaceName, addressValue);
}
return null;
}
@Override
public InterfaceConfiguration create() {
return new InterfaceConfiguration(attributes.protect(), address.create(), networkAddress);
}
@Override
public InterfaceConfigurationBuilder read(InterfaceConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
this.address.read(template.addressConfiguration(), combine);
return this;
}
}
| 2,932
| 34.768293
| 114
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/Attribute.java
|
package org.infinispan.server.configuration;
import java.util.HashMap;
import java.util.Map;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public enum Attribute {
UNKNOWN(null), // must be first
ADMIN,
ALIAS,
ALT_NAME_TYPE,
AUDIENCE,
AUTH_SERVER_URL,
AUTHENTICATION_REALM,
AUTHORIZATION_REALMS,
BACKGROUND_VALIDATION,
BLOCKING_TIMEOUT,
CACHE_CONTAINER,
CACHE_LIFESPAN,
CACHE_MAX_SIZE,
CLEAR_TEXT,
CLIENT_ID,
CLIENT_SECRET,
CLIENT_SSL_CONTEXT,
COMMAND,
CONNECTION_POOLING,
CONNECTION_TIMEOUT,
CREDENTIAL,
DEBUG,
DEFAULT_INTERFACE,
DEFAULT_REALM,
DIGEST_REALM_NAME,
DIRECT_VERIFICATION,
DRIVER,
ENABLED_CIPHERSUITES,
ENABLED_CIPHERSUITES_TLS13,
ENABLED_PROTOCOLS,
EXTRACT_RDN,
FAIL_CACHE,
FILTER,
FILTER_DN,
FILTER_NAME,
FROM,
GENERATE_SELF_SIGNED_CERTIFICATE_HOST,
GROUPS_ATTRIBUTE,
HOST_NAME_VERIFICATION_POLICY,
IDLE_REMOVAL,
IDLE_TIMEOUT,
INITIAL_SIZE,
INTERFACE,
INTROSPECTION_URL,
IO_THREADS,
ISSUER,
JKU_TIMEOUT,
JNDI_NAME,
@Deprecated
KEYSTORE_PASSWORD,
KEYTAB_PATH,
KEY_PASSWORD,
LEAK_DETECTION,
LEVELS,
MASKED,
MAX_SIZE,
MECHANISM_NAMES,
MECHANISM_OIDS,
METRICS_AUTH,
MINIMUM_REMAINING_LIFETIME,
MIN_SIZE,
NAME,
NEW_CONNECTION_SQL,
OBTAIN_KERBEROS_TICKET,
PAGE_SIZE,
PASSWORD,
PATH,
PATTERN,
PLAIN_TEXT,
PORT,
PORT_OFFSET,
PRINCIPAL,
PRINCIPAL_CLAIM,
PROVIDER,
PUBLIC_KEY,
RDN_IDENTIFIER,
READ_TIMEOUT,
REALMS,
RECEIVE_BUFFER_SIZE,
REFERENCE,
REFERRAL_MODE,
RELATIVE_TO,
REPLACEMENT,
REPLACE_ALL,
REQUEST_LIFETIME,
REQUIRED,
REQUIRE_SSL_CLIENT_AUTH,
ROLE_RECURSION,
ROLE_RECURSION_NAME,
SEARCH_DN,
SEARCH_RECURSIVE,
SEARCH_TIME_LIMIT,
SECURITY_REALM,
SEND_BUFFER_SIZE,
SERVER,
SOCKET_BINDING,
STATISTICS,
STORE,
TCP_KEEPALIVE,
TCP_NODELAY,
TO,
TRANSACTION_ISOLATION,
TYPE,
URL,
USERNAME,
VALIDATE_ON_ACQUISITION,
VALUE,
VERIFIABLE,
WORKER_THREADS,
WRAP_GSS_CREDENTIAL,
WRITABLE, UPPERCASE, EVIDENCE_DECODER, SEGMENT;
private static final Map<String, Attribute> ATTRIBUTES;
static {
final Map<String, Attribute> map = new HashMap<>(64);
for (Attribute attribute : values()) {
final String name = attribute.name;
if (name != null) {
map.put(name, attribute);
}
}
ATTRIBUTES = map;
}
private final String name;
Attribute(final String name) {
this.name = name;
}
Attribute() {
this.name = name().toLowerCase().replace('_', '-');
}
public static Attribute forName(String localName) {
final Attribute attribute = ATTRIBUTES.get(localName);
return attribute == null ? UNKNOWN : attribute;
}
@Override
public String toString() {
return name;
}
}
| 2,924
| 17.75
| 60
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/DataSourcesConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.Server;
public class DataSourcesConfigurationBuilder implements Builder<DataSourcesConfiguration> {
private final AttributeSet attributes;
private final Map<String, DataSourceConfigurationBuilder> dataSources = new LinkedHashMap<>(2);
private final Set<String> jndiNames = new HashSet<>(2);
DataSourcesConfigurationBuilder() {
attributes = DataSourcesConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
DataSourceConfigurationBuilder dataSource(String name, String jndiName) {
if (dataSources.containsKey(name)) {
throw Server.log.duplicateDataSource(name);
}
if (jndiNames.contains(jndiName)) {
throw Server.log.duplicateJndiName(jndiName);
}
DataSourceConfigurationBuilder builder = new DataSourceConfigurationBuilder(name, jndiName);
dataSources.put(name, builder);
jndiNames.add(jndiName);
return builder;
}
@Override
public DataSourcesConfiguration create() {
List<DataSourceConfiguration> list = dataSources.values().stream()
.map(DataSourceConfigurationBuilder::create).collect(Collectors.toList());
return new DataSourcesConfiguration(attributes.protect(), list);
}
@Override
public DataSourcesConfigurationBuilder read(DataSourcesConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
dataSources.clear();
//template.dataSources().forEach(s -> dataSource(s.name(), s.port(), s.interfaceName()));
return this;
}
}
| 2,013
| 33.724138
| 100
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/ServerConfigurationBuilder.java
|
package org.infinispan.server.configuration;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Properties;
import java.util.function.Supplier;
import javax.net.ssl.SSLContext;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.server.configuration.endpoint.EndpointsConfigurationBuilder;
import org.infinispan.server.configuration.security.SecurityConfiguration;
import org.infinispan.server.configuration.security.SecurityConfigurationBuilder;
/**
* @author Tristan Tarrant
* @since 10.0
*/
public class ServerConfigurationBuilder implements Builder<ServerConfiguration> {
private final Properties properties = new Properties();
private final InterfacesConfigurationBuilder interfaces = new InterfacesConfigurationBuilder();
private final SocketBindingsConfigurationBuilder socketBindings = new SocketBindingsConfigurationBuilder(this);
private final SecurityConfigurationBuilder security = new SecurityConfigurationBuilder(this);
private final DataSourcesConfigurationBuilder dataSources = new DataSourcesConfigurationBuilder();
private final EndpointsConfigurationBuilder endpoints = new EndpointsConfigurationBuilder(this);
private final List<SSLContextSupplier> suppliers = new ArrayList<>();
private final GlobalConfigurationBuilder builder;
public ServerConfigurationBuilder(GlobalConfigurationBuilder builder) {
this.builder = builder;
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
public ServerConfigurationBuilder properties(Properties properties) {
this.properties.clear();
this.properties.putAll(properties);
return this;
}
public Properties properties() {
return properties;
}
public SecurityConfigurationBuilder security() {
return security;
}
public InterfacesConfigurationBuilder interfaces() {
return interfaces;
}
public SocketBindingsConfigurationBuilder socketBindings() {
return socketBindings;
}
public DataSourcesConfigurationBuilder dataSources() {
return dataSources;
}
public EndpointsConfigurationBuilder endpoints() {
return endpoints;
}
@Override
public void validate() {
Arrays.asList(interfaces, socketBindings, security, endpoints).forEach(Builder::validate);
}
@Override
public ServerConfiguration create() {
SecurityConfiguration securityConfiguration = security.create();
for(SSLContextSupplier supplier : suppliers) {
supplier.configuration = securityConfiguration;
}
InterfacesConfiguration interfacesConfiguration = interfaces.create();
SocketBindingsConfiguration bindingsConfiguration = socketBindings.create(interfacesConfiguration);
return new ServerConfiguration(
interfacesConfiguration,
bindingsConfiguration,
securityConfiguration,
dataSources.create(),
endpoints.create(builder, bindingsConfiguration, securityConfiguration)
);
}
@Override
public Builder<?> read(ServerConfiguration template, Combine combine) {
// Do nothing
return this;
}
public Supplier<SSLContext> serverSSLContextSupplier(String sslContextName) {
SSLContextSupplier supplier = new SSLContextSupplier(sslContextName, false);
suppliers.add(supplier);
return supplier;
}
public Supplier<SSLContext> clientSSLContextSupplier(String sslContextName) {
SSLContextSupplier supplier = new SSLContextSupplier(sslContextName, true);
suppliers.add(supplier);
return supplier;
}
private static class SSLContextSupplier implements Supplier<SSLContext> {
final String name;
final boolean client;
SecurityConfiguration configuration;
SSLContextSupplier(String name, boolean client) {
this.name = name;
this.client = client;
}
@Override
public SSLContext get() {
return client ? configuration.realms().getRealm(name).clientSSLContext() : configuration.realms().getRealm(name).serverSSLContext();
}
}
}
| 4,350
| 32.992188
| 141
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/ServerConfiguration.java
|
package org.infinispan.server.configuration;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.configuration.parsing.ParserScope;
import org.infinispan.configuration.serializing.SerializedWith;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.endpoint.EndpointsConfiguration;
import org.infinispan.server.configuration.security.SecurityConfiguration;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
*/
@BuiltBy(ServerConfigurationBuilder.class)
@SerializedWith(value = ServerConfigurationSerializer.class, scope = ParserScope.GLOBAL)
public class ServerConfiguration {
final InterfacesConfiguration interfaces;
final SocketBindingsConfiguration socketBindings;
final SecurityConfiguration security;
final DataSourcesConfiguration dataSources;
final EndpointsConfiguration endpoints;
private Server server;
ServerConfiguration(
InterfacesConfiguration interfaces,
SocketBindingsConfiguration socketBindings,
SecurityConfiguration security,
DataSourcesConfiguration dataSources,
EndpointsConfiguration endpoints) {
this.interfaces = interfaces;
this.socketBindings = socketBindings;
this.security = security;
this.dataSources = dataSources;
this.endpoints = endpoints;
}
public Map<String, InterfaceConfiguration> networkInterfaces() {
return interfaces.interfaces();
}
public Map<String, SocketBindingConfiguration> socketBindings() {
return socketBindings.socketBindings();
}
public SecurityConfiguration security() {
return security;
}
public Map<String, DataSourceConfiguration> dataSources() {
return dataSources.dataSources().stream().collect(Collectors.toMap(DataSourceConfiguration::name, Function.identity()));
}
public EndpointsConfiguration endpoints() {
return endpoints;
}
public Server getServer() {
return server;
}
public void setServer(Server server) {
this.server = server;
}
}
| 2,169
| 30
| 126
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TrustStoreConfiguration.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.CredentialStoresConfiguration.resolvePassword;
import static org.infinispan.server.security.KeyStoreUtils.buildFilelessKeyStore;
import static org.wildfly.security.provider.util.ProviderUtil.findProvider;
import java.io.FileInputStream;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.Provider;
import java.util.Properties;
import java.util.function.Supplier;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import javax.net.ssl.X509TrustManager;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.configuration.ServerConfigurationSerializer;
import org.wildfly.security.credential.source.CredentialSource;
import org.wildfly.security.keystore.KeyStoreUtil;
import org.wildfly.security.ssl.SSLContextBuilder;
/**
* @since 12.1
*/
public class TrustStoreConfiguration extends ConfigurationElement<TrustStoreConfiguration> {
static final AttributeDefinition<Supplier<CredentialSource>> PASSWORD = AttributeDefinition.builder(Attribute.PASSWORD, null, (Class<Supplier<CredentialSource>>) (Class<?>) Supplier.class).serializer(ServerConfigurationSerializer.CREDENTIAL).build();
static final AttributeDefinition<String> PATH = AttributeDefinition.builder(Attribute.PATH, null, String.class).build();
static final AttributeDefinition<String> RELATIVE_TO = AttributeDefinition.builder(Attribute.RELATIVE_TO, Server.INFINISPAN_SERVER_CONFIG_PATH, String.class).autoPersist(false).build();
static final AttributeDefinition<String> PROVIDER = AttributeDefinition.builder(Attribute.PROVIDER, null, String.class).build();
static final AttributeDefinition<String> TYPE = AttributeDefinition.builder(Attribute.TYPE, null, String.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(TrustStoreConfiguration.class, PATH, RELATIVE_TO, PROVIDER, PASSWORD, TYPE);
}
TrustStoreConfiguration(AttributeSet attributes) {
super(Element.TRUSTSTORE, attributes);
}
KeyStore trustStore(Provider[] providers, Properties properties) {
String fileName = ParseUtils.resolvePath(attributes.attribute(PATH).get(),
properties.getProperty(attributes.attribute(RELATIVE_TO).get()));
String providerName = attributes.attribute(PROVIDER).get();
String type = attributes.attribute(TYPE).get();
if (fileName == null) {
try {
return buildFilelessKeyStore(providers, providerName, type);
} catch (GeneralSecurityException | IOException e) {
throw new CacheConfigurationException(e);
}
} else {
char[] password = resolvePassword(attributes.attribute(PASSWORD));
try (FileInputStream is = new FileInputStream(fileName)) {
return KeyStoreUtil.loadKeyStore(() -> providers, providerName, is, fileName, password);
} catch (IOException | KeyStoreException e) {
throw new CacheConfigurationException(e);
}
}
}
public void build(SSLContextBuilder builder, Properties properties) {
if (attributes.isModified()) {
Provider[] providers = SslContextFactory.discoverSecurityProviders(Thread.currentThread().getContextClassLoader());
try {
KeyStore trustStore = trustStore(providers, properties);
String algorithm = TrustManagerFactory.getDefaultAlgorithm();
String providerName = attributes.attribute(PROVIDER).get();
Provider provider = findProvider(providers, providerName, TrustManagerFactory.class, algorithm);
TrustManagerFactory trustManagerFactory = provider != null ? TrustManagerFactory.getInstance(algorithm, provider) : TrustManagerFactory.getInstance(algorithm);
trustManagerFactory.init(trustStore);
for (TrustManager trustManager : trustManagerFactory.getTrustManagers()) {
if (trustManager instanceof X509TrustManager) {
builder.setTrustManager((X509TrustManager) trustManager);
return;
}
}
throw Server.log.noDefaultTrustManager();
} catch (Exception e) {
throw new CacheConfigurationException(e);
}
}
}
}
| 4,929
| 50.354167
| 253
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/RealmsConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class RealmsConfigurationBuilder implements Builder<RealmsConfiguration> {
private final Map<String, RealmConfigurationBuilder> securityRealms = new LinkedHashMap<>(2);
public RealmsConfigurationBuilder() {
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
public RealmConfigurationBuilder addSecurityRealm(String name) {
RealmConfigurationBuilder realmConfigurationBuilder = new RealmConfigurationBuilder(name);
securityRealms.put(name, realmConfigurationBuilder);
return realmConfigurationBuilder;
}
@Override
public RealmsConfiguration create() {
Map<String, RealmConfiguration> map = securityRealms.entrySet().stream().collect(Collectors.toMap(e -> e.getKey(), e -> e.getValue().create()));
return new RealmsConfiguration(map);
}
@Override
public RealmsConfigurationBuilder read(RealmsConfiguration template, Combine combine) {
securityRealms.clear();
template.realms().entrySet().forEach(e -> addSecurityRealm(e.getKey()).read(e.getValue(), combine));
return this;
}
@Override
public void validate() {
securityRealms.values().forEach(RealmConfigurationBuilder::validate);
}
}
| 1,578
| 30.58
| 150
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapAttributeConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.EXTRACT_RDN;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.FILTER;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.FILTER_DN;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.FROM;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.REFERENCE;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.ROLE_RECURSION;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.ROLE_RECURSION_NAME;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.SEARCH_RECURSIVE;
import static org.infinispan.server.configuration.security.LdapAttributeConfiguration.TO;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class LdapAttributeConfigurationBuilder implements Builder<LdapAttributeConfiguration> {
private final AttributeSet attributes;
LdapAttributeConfigurationBuilder() {
this.attributes = LdapAttributeConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public LdapAttributeConfigurationBuilder filter(String filter) {
attributes.attribute(FILTER).set(filter);
return this;
}
public LdapAttributeConfigurationBuilder reference(String reference) {
attributes.attribute(REFERENCE).set(reference);
return this;
}
public LdapAttributeConfigurationBuilder filterBaseDn(String filterBaseDn) {
attributes.attribute(FILTER_DN).set(filterBaseDn);
return this;
}
public LdapAttributeConfigurationBuilder from(String from) {
attributes.attribute(FROM).set(from);
return this;
}
public LdapAttributeConfigurationBuilder to(String to) {
attributes.attribute(TO).set(to);
return this;
}
public LdapAttributeConfigurationBuilder searchRecursive(boolean searchRecursive) {
attributes.attribute(SEARCH_RECURSIVE).set(searchRecursive);
return this;
}
public LdapAttributeConfigurationBuilder roleRecursion(int roleRecursion) {
attributes.attribute(ROLE_RECURSION).set(roleRecursion);
return this;
}
public LdapAttributeConfigurationBuilder roleRecursionName(String roleRecursionName) {
attributes.attribute(ROLE_RECURSION_NAME).set(roleRecursionName);
return this;
}
public LdapAttributeConfigurationBuilder extractRdn(String rdn) {
attributes.attribute(EXTRACT_RDN).set(rdn);
return this;
}
@Override
public LdapAttributeConfiguration create() {
return new LdapAttributeConfiguration(attributes.protect());
}
@Override
public LdapAttributeConfigurationBuilder read(LdapAttributeConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
}
| 3,212
| 35.101124
| 106
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/CredentialStoreConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.security.GeneralSecurityException;
import java.security.KeyStore;
import java.security.spec.AlgorithmParameterSpec;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import java.util.function.Supplier;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSerializer;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.configuration.parsing.ParseUtils;
import org.infinispan.server.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ElytronPasswordProviderSupplier;
import org.wildfly.security.auth.SupportLevel;
import org.wildfly.security.auth.server.IdentityCredentials;
import org.wildfly.security.credential.Credential;
import org.wildfly.security.credential.PasswordCredential;
import org.wildfly.security.credential.source.CredentialSource;
import org.wildfly.security.credential.source.impl.CommandCredentialSource;
import org.wildfly.security.credential.store.CredentialStore;
import org.wildfly.security.credential.store.CredentialStoreException;
import org.wildfly.security.credential.store.CredentialStoreSpi;
import org.wildfly.security.credential.store.impl.KeyStoreCredentialStore;
import org.wildfly.security.password.WildFlyElytronPasswordProvider;
import org.wildfly.security.password.interfaces.ClearPassword;
import org.wildfly.security.util.PasswordBasedEncryptionUtil;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class CredentialStoreConfiguration extends ConfigurationElement<CredentialStoresConfiguration> {
public static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, null, String.class).build();
public static final AttributeDefinition<String> PATH = AttributeDefinition.builder(Attribute.PATH, null, String.class).build();
public static final AttributeDefinition<String> RELATIVE_TO = AttributeDefinition.builder(Attribute.RELATIVE_TO, Server.INFINISPAN_SERVER_CONFIG_PATH, String.class).autoPersist(false).build();
public static final AttributeDefinition<String> TYPE = AttributeDefinition.builder(Attribute.TYPE, "pkcs12", String.class).build();
static final AttributeDefinition<Supplier<CredentialSource>> CREDENTIAL = AttributeDefinition.builder(Attribute.CREDENTIAL, null, (Class<Supplier<CredentialSource>>) (Class<?>) Supplier.class)
.serializer((writer, name, value) -> {
((AttributeSerializer<CredentialSource>) value).serialize(writer, name, null);
}).build();
static AttributeSet attributeDefinitionSet() {
KeyStore.getDefaultType();
return new AttributeSet(CredentialStoreConfiguration.class, NAME, PATH, RELATIVE_TO, TYPE, CREDENTIAL);
}
private CredentialStoreSpi credentialStore;
CredentialStoreConfiguration(AttributeSet attributes) {
super(Element.CREDENTIAL_STORE, attributes);
}
void init(Properties properties) {
if (credentialStore == null) {
if (attributes.attribute(PATH).isNull()) {
throw new IllegalStateException("file has to be specified");
}
String path = attributes.attribute(PATH).get();
String relativeTo = properties.getProperty(attributes.attribute(RELATIVE_TO).get());
String location = ParseUtils.resolvePath(path, relativeTo);
credentialStore = new KeyStoreCredentialStore();
final Map<String, String> map = new HashMap<>();
map.put("location", location);
map.put("create", "false");
map.put("keyStoreType", attributes.attribute(TYPE).get());
try {
CredentialSource credential = attributes.attribute(CREDENTIAL).get().get();
credentialStore.initialize(
map,
new CredentialStore.CredentialSourceProtectionParameter(
IdentityCredentials.NONE.withCredential(credential.getCredential(PasswordCredential.class))),
ElytronPasswordProviderSupplier.PROVIDERS
);
} catch (Exception e) {
// We ignore the exception if it's about automatic creation
if (!e.getMessage().startsWith("ELY09518")) {
throw new CacheConfigurationException(e);
}
}
}
}
public <C extends Credential> C getCredential(String alias, Class<C> type) {
try {
if (alias == null) {
if (credentialStore.getAliases().size() == 1) {
alias = credentialStore.getAliases().iterator().next();
} else {
throw Server.log.unspecifiedCredentialAlias();
}
}
return credentialStore.retrieve(alias, type, null, null, null);
} catch (CredentialStoreException e) {
throw new CacheConfigurationException(e);
}
}
public static class ClearTextCredentialSource implements CredentialSource {
final char[] secret;
public ClearTextCredentialSource(final char[] secret) {
this.secret = secret;
}
@Override
public SupportLevel getCredentialAcquireSupport(Class<? extends Credential> credentialType, String algorithmName, AlgorithmParameterSpec parameterSpec) {
return credentialType == PasswordCredential.class ? SupportLevel.SUPPORTED : SupportLevel.UNSUPPORTED;
}
@Override
public <C extends Credential> C getCredential(Class<C> credentialType, String algorithmName, AlgorithmParameterSpec parameterSpec) {
return credentialType.cast(new PasswordCredential(ClearPassword.createRaw(ClearPassword.ALGORITHM_CLEAR, secret)));
}
}
public static class ClearTextCredentialSupplier implements Supplier<CredentialSource>, AttributeSerializer<ClearTextCredentialSupplier> {
private final ClearTextCredentialSource credential;
public ClearTextCredentialSupplier(char[] credential) {
this.credential = new ClearTextCredentialSource(credential);
}
@Override
public CredentialSource get() {
return credential;
}
@Override
public void serialize(ConfigurationWriter writer, String name, ClearTextCredentialSupplier value) {
writer.writeStartElement(Element.CLEAR_TEXT_CREDENTIAL);
if (writer.clearTextSecrets()) {
writer.writeAttribute(Attribute.CLEAR_TEXT, new String(credential.secret));
} else {
writer.writeAttribute(name, "***");
}
writer.writeEndElement();
}
}
public static class MaskedCredentialSupplier implements Supplier<CredentialSource>, AttributeSerializer<MaskedCredentialSupplier> {
private final CredentialSource credential;
private final String masked;
public MaskedCredentialSupplier(String masked) {
this.masked = masked;
String[] part = masked.split(";");
if (part.length != 3) {
throw Server.log.wrongMaskedPasswordFormat();
}
String salt = part[1];
final int iterationCount;
try {
iterationCount = Integer.parseInt(part[2]);
} catch (NumberFormatException e) {
throw Server.log.wrongMaskedPasswordFormat();
}
try {
PasswordBasedEncryptionUtil pbe = new PasswordBasedEncryptionUtil.Builder()
.picketBoxCompatibility()
.salt(salt)
.iteration(iterationCount)
.decryptMode()
.build();
credential = new ClearTextCredentialSource(pbe.decodeAndDecrypt(part[0]));
} catch (GeneralSecurityException e) {
throw new CacheConfigurationException(e);
}
}
@Override
public CredentialSource get() {
return credential;
}
@Override
public void serialize(ConfigurationWriter writer, String name, MaskedCredentialSupplier value) {
writer.writeStartElement(Element.MASKED_CREDENTIAL);
writer.writeAttribute(Attribute.MASKED, masked);
writer.writeEndElement();
}
}
public static class CommandCredentialSupplier implements Supplier<CredentialSource>, AttributeSerializer<CommandCredentialSupplier> {
private final String command;
private final CommandCredentialSource source;
public CommandCredentialSupplier(String command) {
this.command = command;
CommandCredentialSource.Builder builder = CommandCredentialSource.builder();
builder.setPasswordFactoryProvider(WildFlyElytronPasswordProvider.getInstance());
// comma can be back slashed
final String[] parsedCommands = command.split("(?<!\\\\) ");
for (String parsedCommand : parsedCommands) {
if (parsedCommand.indexOf('\\') != -1) {
builder.addCommand(parsedCommand.replaceAll("\\\\ ", " "));
} else {
builder.addCommand(parsedCommand);
}
}
try {
this.source = builder.build();
} catch (GeneralSecurityException e) {
throw new CacheConfigurationException(e);
}
}
@Override
public CredentialSource get() {
return source;
}
@Override
public void serialize(ConfigurationWriter writer, String name, CommandCredentialSupplier value) {
writer.writeStartElement(Element.COMMAND_CREDENTIAL);
writer.writeAttribute(Attribute.COMMAND, command);
writer.writeEndElement();
}
}
}
| 9,939
| 42.217391
| 195
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TokenRealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.EnumSet;
import java.util.Properties;
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.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.KeycloakRoleDecoder;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.realm.token.TokenSecurityRealm;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
/**
* @since 10.0
*/
public class TokenRealmConfiguration extends ConfigurationElement<TokenRealmConfiguration> implements RealmProvider {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, "token", String.class).build();
static final AttributeDefinition<String> AUTH_SERVER_URL = AttributeDefinition.builder(Attribute.AUTH_SERVER_URL, null, String.class).build();
static final AttributeDefinition<String> CLIENT_ID = AttributeDefinition.builder(Attribute.CLIENT_ID, null, String.class).build();
static final AttributeDefinition<String> PRINCIPAL_CLAIM = AttributeDefinition.builder(Attribute.PRINCIPAL_CLAIM, null, String.class).build();
private final JwtConfiguration jwtConfiguration;
private final OAuth2Configuration oauth2Configuration;
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(TokenRealmConfiguration.class, NAME, AUTH_SERVER_URL, CLIENT_ID, PRINCIPAL_CLAIM);
}
TokenRealmConfiguration(JwtConfiguration jwtConfiguration, OAuth2Configuration oAuth2Configuration, AttributeSet attributes) {
super(Element.TOKEN_REALM, attributes);
this.jwtConfiguration = jwtConfiguration;
this.oauth2Configuration = oAuth2Configuration;
}
public String name() {
return attributes.attribute(NAME).get();
}
public String authServerUrl() {
return attributes.attribute(AUTH_SERVER_URL).get();
}
public String clientId() {
return attributes.attribute(CLIENT_ID).get();
}
public JwtConfiguration jwtConfiguration() {
return jwtConfiguration;
}
public OAuth2Configuration oauth2Configuration() {
return oauth2Configuration;
}
@Override
public SecurityRealm build(SecurityConfiguration security, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties) {
TokenSecurityRealm.Builder tokenRealmBuilder = TokenSecurityRealm.builder();
tokenRealmBuilder.validator(oauth2Configuration().isModified() ? oauth2Configuration.getValidator(security, realm) : jwtConfiguration.getValidator(security, realm));
TokenSecurityRealm securityRealm = tokenRealmBuilder.build();
domainBuilder.setRoleDecoder(new KeycloakRoleDecoder());
return securityRealm;
}
@Override
public void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features) {
features.add(ServerSecurityRealm.Feature.TOKEN);
}
}
| 3,176
| 41.932432
| 171
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/JwtConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.nio.charset.StandardCharsets;
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.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.HostnameVerificationPolicy;
import org.wildfly.security.auth.realm.token.TokenValidator;
import org.wildfly.security.auth.realm.token.validator.JwtValidator;
/**
* @since 10.0
*/
public class JwtConfiguration extends ConfigurationElement<JwtConfiguration> {
static final AttributeDefinition<String[]> AUDIENCE = AttributeDefinition.builder(Attribute.AUDIENCE, null, String[].class).build();
static final AttributeDefinition<String> CLIENT_SSL_CONTEXT = AttributeDefinition.builder(Attribute.CLIENT_SSL_CONTEXT, null, String.class).build();
static final AttributeDefinition<String> HOST_NAME_VERIFICATION_POLICY = AttributeDefinition.builder(Attribute.HOST_NAME_VERIFICATION_POLICY, null, String.class).build();
static final AttributeDefinition<String[]> ISSUER = AttributeDefinition.builder(Attribute.ISSUER, null, String[].class).build();
static final AttributeDefinition<Long> JKU_TIMEOUT = AttributeDefinition.builder(Attribute.JKU_TIMEOUT, null, Long.class).build();
static final AttributeDefinition<String> PUBLIC_KEY = AttributeDefinition.builder(Attribute.PUBLIC_KEY, null, String.class).build();
static final AttributeDefinition<Integer> CONNECTION_TIMEOUT = AttributeDefinition.builder(Attribute.CONNECTION_TIMEOUT, 2000, Integer.class).immutable().build();
static final AttributeDefinition<Integer> READ_TIMEOUT = AttributeDefinition.builder(Attribute.READ_TIMEOUT, 2000, Integer.class).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(JwtConfiguration.class, AUDIENCE, CLIENT_SSL_CONTEXT, HOST_NAME_VERIFICATION_POLICY, ISSUER, JKU_TIMEOUT, PUBLIC_KEY, CONNECTION_TIMEOUT, READ_TIMEOUT);
}
JwtConfiguration(AttributeSet attributes) {
super(Element.JWT, attributes);
}
public TokenValidator getValidator(SecurityConfiguration security, RealmConfiguration realm) {
JwtValidator.Builder validatorBuilder = JwtValidator.builder();
attributes.attribute(AUDIENCE).apply(v -> validatorBuilder.audience(v));
attributes.attribute(ISSUER).apply(v -> validatorBuilder.issuer(v));
attributes.attribute(JKU_TIMEOUT).apply(v -> validatorBuilder.setJkuTimeout(v));
attributes.attribute(PUBLIC_KEY).apply(v -> validatorBuilder.publicKey(v.getBytes(StandardCharsets.UTF_8)));
attributes.attribute(HOST_NAME_VERIFICATION_POLICY).apply(v -> validatorBuilder.useSslHostnameVerifier(HostnameVerificationPolicy.valueOf(v).getVerifier()));
attributes.attribute(CONNECTION_TIMEOUT).apply(v -> validatorBuilder.connectionTimeout(v));
attributes.attribute(READ_TIMEOUT).apply(v -> validatorBuilder.readTimeout(v));
RealmConfiguration sslRealm = attributes.attribute(CLIENT_SSL_CONTEXT).isNull() ? realm : security.realms().getRealm(attributes.attribute(CLIENT_SSL_CONTEXT).get());
validatorBuilder.useSslContext(sslRealm.clientSSLContext());
return validatorBuilder.build();
}
}
| 3,397
| 68.346939
| 182
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapIdentityMappingConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.EnumSet;
import java.util.List;
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.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.realm.ldap.LdapSecurityRealmBuilder;
/**
* @since 10.0
*/
public class LdapIdentityMappingConfiguration extends ConfigurationElement<LdapIdentityMappingConfiguration> {
static final AttributeDefinition<String> RDN_IDENTIFIER = AttributeDefinition.builder(Attribute.RDN_IDENTIFIER, null, String.class).immutable().build();
static final AttributeDefinition<String> SEARCH_BASE_DN = AttributeDefinition.builder(Attribute.SEARCH_DN, null, String.class).immutable().build();
static final AttributeDefinition<Boolean> SEARCH_RECURSIVE = AttributeDefinition.builder(Attribute.SEARCH_RECURSIVE, false, Boolean.class).immutable().build();
static final AttributeDefinition<Integer> SEARCH_TIME_LIMIT = AttributeDefinition.builder(Attribute.SEARCH_TIME_LIMIT, 10_000, Integer.class).immutable().build();
static final AttributeDefinition<String> FILTER_NAME = AttributeDefinition.builder(Attribute.FILTER_NAME, "(rdn_identifier={0})", String.class).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(LdapIdentityMappingConfiguration.class, RDN_IDENTIFIER, SEARCH_BASE_DN, SEARCH_RECURSIVE, SEARCH_TIME_LIMIT, FILTER_NAME);
}
private final List<LdapAttributeConfiguration> attributeMappings;
private final LdapUserPasswordMapperConfiguration userPasswordMapper;
LdapIdentityMappingConfiguration(AttributeSet attributes,
List<LdapAttributeConfiguration> attributeMappings,
LdapUserPasswordMapperConfiguration userPasswordMapper) {
super(Element.IDENTITY_MAPPING, attributes);
this.attributeMappings = attributeMappings;
this.userPasswordMapper = userPasswordMapper;
}
public List<LdapAttributeConfiguration> attributeMappings() {
return attributeMappings;
}
public LdapUserPasswordMapperConfiguration userPasswordMapper() {
return userPasswordMapper;
}
EnumSet<ServerSecurityRealm.Feature> build(LdapSecurityRealmBuilder builder, RealmConfiguration realm) {
LdapSecurityRealmBuilder.IdentityMappingBuilder identity = builder.identityMapping();
if (attributes.attribute(RDN_IDENTIFIER).isModified()) {
identity.setRdnIdentifier(attributes.attribute(RDN_IDENTIFIER).get());
}
if (attributes.attribute(SEARCH_BASE_DN).isModified()) {
identity.setSearchDn(attributes.attribute(SEARCH_BASE_DN).get());
}
if (attributes.attribute(SEARCH_RECURSIVE).get()) {
identity.searchRecursive();
}
identity.setSearchTimeLimit(attributes.attribute(SEARCH_TIME_LIMIT).get());
if (attributes.attribute(FILTER_NAME).isModified()) {
identity.setFilterName(attributes.attribute(FILTER_NAME).get());
}
for (LdapAttributeConfiguration mapping : attributeMappings) {
mapping.build(identity);
}
EnumSet<ServerSecurityRealm.Feature> features = userPasswordMapper.build(builder, realm);
identity.build(); // side-effect
return features;
}
}
| 3,568
| 49.267606
| 167
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/SecurityConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.configuration.ServerConfigurationBuilder;
/**
* @since 10.0
*/
public class SecurityConfigurationBuilder implements Builder<SecurityConfiguration> {
private final CredentialStoresConfigurationBuilder credentialStoresConfiguration;
private final RealmsConfigurationBuilder realmsConfiguration = new RealmsConfigurationBuilder();
private final TransportSecurityConfigurationBuilder transport = new TransportSecurityConfigurationBuilder();
private final ServerConfigurationBuilder builder;
public SecurityConfigurationBuilder(ServerConfigurationBuilder builder) {
this.builder = builder;
this.credentialStoresConfiguration = new CredentialStoresConfigurationBuilder(builder);
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
public CredentialStoresConfigurationBuilder credentialStores() {
return credentialStoresConfiguration;
}
public RealmsConfigurationBuilder realms() {
return realmsConfiguration;
}
@Override
public void validate() {
credentialStoresConfiguration.validate();
realmsConfiguration.validate();
transport.validate();
}
@Override
public SecurityConfiguration create() {
return new SecurityConfiguration(credentialStoresConfiguration.create(), realmsConfiguration.create(), transport.create(), builder.properties());
}
@Override
public SecurityConfigurationBuilder read(SecurityConfiguration template, Combine combine) {
credentialStoresConfiguration.read(template.credentialStores(), combine);
realmsConfiguration.read(template.realms(), combine);
return this;
}
public TransportSecurityConfigurationBuilder transport() {
return transport;
}
}
| 2,006
| 33.603448
| 151
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/TrustStoreRealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.security.KeyStore;
import java.security.Provider;
import java.util.EnumSet;
import java.util.Properties;
import org.infinispan.commons.configuration.BuiltBy;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.util.SslContextFactory;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.realm.KeyStoreBackedSecurityRealm;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
/**
* @since 10.0
*/
@BuiltBy(TrustStoreRealmConfigurationBuilder.class)
public class TrustStoreRealmConfiguration extends ConfigurationElement<TrustStoreRealmConfiguration> implements RealmProvider {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, "trust", String.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(TrustStoreRealmConfiguration.class, NAME);
}
TrustStoreRealmConfiguration(AttributeSet attributes) {
super(Element.TRUSTSTORE_REALM, attributes);
}
@Override
public SecurityRealm build(SecurityConfiguration securityConfiguration, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties) {
Provider[] providers = SslContextFactory.discoverSecurityProviders(Thread.currentThread().getContextClassLoader());
KeyStore keyStore = realm.serverIdentitiesConfiguration().sslConfiguration().trustStore().trustStore(providers, properties);
return new KeyStoreBackedSecurityRealm(keyStore);
}
@Override
public String name() {
return attributes.attribute(NAME).get();
}
@Override
public void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features) {
features.add(ServerSecurityRealm.Feature.TRUST);
}
}
| 2,160
| 40.557692
| 163
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/UserPropertiesConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.UserPropertiesConfiguration.DIGEST_REALM_NAME;
import static org.infinispan.server.configuration.security.UserPropertiesConfiguration.PATH;
import static org.infinispan.server.configuration.security.UserPropertiesConfiguration.PLAIN_TEXT;
import static org.infinispan.server.configuration.security.UserPropertiesConfiguration.RELATIVE_TO;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class UserPropertiesConfigurationBuilder implements Builder<UserPropertiesConfiguration> {
private final AttributeSet attributes;
UserPropertiesConfigurationBuilder() {
attributes = UserPropertiesConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public UserPropertiesConfigurationBuilder path(String path) {
attributes.attribute(PATH).set(path);
return this;
}
public UserPropertiesConfigurationBuilder relativeTo(String relativeTo) {
attributes.attribute(RELATIVE_TO).set(relativeTo);
return this;
}
public UserPropertiesConfigurationBuilder plainText(boolean plainText) {
attributes.attribute(PLAIN_TEXT).set(plainText);
return this;
}
public UserPropertiesConfigurationBuilder digestRealmName(String name) {
attributes.attribute(DIGEST_REALM_NAME).set(name);
return this;
}
public boolean plainText() {
return attributes.attribute(PLAIN_TEXT).get();
}
@Override
public UserPropertiesConfiguration create() {
return new UserPropertiesConfiguration(attributes.protect());
}
@Override
public UserPropertiesConfigurationBuilder read(UserPropertiesConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 2,032
| 31.790323
| 106
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/SSLConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class SSLConfigurationBuilder implements Builder<SSLConfiguration> {
private final KeyStoreConfigurationBuilder keyStore;
private final TrustStoreConfigurationBuilder trustStore;
private final SSLEngineConfigurationBuilder engine;
SSLConfigurationBuilder(RealmConfigurationBuilder realmBuilder) {
this.keyStore = new KeyStoreConfigurationBuilder(realmBuilder);
this.trustStore = new TrustStoreConfigurationBuilder(realmBuilder);
this.engine = new SSLEngineConfigurationBuilder(realmBuilder);
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
public KeyStoreConfigurationBuilder keyStore() {
return keyStore;
}
public TrustStoreConfigurationBuilder trustStore() {
return trustStore;
}
public SSLEngineConfigurationBuilder engine() {
return engine;
}
@Override
public SSLConfiguration create() {
return new SSLConfiguration(keyStore.create(), trustStore.create(), engine.create());
}
@Override
public SSLConfigurationBuilder read(SSLConfiguration template, Combine combine) {
keyStore.read(template.keyStore(), combine);
trustStore.read(template.trustStore(), combine);
engine.read(template.engine(), combine);
return this;
}
}
| 1,554
| 28.339623
| 91
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/ServerIdentitiesConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class ServerIdentitiesConfigurationBuilder implements Builder<ServerIdentitiesConfiguration> {
SSLConfigurationBuilder sslConfigurationBuilder;
private final List<KerberosSecurityFactoryConfigurationBuilder> kerberosConfigurations = new ArrayList<>();
private final RealmConfigurationBuilder realmBuilder;
ServerIdentitiesConfigurationBuilder(RealmConfigurationBuilder realmBuilder) {
this.realmBuilder = realmBuilder;
}
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
public SSLConfigurationBuilder sslConfiguration() {
if (sslConfigurationBuilder == null) {
sslConfigurationBuilder = new SSLConfigurationBuilder(realmBuilder);
}
return sslConfigurationBuilder;
}
public KerberosSecurityFactoryConfigurationBuilder addKerberosConfiguration() {
KerberosSecurityFactoryConfigurationBuilder kerberos = new KerberosSecurityFactoryConfigurationBuilder(realmBuilder);
kerberosConfigurations.add(kerberos);
return kerberos;
}
@Override
public ServerIdentitiesConfiguration create() {
SSLConfiguration sslConfiguration = this.sslConfigurationBuilder == null ? null : this.sslConfigurationBuilder.create();
List<KerberosSecurityFactoryConfiguration> kerberosConfigurations = this.kerberosConfigurations.stream()
.map(KerberosSecurityFactoryConfigurationBuilder::create).collect(Collectors.toList());
return new ServerIdentitiesConfiguration(sslConfiguration, kerberosConfigurations);
}
@Override
public ServerIdentitiesConfigurationBuilder read(ServerIdentitiesConfiguration template, Combine combine) {
if (template.sslConfiguration() != null) {
sslConfiguration().read(template.sslConfiguration(), combine);
}
kerberosConfigurations.clear();
template.kerberosConfigurations().forEach(s -> addKerberosConfiguration().read(s, combine));
return this;
}
}
| 2,307
| 38.118644
| 126
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/KerberosSecurityFactoryConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
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.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.wildfly.security.credential.source.CredentialSource;
/**
* KerberosSecurityFactoryConfiguration.
*
* @author Tristan Tarrant
* @since 10.1
*/
public class KerberosSecurityFactoryConfiguration extends ConfigurationElement<KerberosSecurityFactoryConfiguration> {
private static final String[] DEFAULT_MECHANISM_NAMES = new String[]{"KRB5", "SPNEGO"};
static final AttributeDefinition<String> PRINCIPAL = AttributeDefinition.builder(Attribute.PRINCIPAL, null, String.class).build();
static final AttributeDefinition<String> KEYTAB_PATH = AttributeDefinition.builder(Attribute.KEYTAB_PATH, null, String.class).build();
static final AttributeDefinition<String> RELATIVE_TO = AttributeDefinition.builder(Attribute.RELATIVE_TO, Server.INFINISPAN_SERVER_CONFIG_PATH, String.class).build();
static final AttributeDefinition<Boolean> DEBUG = AttributeDefinition.builder(Attribute.DEBUG, false, Boolean.class).build();
static final AttributeDefinition<Long> FAIL_CACHE = AttributeDefinition.builder(Attribute.FAIL_CACHE, 0l, Long.class).build();
static final AttributeDefinition<Set<String>> MECHANISM_NAMES = AttributeDefinition.<Set<String>>builder(Attribute.MECHANISM_NAMES, new HashSet<>()).initializer(() -> new HashSet<>(Arrays.asList(DEFAULT_MECHANISM_NAMES))).build();
static final AttributeDefinition<Set<String>> MECHANISM_OIDS = AttributeDefinition.<Set<String>>builder(Attribute.MECHANISM_OIDS, new HashSet<>()).initializer(HashSet::new).build();
static final AttributeDefinition<Integer> MINIMUM_REMAINING_LIFETIME = AttributeDefinition.builder(Attribute.MINIMUM_REMAINING_LIFETIME, 0, Integer.class).build();
static final AttributeDefinition<Boolean> OBTAIN_KERBEROS_TICKET = AttributeDefinition.builder(Attribute.OBTAIN_KERBEROS_TICKET, false, Boolean.class).build();
static final AttributeDefinition<Map<String, Object>> OPTIONS = AttributeDefinition.<Map<String, Object>>builder("options", new HashMap<>()).initializer(HashMap::new).build();
static final AttributeDefinition<Integer> REQUEST_LIFETIME = AttributeDefinition.builder(Attribute.REQUEST_LIFETIME, 0, Integer.class).build();
static final AttributeDefinition<Boolean> REQUIRED = AttributeDefinition.builder(Attribute.REQUIRED, false, Boolean.class).build();
static final AttributeDefinition<Boolean> SERVER = AttributeDefinition.builder(Attribute.SERVER, true, Boolean.class).build();
static final AttributeDefinition<Boolean> WRAP_GSS_CREDENTIAL = AttributeDefinition.builder(Attribute.WRAP_GSS_CREDENTIAL, false, Boolean.class).build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(KerberosSecurityFactoryConfiguration.class, PRINCIPAL, KEYTAB_PATH, RELATIVE_TO, DEBUG, FAIL_CACHE,
MECHANISM_NAMES, MECHANISM_OIDS, MINIMUM_REMAINING_LIFETIME, OBTAIN_KERBEROS_TICKET, OPTIONS, REQUEST_LIFETIME,
REQUIRED, SERVER, WRAP_GSS_CREDENTIAL);
}
private final CredentialSource credentialSource;
KerberosSecurityFactoryConfiguration(AttributeSet attributes, CredentialSource credentialSource) {
super(Element.KERBEROS, attributes);
this.credentialSource = credentialSource;
}
public String getPrincipal() {
return attributes.attribute(PRINCIPAL).get();
}
public CredentialSource getCredentialSource() {
return credentialSource;
}
}
| 3,906
| 62.016129
| 233
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/LdapUserPasswordMapperConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.util.EnumSet;
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.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.realm.ldap.LdapSecurityRealmBuilder;
/**
* @since 10.0
*/
public class LdapUserPasswordMapperConfiguration extends ConfigurationElement<LdapUserPasswordMapperConfiguration> {
static final AttributeDefinition<String> FROM = AttributeDefinition.builder(Attribute.FROM, null, String.class).immutable().build();
static final AttributeDefinition<Boolean> VERIFIABLE = AttributeDefinition.builder(Attribute.VERIFIABLE, true, Boolean.class).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(LdapUserPasswordMapperConfiguration.class, FROM, VERIFIABLE);
}
LdapUserPasswordMapperConfiguration(AttributeSet attributes) {
super(Element.USER_PASSWORD_MAPPER, attributes);
}
EnumSet<ServerSecurityRealm.Feature> build(LdapSecurityRealmBuilder ldapRealmBuilder, RealmConfiguration realm) {
EnumSet<ServerSecurityRealm.Feature> features = EnumSet.noneOf(ServerSecurityRealm.Feature.class);
if (attributes.attribute(FROM).get() != null) {
LdapSecurityRealmBuilder.UserPasswordCredentialLoaderBuilder builder = ldapRealmBuilder.userPasswordCredentialLoader();
builder.setUserPasswordAttribute(attributes.attribute(FROM).get());
if (!attributes.attribute(VERIFIABLE).get()) {
builder.disableVerification();
} else {
/*
* At this stage, we can only guess that the user password attribute can be used for hashed password verification.
* The only way to verify this would be to attempt connecting to the LDAP server using the configured credentials,
* fetch the user password attribute and see if it is prefixed with one of the known hash names.
*
* See https://issues.redhat.com/browse/ELY-296
*/
features.add(ServerSecurityRealm.Feature.PASSWORD_HASHED);
}
builder.build(); // side-effect: adds the credential loader to the ldap realm
}
return features;
}
}
| 2,516
| 50.367347
| 149
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/GroupsPropertiesConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.GroupsPropertiesConfiguration.PATH;
import static org.infinispan.server.configuration.security.GroupsPropertiesConfiguration.RELATIVE_TO;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class GroupsPropertiesConfigurationBuilder implements Builder<GroupsPropertiesConfiguration> {
private final AttributeSet attributes;
GroupsPropertiesConfigurationBuilder() {
attributes = GroupsPropertiesConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public GroupsPropertiesConfigurationBuilder path(String path) {
attributes.attribute(PATH).set(path);
return this;
}
public GroupsPropertiesConfigurationBuilder relativeTo(String relativeTo) {
attributes.attribute(RELATIVE_TO).set(relativeTo);
return this;
}
@Override
public GroupsPropertiesConfiguration create() {
return new GroupsPropertiesConfiguration(attributes.protect());
}
@Override
public GroupsPropertiesConfigurationBuilder read(GroupsPropertiesConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 1,446
| 30.456522
| 110
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/KeyStoreConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.ALIAS;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.GENERATE_SELF_SIGNED_CERTIFICATE_HOST;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.KEYSTORE_PASSWORD;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.KEY_PASSWORD;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.PATH;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.PROVIDER;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.RELATIVE_TO;
import static org.infinispan.server.configuration.security.KeyStoreConfiguration.TYPE;
import java.util.function.Supplier;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.server.Server;
import org.infinispan.server.security.PasswordCredentialSource;
import org.wildfly.security.credential.source.CredentialSource;
/**
* @since 10.0
*/
public class KeyStoreConfigurationBuilder implements Builder<KeyStoreConfiguration> {
private final AttributeSet attributes;
private final RealmConfigurationBuilder realmBuilder;
KeyStoreConfigurationBuilder(RealmConfigurationBuilder realmBuilder) {
this.realmBuilder = realmBuilder;
this.attributes = KeyStoreConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public KeyStoreConfigurationBuilder alias(String alias) {
attributes.attribute(ALIAS).set(alias);
return this;
}
public KeyStoreConfigurationBuilder keyStorePassword(char[] keyStorePassword) {
attributes.attribute(KEYSTORE_PASSWORD).set(new PasswordCredentialSource(keyStorePassword));
return this;
}
public KeyStoreConfigurationBuilder keyStorePassword(Supplier<CredentialSource> keyStorePassword) {
attributes.attribute(KEYSTORE_PASSWORD).set(keyStorePassword);
return this;
}
public KeyStoreConfigurationBuilder generateSelfSignedCertificateHost(String certificateHost) {
attributes.attribute(GENERATE_SELF_SIGNED_CERTIFICATE_HOST).set(certificateHost);
return this;
}
@Deprecated
public KeyStoreConfigurationBuilder keyPassword(char[] keyPassword) {
attributes.attribute(KEY_PASSWORD).set(new PasswordCredentialSource(keyPassword));
return this;
}
public KeyStoreConfigurationBuilder path(String path) {
attributes.attribute(PATH).set(path);
return this;
}
public KeyStoreConfigurationBuilder provider(String value) {
attributes.attribute(PROVIDER).set(value);
return this;
}
public KeyStoreConfigurationBuilder relativeTo(String relativeTo) {
attributes.attribute(RELATIVE_TO).set(relativeTo);
return this;
}
public KeyStoreConfigurationBuilder type(String value) {
attributes.attribute(TYPE).set(value);
return this;
}
@Override
public void validate() {
if (attributes.attribute(PATH).isNull() && attributes.attribute(TYPE).isNull()) {
throw Server.log.filelessKeyStoreRequiresType();
}
}
@Override
public KeyStoreConfiguration create() {
return new KeyStoreConfiguration(attributes.protect());
}
@Override
public KeyStoreConfigurationBuilder read(KeyStoreConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 3,692
| 35.205882
| 119
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/AggregateRealmConfiguration.java
|
package org.infinispan.server.configuration.security;
import java.security.Principal;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.List;
import java.util.Properties;
import java.util.function.UnaryOperator;
import javax.security.auth.x500.X500Principal;
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.Server;
import org.infinispan.server.configuration.Attribute;
import org.infinispan.server.configuration.Element;
import org.infinispan.server.security.ServerSecurityRealm;
import org.wildfly.security.auth.principal.NamePrincipal;
import org.wildfly.security.auth.realm.AggregateSecurityRealm;
import org.wildfly.security.auth.server.NameRewriter;
import org.wildfly.security.auth.server.SecurityDomain;
import org.wildfly.security.auth.server.SecurityRealm;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class AggregateRealmConfiguration extends ConfigurationElement<AggregateRealmConfiguration> implements RealmProvider {
static final AttributeDefinition<String> NAME = AttributeDefinition.builder(Attribute.NAME, "aggregate", String.class).immutable().build();
static final AttributeDefinition<String> AUTHN_REALM = AttributeDefinition.builder(Attribute.AUTHENTICATION_REALM, null, String.class).immutable().build();
static final AttributeDefinition<List<String>> AUTHZ_REALMS = AttributeDefinition.builder(Attribute.AUTHORIZATION_REALMS, null, (Class<List<String>>) (Class<?>) List.class)
.initializer(ArrayList::new).immutable().build();
static final AttributeDefinition<NameRewriter> NAME_REWRITER = AttributeDefinition.builder(Element.NAME_REWRITER, NameRewriter.IDENTITY_REWRITER, NameRewriter.class).autoPersist(false).immutable().build();
static AttributeSet attributeDefinitionSet() {
return new AttributeSet(AggregateRealmConfiguration.class, NAME, AUTHN_REALM, AUTHZ_REALMS, NAME_REWRITER);
}
private EnumSet<ServerSecurityRealm.Feature> authenticationFeatures;
AggregateRealmConfiguration(AttributeSet attributes) {
super(Element.AGGREGATE_REALM, attributes);
}
@Override
public SecurityRealm build(SecurityConfiguration securityConfiguration, RealmConfiguration realm, SecurityDomain.Builder domainBuilder, Properties properties) {
domainBuilder.setDefaultRealmName(name()); // We make this the default realm
String authenticationRealm = authenticationRealm();
SecurityRealm authnRealm = realm.realms.get(authenticationRealm);
if (authnRealm == null) {
throw Server.log.unknownRealm(authenticationRealm);
}
authenticationFeatures = EnumSet.noneOf(ServerSecurityRealm.Feature.class);
for (RealmProvider provider : realm.realmProviders()) {
if (provider.name().equals(authenticationRealm)) {
provider.applyFeatures(authenticationFeatures);
}
}
List<String> names = authorizationRealms();
SecurityRealm[] authzRealms;
if (names.isEmpty()) { // we add all realms
authzRealms = realm.realms.values().toArray(SecurityRealm[]::new);
} else { // only the specified realms
authzRealms = new SecurityRealm[names.size()];
for (int i = 0; i < names.size(); i++) {
SecurityRealm securityRealm = realm.realms.get(names.get(i));
if (securityRealm == null) {
throw Server.log.unknownRealm(names.get(i));
} else {
authzRealms[i] = securityRealm;
}
}
}
return new AggregateSecurityRealm(authnRealm, asPrincipalRewriter(nameRewriter()), authzRealms);
}
@Override
public void applyFeatures(EnumSet<ServerSecurityRealm.Feature> features) {
// We need to reset the features: only the authentication realm features matter
features.retainAll(EnumSet.of(ServerSecurityRealm.Feature.ENCRYPT));
features.addAll(authenticationFeatures);
}
static UnaryOperator<Principal> asPrincipalRewriter(NameRewriter rewriter) {
return (principal) -> {
if (principal == null) {
return null;
} else if (principal instanceof NamePrincipal || principal instanceof X500Principal) {
String rewritten = rewriter.rewriteName(principal.getName());
return rewritten == null ? null : new NamePrincipal(rewritten);
} else {
return principal;
}
};
}
public String name() {
return attributes.attribute(NAME).get();
}
public String authenticationRealm() {
return attributes.attribute(AUTHN_REALM).get();
}
public List<String> authorizationRealms() {
return attributes.attribute(AUTHZ_REALMS).get();
}
public NameRewriter nameRewriter() {
return attributes.attribute(NAME_REWRITER).get();
}
}
| 5,013
| 42.224138
| 208
|
java
|
null |
infinispan-main/server/runtime/src/main/java/org/infinispan/server/configuration/security/JwtConfigurationBuilder.java
|
package org.infinispan.server.configuration.security;
import static org.infinispan.server.configuration.security.JwtConfiguration.AUDIENCE;
import static org.infinispan.server.configuration.security.JwtConfiguration.CLIENT_SSL_CONTEXT;
import static org.infinispan.server.configuration.security.JwtConfiguration.CONNECTION_TIMEOUT;
import static org.infinispan.server.configuration.security.JwtConfiguration.HOST_NAME_VERIFICATION_POLICY;
import static org.infinispan.server.configuration.security.JwtConfiguration.ISSUER;
import static org.infinispan.server.configuration.security.JwtConfiguration.JKU_TIMEOUT;
import static org.infinispan.server.configuration.security.JwtConfiguration.PUBLIC_KEY;
import static org.infinispan.server.configuration.security.JwtConfiguration.READ_TIMEOUT;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
/**
* @since 10.0
*/
public class JwtConfigurationBuilder implements Builder<JwtConfiguration> {
private final AttributeSet attributes;
JwtConfigurationBuilder() {
this.attributes = JwtConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
boolean isModified() {
return this.attributes.isModified();
}
public JwtConfigurationBuilder audience(String[] audience) {
attributes.attribute(AUDIENCE).set(audience);
return this;
}
public JwtConfigurationBuilder clientSSLContext(String value) {
attributes.attribute(CLIENT_SSL_CONTEXT).set(value);
return this;
}
public JwtConfigurationBuilder hostNameVerificationPolicy(String value) {
attributes.attribute(HOST_NAME_VERIFICATION_POLICY).set(value);
return this;
}
public JwtConfigurationBuilder issuers(String[] issuers) {
attributes.attribute(ISSUER).set(issuers);
return this;
}
public JwtConfigurationBuilder jkuTimeout(long timeout) {
attributes.attribute(JKU_TIMEOUT).set(timeout);
return this;
}
public JwtConfigurationBuilder publicKey(String publicKey) {
attributes.attribute(PUBLIC_KEY).set(publicKey);
return this;
}
public JwtConfigurationBuilder connectionTimeout(int timeout) {
attributes.attribute(CONNECTION_TIMEOUT).set(timeout);
return this;
}
public JwtConfigurationBuilder readTimeout(int timeout) {
attributes.attribute(READ_TIMEOUT).set(timeout);
return this;
}
@Override
public JwtConfiguration create() {
return new JwtConfiguration(attributes.protect());
}
@Override
public JwtConfigurationBuilder read(JwtConfiguration template, Combine combine) {
attributes.read(template.attributes(), combine);
return this;
}
}
| 2,842
| 32.05814
| 106
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.