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/rest/src/main/java/org/infinispan/rest/configuration/RestAuthenticationConfiguration.java
|
package org.infinispan.rest.configuration;
import java.util.ArrayList;
import java.util.List;
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.rest.authentication.RestAuthenticator;
import org.infinispan.server.core.configuration.AuthenticationConfiguration;
/**
* AuthenticationConfiguration.
*
* @author Tristan Tarrant
* @since 10.0
*/
public class RestAuthenticationConfiguration extends ConfigurationElement<RestAuthenticationConfiguration> implements AuthenticationConfiguration {
public static final AttributeDefinition<String> SECURITY_REALM = AttributeDefinition.builder("security-realm", null, String.class).immutable().build();
public static final AttributeDefinition<List<String>> MECHANISMS = AttributeDefinition.builder("mechanisms", null, (Class<List<String>>) (Class<?>) List.class)
.initializer(ArrayList::new).immutable().serializer(AttributeSerializer.STRING_COLLECTION).build();
public static final AttributeDefinition<Boolean> METRICS_AUTH = AttributeDefinition.builder("metrics-auth", true, Boolean.class).autoPersist(false).build();
private final Boolean enabled;
private final RestAuthenticator authenticator;
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(RestAuthenticationConfiguration.class, MECHANISMS, SECURITY_REALM, METRICS_AUTH);
}
RestAuthenticationConfiguration(AttributeSet attributes, RestAuthenticator authenticator, Boolean enabled) {
super("authentication", attributes);
this.enabled = enabled;
this.authenticator = authenticator;
}
public boolean enabled() {
return enabled;
}
public List<String> mechanisms() {
return attributes.attribute(MECHANISMS).get();
}
public RestAuthenticator authenticator() {
return authenticator;
}
public boolean metricsAuth() {
return attributes.attribute(METRICS_AUTH).get();
}
public String securityRealm() {
return attributes.attribute(SECURITY_REALM).get();
}
}
| 2,276
| 38.258621
| 162
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/configuration/CorsConfiguration.java
|
package org.infinispan.rest.configuration;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import io.netty.handler.codec.http.cors.CorsConfig;
/**
* @since 10.0
*/
public class CorsConfiguration extends ConfigurationElement<CorsConfiguration> {
private final List<CorsConfig> nettyCorsConfigs;
private List<CorsRuleConfiguration> corsConfigurations;
CorsConfiguration(List<CorsRuleConfiguration> corsConfigurations, List<CorsConfig> extraConfigs) {
super("cors-rules", AttributeSet.EMPTY, children(corsConfigurations));
this.corsConfigurations = corsConfigurations;
this.nettyCorsConfigs = corsConfigurations.stream().map(CorsRuleConfiguration::corsConfig).collect(Collectors.toList());
this.nettyCorsConfigs.addAll(extraConfigs);
}
public List<CorsRuleConfiguration> corsRules() {
return corsConfigurations;
}
List<CorsConfig> corsConfigs() {
return Collections.unmodifiableList(nettyCorsConfigs);
}
}
| 1,160
| 32.171429
| 126
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/configuration/CorsConfigurationBuilder.java
|
package org.infinispan.rest.configuration;
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;
import io.netty.handler.codec.http.cors.CorsConfig;
/**
* @since 10.0
*/
public class CorsConfigurationBuilder implements Builder<CorsConfiguration> {
private List<CorsRuleConfigurationBuilder> corsRules = new ArrayList<>();
private List<CorsConfig> extraConfigs = new ArrayList<>();
@Override
public AttributeSet attributes() {
return AttributeSet.EMPTY;
}
public CorsRuleConfigurationBuilder addNewRule() {
CorsRuleConfigurationBuilder builder = new CorsRuleConfigurationBuilder();
corsRules.add(builder);
return builder;
}
public CorsConfigurationBuilder add(List<CorsConfig> corsConfig) {
this.extraConfigs = corsConfig;
return this;
}
@Override
public CorsConfiguration create() {
List<CorsRuleConfiguration> cors = corsRules.stream().distinct().map(CorsRuleConfigurationBuilder::create).collect(Collectors.toList());
return new CorsConfiguration(cors, extraConfigs);
}
@Override
public CorsConfigurationBuilder read(CorsConfiguration template, Combine combine) {
corsRules.clear();
template.corsRules().forEach(r -> addNewRule().read(r, combine));
return this;
}
}
| 1,498
| 29.591837
| 142
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/configuration/RestAuthenticationConfigurationBuilder.java
|
package org.infinispan.rest.configuration;
import static org.infinispan.rest.configuration.RestAuthenticationConfiguration.MECHANISMS;
import static org.infinispan.rest.configuration.RestAuthenticationConfiguration.METRICS_AUTH;
import static org.infinispan.rest.configuration.RestAuthenticationConfiguration.SECURITY_REALM;
import java.util.List;
import org.infinispan.commons.configuration.Builder;
import org.infinispan.commons.configuration.Combine;
import org.infinispan.commons.configuration.attributes.AttributeSet;
import org.infinispan.rest.authentication.RestAuthenticator;
import org.infinispan.server.core.configuration.AbstractProtocolServerConfigurationChildBuilder;
import org.infinispan.server.core.configuration.AuthenticationConfigurationBuilder;
import org.infinispan.server.core.configuration.ProtocolServerConfigurationBuilder;
/**
* AuthenticationConfigurationBuilder.
*
* @author Tristan Tarrant
* @since 10.0
*/
public class RestAuthenticationConfigurationBuilder extends AbstractProtocolServerConfigurationChildBuilder<RestServerConfiguration, RestAuthenticationConfigurationBuilder, RestAuthenticationConfiguration> implements AuthenticationConfigurationBuilder<RestAuthenticationConfiguration> {
private final AttributeSet attributes;
private RestAuthenticator authenticator;
private boolean enabled;
RestAuthenticationConfigurationBuilder(ProtocolServerConfigurationBuilder builder) {
super(builder);
attributes = RestAuthenticationConfiguration.attributeDefinitionSet();
}
@Override
public AttributeSet attributes() {
return attributes;
}
public RestAuthenticationConfigurationBuilder enable() {
return enabled(true);
}
public RestAuthenticationConfigurationBuilder disable() {
return enabled(false);
}
public RestAuthenticationConfigurationBuilder enabled(boolean enabled) {
this.enabled = enabled;
return this;
}
public boolean enabled() {
return enabled;
}
public RestAuthenticationConfigurationBuilder securityRealm(String realm) {
attributes.attribute(SECURITY_REALM).set(realm);
return this;
}
public String securityRealm() {
return attributes.attribute(SECURITY_REALM).get();
}
public boolean hasSecurityRealm() {
return !attributes.attribute(SECURITY_REALM).isNull();
}
public RestAuthenticationConfigurationBuilder authenticator(RestAuthenticator authenticator) {
this.authenticator = authenticator;
return this.enable();
}
public RestAuthenticationConfigurationBuilder addMechanisms(String... mechanisms) {
List<String> mechs = attributes.attribute(MECHANISMS).get();
for (int i = 0; i < mechanisms.length; i++) {
mechs.add(mechanisms[i]);
}
attributes.attribute(MECHANISMS).set(mechs);
return this.enable();
}
public boolean hasMechanisms() {
return !attributes.attribute(MECHANISMS).get().isEmpty();
}
public List<String> mechanisms() {
return attributes.attribute(MECHANISMS).get();
}
public RestAuthenticationConfigurationBuilder metricsAuth(boolean metricsAuth) {
attributes.attribute(METRICS_AUTH).set(metricsAuth);
return this;
}
@Override
public void validate() {
if (enabled && authenticator == null) {
throw RestServerConfigurationBuilder.logger.authenticationWithoutAuthenticator();
}
}
@Override
public RestAuthenticationConfiguration create() {
return new RestAuthenticationConfiguration(attributes.protect(), authenticator, enabled);
}
@Override
public Builder<?> read(RestAuthenticationConfiguration template, Combine combine) {
this.attributes.read(template.attributes(), combine);
return this;
}
@Override
public RestAuthenticationConfigurationBuilder self() {
return this;
}
}
| 3,886
| 31.663866
| 286
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/configuration/CorsRuleConfiguration.java
|
package org.infinispan.rest.configuration;
import java.util.Arrays;
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.ConfigurationFormatFeature;
import io.netty.handler.codec.http.cors.CorsConfig;
/**
* @since 10.0
*/
public class CorsRuleConfiguration extends ConfigurationElement<CorsRuleConfiguration> {
public static final AttributeDefinition<String> NAME = AttributeDefinition.builder("name", null, String.class).immutable().build();
public static final AttributeDefinition<Boolean> ALLOW_CREDENTIALS = AttributeDefinition.builder("allow-credentials", null, Boolean.class).immutable().build();
public static final AttributeDefinition<Long> MAX_AGE = AttributeDefinition.builder("max-age-seconds", null, Long.class).immutable().build();
public static final AttributeDefinition<String[]> ALLOW_ORIGINS = AttributeDefinition.builder("allowed-origins", null, String[].class)
.serializer(stringArraySerializer())
.immutable().build();
public static final AttributeDefinition<String[]> ALLOW_METHODS = AttributeDefinition.builder("allowed-methods", null, String[].class)
.serializer(stringArraySerializer())
.immutable().build();
public static final AttributeDefinition<String[]> ALLOW_HEADERS = AttributeDefinition.builder("allowed-headers", null, String[].class)
.serializer(stringArraySerializer())
.immutable().build();
public static final AttributeDefinition<String[]> EXPOSE_HEADERS = AttributeDefinition.builder("expose-headers", null, String[].class)
.serializer(stringArraySerializer())
.immutable().build();
public static AttributeSet attributeDefinitionSet() {
return new AttributeSet(CorsRuleConfiguration.class, NAME, ALLOW_CREDENTIALS, MAX_AGE, ALLOW_ORIGINS, ALLOW_METHODS, ALLOW_HEADERS, EXPOSE_HEADERS);
}
private final CorsConfig corsConfig;
CorsRuleConfiguration(AttributeSet attributes, CorsConfig corsConfig) {
super("cors-rule", true, attributes);
this.corsConfig = corsConfig;
}
CorsConfig corsConfig() {
return corsConfig;
}
private static AttributeSerializer<String[]> stringArraySerializer() {
return (w, n, v) -> {
if (w.hasFeature(ConfigurationFormatFeature.MIXED_ELEMENTS)) {
w.writeAttribute(n, Arrays.asList(v));
} else {
w.writeArrayElement(n, n, null, Arrays.asList(v));
}
};
}
}
| 2,726
| 46.017241
| 162
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/stream/CacheChunkedStream.java
|
package org.infinispan.rest.stream;
import java.nio.charset.StandardCharsets;
import java.util.Objects;
import org.infinispan.commons.marshall.WrappedByteArray;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultHttpContent;
import io.netty.handler.codec.http.LastHttpContent;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import io.reactivex.rxjava3.subscribers.DefaultSubscriber;
import org.reactivestreams.Publisher;
public abstract class CacheChunkedStream<T> {
protected static final Log logger = LogFactory.getLog(CacheChunkedStream.class);
// Netty default value with `ChunkedStream`.
private static final int CHUNK_SIZE = 8192;
protected final Publisher<T> publisher;
public CacheChunkedStream(Publisher<T> publisher) {
this.publisher = publisher;
}
public static byte[] readContentAsBytes(Object content) {
if (content instanceof byte[]) return (byte[]) content;
if (content instanceof WrappedByteArray) {
return ((WrappedByteArray) content).getBytes();
}
return content.toString().getBytes(StandardCharsets.UTF_8);
}
public abstract void subscribe(ChannelHandlerContext ctx);
abstract static class ByteBufSubscriber<T> extends DefaultSubscriber<T> {
protected final ChannelHandlerContext ctx;
protected final ByteBufAllocator allocator;
protected final GenericFutureListener<Future<Void>> ERROR_LISTENER = f -> {
try {
f.get();
} catch (Throwable t) {
onError(t);
}
};
private boolean firstEntry = true;
private ByteBuf pendingBuffer;
protected ByteBufSubscriber(ChannelHandlerContext ctx, ByteBufAllocator allocator) {
this.ctx = Objects.requireNonNull(ctx);
this.allocator = Objects.requireNonNull(allocator);
}
protected ByteBuf newByteBuf() {
// Note this buffer will expand as necessary, but we allocate it with an extra 12.5% buffer to prevent resizes
// when we reach the chunk size
return allocator.buffer(CHUNK_SIZE + CHUNK_SIZE >> 3);
}
@Override
protected void onStart() {
ByteBuf buf = newByteBuf();
buf.writeByte('[');
pendingBuffer = buf;
request(1);
}
@Override
public void onNext(T item) {
ByteBuf pendingBuf = pendingBuffer;
if (!firstEntry) {
pendingBuf.writeByte(',');
} else {
firstEntry = false;
}
writeItem(item, pendingBuf);
// Buffer has surpassed our chunk size send it and reallocate
if (pendingBuf.writerIndex() > CHUNK_SIZE) {
writeToContext(pendingBuf, false).addListener(f -> {
try {
f.get();
request(1);
} catch (Throwable t) {
onError(t);
}
});
pendingBuffer = newByteBuf();
} else {
assert pendingBuf.writableBytes() > 0;
request(1);
}
}
// Implementation can writ the bytes for the given item into the provided ByteBuf. It is recommended to first
// call ByteBuf.ensureWritable(int) with the amount of bytes required to be written to avoid multiple resizes
abstract void writeItem(T item, ByteBuf pending);
@Override
public void onError(Throwable t) {
logger.error("Error encountered while streaming cache chunk", t);
if (pendingBuffer != null) {
pendingBuffer.release();
pendingBuffer = null;
}
cancel();
ctx.close();
}
@Override
public void onComplete() {
ByteBuf buf = pendingBuffer;
buf.writeByte(']');
writeToContext(buf, true)
.addListener(ERROR_LISTENER);
pendingBuffer = null;
}
ChannelFuture writeToContext(ByteBuf buf, boolean isComplete) {
ChannelFuture completeFuture = ctx.write(new DefaultHttpContent(buf));
if (isComplete) {
completeFuture = ctx.write(LastHttpContent.EMPTY_LAST_CONTENT);
}
ctx.flush();
return completeFuture;
}
}
}
| 4,507
| 31.431655
| 119
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/stream/CacheEntryStreamProcessor.java
|
package org.infinispan.rest.stream;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.container.versioning.EntryVersion;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.container.versioning.SimpleClusteredVersion;
import org.infinispan.metadata.Metadata;
import org.reactivestreams.Publisher;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
/**
* A {@link CacheChunkedStream} that reads {@link Map.Entry} and produces a JSON output.
* For example:
* <p>
* <pre>{@code
* [
* {"key":1,"value":"value","timeToLiveSeconds": -1, "maxIdleTimeSeconds": -1, "created": -1, "lastUsed": -1, "expireTime": -1},
* {"key":2,"value":"value2","timeToLiveSeconds": -1, "maxIdleTimeSeconds": -1, "created": -1, "lastUsed": -1, "expireTime": -1}
* ]
* }</pre>
*
*
* @since 12.0
*/
public class CacheEntryStreamProcessor extends CacheChunkedStream<CacheEntry<?, ?>> {
private final boolean keysAreJson;
private final boolean valuesAreJson;
private static final byte[] KEY_LABEL = "\"key\":".getBytes();
private static final byte[] VALUE_LABEL = "\"value\":".getBytes();
private static final byte OPEN_ITEM_CHAR = '{';
private static final byte SEPARATOR = ',';
private static final byte CLOSE_ITEM_CHAR = '}';
private final boolean includeMetadata;
public CacheEntryStreamProcessor(Publisher<CacheEntry<?, ?>> publisher, boolean keysAreJson, boolean valuesAreJson,
boolean includeMetadata) {
super(publisher);
this.keysAreJson = keysAreJson;
this.valuesAreJson = valuesAreJson;
this.includeMetadata = includeMetadata;
}
@Override
public void subscribe(ChannelHandlerContext ctx) {
publisher.subscribe(new EntrySubscriber(ctx, ctx.alloc()));
}
class EntrySubscriber extends ByteBufSubscriber<CacheEntry<?, ?>> {
protected EntrySubscriber(ChannelHandlerContext ctx, ByteBufAllocator allocator) {
super(ctx, allocator);
}
@Override
void writeItem(CacheEntry<?, ?> item, ByteBuf pending) {
byte[] keyBytes = escape(item.getKey(), keysAreJson);
byte[] valueBytes = escape(item.getValue(), valuesAreJson);
byte[] metadataBytes = includeMetadata ? metadataBytes(item) : null;
// 1 for {
// Key label
// Key bytes
// 2 for "" around key if not json
// 1 for ,
// Value label
// Value bytes
// 2 for "" around key if not json
// 1 for }
int bytesRequired = 1 + KEY_LABEL.length + keyBytes.length + (keysAreJson ? 0 : 2)
+ 1 + VALUE_LABEL.length + valueBytes.length + (valuesAreJson ? 0 : 2) + 1;
// Also add in metadataBytes as necessary
if (metadataBytes != null) {
bytesRequired += 1 + metadataBytes.length;
}
pending.ensureWritable(bytesRequired);
pending.writeByte(OPEN_ITEM_CHAR);
pending.writeBytes(KEY_LABEL);
if (!keysAreJson) pending.writeByte('"');
pending.writeBytes(keyBytes);
if (!keysAreJson) pending.writeByte('"');
pending.writeByte(SEPARATOR);
pending.writeBytes(VALUE_LABEL);
if (!valuesAreJson) pending.writeByte('"');
pending.writeBytes(valueBytes);
if (!valuesAreJson) pending.writeByte('"');
if (metadataBytes != null) {
pending.writeByte(SEPARATOR);
pending.writeBytes(metadataBytes);
}
pending.writeByte(CLOSE_ITEM_CHAR);
}
}
private byte[] escape(Object content, boolean json) {
byte[] asUTF = readContentAsBytes(content);
if (json) return asUTF;
return Json.help.escape(new String(asUTF)).getBytes(StandardCharsets.UTF_8);
}
private static byte[] metadataBytes(CacheEntry<?, ?> currentEntry) {
if (!(currentEntry instanceof InternalCacheEntry)) {
return null;
}
InternalCacheEntry ice = (InternalCacheEntry) currentEntry;
// add metadata
long lifespanInSeconds = ice.getLifespan();
if (lifespanInSeconds > -1) {
lifespanInSeconds = TimeUnit.MILLISECONDS.toSeconds(lifespanInSeconds);
}
long maxIdleInSeconds = ice.getMaxIdle();
if (maxIdleInSeconds > -1) {
maxIdleInSeconds = TimeUnit.MILLISECONDS.toSeconds(maxIdleInSeconds);
}
long created = ice.getCreated();
long lastUsed = ice.getLastUsed();
long expiryTime = ice.getExpiryTime();
Metadata metadata = currentEntry.getMetadata();
EntryVersion version = (metadata == null) ? null : metadata.version();
return metadataBytes(lifespanInSeconds, maxIdleInSeconds, created, lastUsed, expiryTime, version);
}
private static byte[] metadataBytes(long timeToLiveSeconds, long maxIdleTimeSeconds, long created, long lastUsed,
long expireTime, EntryVersion entryVersion) {
Long version = null;
Integer topologyId = null;
if (entryVersion instanceof NumericVersion) {
version = ((NumericVersion) entryVersion).getVersion();
} else if (entryVersion instanceof SimpleClusteredVersion) {
version = ((SimpleClusteredVersion) entryVersion).getVersion();
topologyId = ((SimpleClusteredVersion) entryVersion).getTopologyId();
}
StringBuilder metadata = new StringBuilder();
metadata.append("\"timeToLiveSeconds\":");
metadata.append(timeToLiveSeconds);
metadata.append(",\"maxIdleTimeSeconds\":");
metadata.append(maxIdleTimeSeconds);
metadata.append(",\"created\":");
metadata.append(created);
metadata.append(",\"lastUsed\":");
metadata.append(lastUsed);
metadata.append(",\"expireTime\":");
metadata.append(expireTime);
if (version != null) {
metadata.append(",\"version\":");
metadata.append(version);
}
if (topologyId != null) {
metadata.append(",\"topologyId\":");
metadata.append(topologyId);
}
return metadata.toString().getBytes();
}
}
| 6,401
| 35.793103
| 130
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/stream/CacheKeyStreamProcessor.java
|
package org.infinispan.rest.stream;
import static java.nio.charset.StandardCharsets.UTF_8;
import org.reactivestreams.Publisher;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
/**
* A {@link CacheChunkedStream} that reads from a <code>byte[]</code> and produces a JSON output.
*
* @since 10.0
*/
public class CacheKeyStreamProcessor extends CacheChunkedStream<byte[]> {
public CacheKeyStreamProcessor(Publisher<byte[]> publisher) {
super(publisher);
}
@Override
public void subscribe(ChannelHandlerContext ctx) {
publisher.subscribe(new KeySubscriber(ctx, ctx.alloc()));
}
static class KeySubscriber extends ByteBufSubscriber<byte[]> {
protected KeySubscriber(ChannelHandlerContext ctx, ByteBufAllocator allocator) {
super(ctx, allocator);
}
@Override
void writeItem(byte[] item, ByteBuf pending) {
String stringified = new String(item, UTF_8);
byte[] bytesToWrite = stringified.replaceAll("\"", "\\\\\"")
.getBytes(UTF_8);
pending.ensureWritable(bytesToWrite.length + 2);
pending.writeByte('"');
pending.writeBytes(bytesToWrite);
pending.writeByte('"');
}
}
}
| 1,287
| 28.272727
| 97
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/distribution/DataDistributionContextInitializer.java
|
package org.infinispan.rest.distribution;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
@AutoProtoSchemaBuilder(
dependsOn = org.infinispan.marshall.persistence.impl.PersistenceContextInitializer.class,
includeClasses = {
CacheDistributionInfo.class,
NodeDistributionInfo.class,
KeyDistributionInfo.class,
},
schemaFileName = "persistence.distribution.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.persistence.distribution",
service = false
)
public interface DataDistributionContextInitializer extends SerializationContextInitializer { }
| 744
| 38.210526
| 95
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/distribution/NodeDataDistribution.java
|
package org.infinispan.rest.distribution;
import java.util.List;
/**
* Identifies a specific node on a data distribution response.
*
* @since 14.0
*/
public interface NodeDataDistribution {
String name();
List<String> addresses();
}
| 247
| 14.5
| 62
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/distribution/NodeDistributionInfo.java
|
package org.infinispan.rest.distribution;
import static org.infinispan.commons.marshall.ProtoStreamTypeIds.CLUSTER_DISTRIBUTION_INFO;
import static org.infinispan.stats.impl.LocalContainerStatsImpl.LOCAL_CONTAINER_STATS;
import java.util.ArrayList;
import java.util.List;
import net.jcip.annotations.Immutable;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.manager.CacheManagerInfo;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
import org.infinispan.stats.ClusterContainerStats;
/**
* Collect node's information and statistics of the local JVM.
* <p/>
* Contains information about the node name and address; the JVM statistics are memory used and available,
* all in bytes. We rely on {@link ClusterContainerStats} to retrieve the JVM values, so if the collector is
* disabled, we return -1.
*
* @author José Bolina
* @see 14.0
*/
@Immutable
@ProtoTypeId(CLUSTER_DISTRIBUTION_INFO)
public class NodeDistributionInfo implements JsonSerialization, NodeDataDistribution {
private final String name;
private final List<String> addresses;
private final long memoryAvailable;
private final long memoryUsed;
@ProtoFactory
public NodeDistributionInfo(String name, List<String> addresses, long memoryAvailable, long memoryUsed) {
this.name = name;
this.addresses = addresses;
this.memoryAvailable = memoryAvailable;
this.memoryUsed = memoryUsed;
}
@ProtoField(1)
@Override
public String name() {
return name;
}
@ProtoField(value = 2, collectionImplementation = ArrayList.class)
@Override
public List<String> addresses() {
return addresses;
}
@ProtoField(value = 3, defaultValue = "0")
public long memoryAvailable() {
return memoryAvailable;
}
@ProtoField(value = 4, defaultValue = "0")
public long memoryUsed() {
return memoryUsed;
}
@Override
public Json toJson() {
return Json.object()
.set("node_name", name)
.set("node_addresses", Json.array(addresses.toArray()))
.set("memory_available", memoryAvailable)
.set("memory_used", memoryUsed);
}
public static NodeDistributionInfo resolve(CacheManagerInfo manager, GlobalComponentRegistry registry) {
String name = manager.getNodeName();
List<String> addresses = manager.getPhysicalAddressesRaw();
final ClusterContainerStats stats = registry.getComponent(ClusterContainerStats.class, LOCAL_CONTAINER_STATS);
return new NodeDistributionInfo(name, addresses, stats.getMemoryAvailable(), stats.getMemoryUsed());
}
}
| 2,876
| 33.662651
| 116
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/distribution/CompleteKeyDistribution.java
|
package org.infinispan.rest.distribution;
import java.util.List;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
public class CompleteKeyDistribution implements JsonSerialization {
private final List<KeyDistributionInfo> distribution;
private final boolean containsKeys;
public CompleteKeyDistribution(List<KeyDistributionInfo> distribution, boolean containsKeys) {
this.distribution = distribution;
this.containsKeys = containsKeys;
}
@Override
public Json toJson() {
return Json.object()
.set("contains_key", containsKeys)
.set("owners", Json.array(distribution.stream().map(KeyDistributionInfo::toJson).toArray()));
}
}
| 776
| 31.375
| 105
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/distribution/KeyDistributionInfo.java
|
package org.infinispan.rest.distribution;
import static org.infinispan.commons.marshall.ProtoStreamTypeIds.KEY_DISTRIBUTION_INFO;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.manager.CacheManagerInfo;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
@ProtoTypeId(KEY_DISTRIBUTION_INFO)
public class KeyDistributionInfo implements JsonSerialization, NodeDataDistribution {
private final String name;
private final boolean primary;
private final List<String> addresses;
@ProtoFactory
public KeyDistributionInfo(String name, boolean primary, List<String> addresses) {
this.name = name;
this.primary = primary;
this.addresses = addresses;
}
@ProtoField(1)
@Override
public String name() {
return name;
}
@ProtoField(value = 2, defaultValue = "false")
public boolean primary() {
return primary;
}
@ProtoField(value = 3, collectionImplementation = ArrayList.class)
@Override
public List<String> addresses() {
return addresses;
}
@Override
public Json toJson() {
return Json.object()
.set("node_name", name)
.set("primary", primary)
.set("node_addresses", Json.array(addresses.toArray()));
}
public static KeyDistributionInfo resolve(AdvancedCache<?, ?> cache, boolean primary) {
final CacheManagerInfo manager = cache.getCacheManager().getCacheManagerInfo();
return new KeyDistributionInfo(manager.getNodeName(), primary, manager.getPhysicalAddressesRaw());
}
}
| 1,848
| 30.338983
| 104
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/distribution/CacheDistributionInfo.java
|
package org.infinispan.rest.distribution;
import static org.infinispan.commons.marshall.ProtoStreamTypeIds.CACHE_DISTRIBUTION_INFO;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.manager.CacheManagerInfo;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.protostream.annotations.ProtoTypeId;
import org.infinispan.stats.Stats;
@ProtoTypeId(CACHE_DISTRIBUTION_INFO)
public class CacheDistributionInfo implements JsonSerialization, NodeDataDistribution {
private final String name;
private final List<String> addresses;
private final long memoryEntries;
private final long totalEntries;
private final long memoryUsed;
@ProtoFactory
public CacheDistributionInfo(String name, List<String> addresses, long memoryEntries, long totalEntries, long memoryUsed) {
this.name = name;
this.addresses = addresses;
this.memoryEntries = memoryEntries;
this.totalEntries = totalEntries;
this.memoryUsed = memoryUsed;
}
@ProtoField(1)
@Override
public String name() {
return name;
}
@ProtoField(value = 2, collectionImplementation = ArrayList.class)
@Override
public List<String> addresses() {
return addresses;
}
@ProtoField(value = 3, defaultValue = "0")
public long memoryEntries() {
return memoryEntries;
}
@ProtoField(value = 4, defaultValue = "0")
public long totalEntries() {
return totalEntries;
}
@ProtoField(value = 5, defaultValue = "0")
public long memoryUsed() {
return memoryUsed;
}
@Override
public Json toJson() {
return Json.object()
.set("node_name", name)
.set("node_addresses", Json.array(addresses.toArray()))
.set("memory_entries", memoryEntries)
.set("total_entries", totalEntries)
.set("memory_used", memoryUsed);
}
public static CacheDistributionInfo resolve(AdvancedCache<?, ?> cache) {
final CacheManagerInfo manager = cache.getCacheManager().getCacheManagerInfo();
return resolve(cache, manager);
}
public static CacheDistributionInfo resolve(AdvancedCache<?, ?> cache, CacheManagerInfo manager) {
final Stats stats = cache.getStats();
long inMemory = stats.getApproximateEntriesInMemory();
long total = stats.getApproximateEntries();
return new CacheDistributionInfo(manager.getNodeName(), manager.getPhysicalAddressesRaw(), inMemory, total,
stats.getDataMemoryUsed());
}
}
| 2,754
| 31.797619
| 126
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/cachemanager/package-info.java
|
/**
* Cache manager wrapper for REST interface.
*
* @api.private
*/
package org.infinispan.rest.cachemanager;
| 114
| 15.428571
| 44
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/cachemanager/RestCacheManager.java
|
package org.infinispan.rest.cachemanager;
import static org.infinispan.commons.dataconversion.MediaType.MATCH_ALL;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import javax.security.auth.Subject;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.util.Immutables;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.container.entries.CacheEntry;
import org.infinispan.context.Flag;
import org.infinispan.distribution.DistributionInfo;
import org.infinispan.distribution.DistributionManager;
import org.infinispan.distribution.LocalizedCacheTopology;
import org.infinispan.encoding.impl.StorageConfigurationManager;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.manager.ClusterExecutor;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.manager.EmbeddedCacheManagerAdmin;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachemanagerlistener.annotation.CacheStopped;
import org.infinispan.notifications.cachemanagerlistener.event.CacheStoppedEvent;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.remoting.transport.Address;
import org.infinispan.remoting.transport.Transport;
import org.infinispan.remoting.transport.jgroups.JGroupsTransport;
import org.infinispan.rest.distribution.CacheDistributionInfo;
import org.infinispan.rest.distribution.CompleteKeyDistribution;
import org.infinispan.rest.distribution.KeyDistributionInfo;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.logging.Log;
import org.infinispan.security.AuthorizationManager;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.security.impl.Authorizer;
import org.infinispan.server.core.CacheInfo;
import org.infinispan.topology.LocalTopologyManager;
import org.infinispan.util.KeyValuePair;
import org.infinispan.util.concurrent.CompletionStages;
import org.infinispan.util.function.SerializableFunction;
import org.infinispan.util.logging.LogFactory;
/**
* Manages caches instances used during rest requests.
*/
public class RestCacheManager<V> {
protected final static Log logger = LogFactory.getLog(RestCacheManager.class, Log.class);
private final EmbeddedCacheManager instance;
private final InternalCacheRegistry icr;
private final Predicate<? super String> isCacheIgnored;
private final boolean allowInternalCacheAccess;
private final Map<String, CacheInfo<Object, V>> knownCaches = new ConcurrentHashMap<>(4, 0.9f, 16);
private final RemoveCacheListener removeCacheListener;
private final Authorizer authorizer;
public RestCacheManager(EmbeddedCacheManager instance, Predicate<? super String> isCacheIgnored) {
this.instance = instance;
this.isCacheIgnored = isCacheIgnored;
this.icr = SecurityActions.getGlobalComponentRegistry(instance).getComponent(InternalCacheRegistry.class);
this.authorizer = SecurityActions.getGlobalComponentRegistry(instance).getComponent(Authorizer.class);
this.allowInternalCacheAccess = SecurityActions.getCacheManagerConfiguration(instance)
.security().authorization().enabled();
removeCacheListener = new RemoveCacheListener();
SecurityActions.addListener(instance, removeCacheListener);
}
public AdvancedCache<Object, V> getCache(String name, MediaType keyContentType, MediaType valueContentType, RestRequest request) {
Subject subject = request.getSubject();
Flag[] flags = request.getFlags();
if (isCacheIgnored.test(name)) {
throw logger.cacheUnavailable(name);
}
if (keyContentType == null || valueContentType == null) {
throw logger.missingRequiredMediaType(name);
}
checkCacheAvailable(name);
CacheInfo<Object, V> cacheInfo = knownCaches.get(name);
if (cacheInfo == null) {
AdvancedCache<Object, V> cache = instance.<Object, V>getCache(name).getAdvancedCache()
.withFlags(Flag.IGNORE_RETURN_VALUES);
cacheInfo = new CacheInfo<>(cache);
knownCaches.putIfAbsent(name, cacheInfo);
}
AdvancedCache<Object, V> cache = cacheInfo.getCache(new KeyValuePair<>(keyContentType, valueContentType), subject);
if (flags != null && flags.length > 0) cache = cache.withFlags(flags);
return cache;
}
public AdvancedCache<Object, V> getCache(String name, MediaType keyContentType, RestRequest request) {
if (keyContentType == null)
return getCache(name, request);
return getCache(name, keyContentType, MATCH_ALL, request);
}
public AdvancedCache<Object, V> getCache(String name, RestRequest restRequest) {
return getCache(name, MATCH_ALL, MATCH_ALL, restRequest);
}
public boolean cacheExists(String name) {
return instance.cacheExists(name);
}
private void checkCacheAvailable(String cacheName) {
if (!instance.isRunning(cacheName)) {
GlobalComponentRegistry gcr = SecurityActions.getGlobalComponentRegistry(instance);
LocalTopologyManager ltm = gcr.getLocalTopologyManager();
if (ltm != null) ltm.assertTopologyStable(cacheName);
throw logger.cacheNotFound(cacheName);
} else if (icr.isInternalCache(cacheName)) {
if (icr.isPrivateCache(cacheName)) {
throw logger.requestNotAllowedToInternalCaches(cacheName);
} else if (!allowInternalCacheAccess && !icr.internalCacheHasFlag(cacheName, InternalCacheRegistry.Flag.USER)) {
throw logger.requestNotAllowedToInternalCachesWithoutAuthz(cacheName);
}
}
}
public boolean isCacheQueryable(Cache<?, ?> cache) {
return SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache())
.getComponent(StorageConfigurationManager.class)
.isQueryable();
}
public Collection<String> getCacheNames() {
return instance.getCacheNames();
}
public Collection<String> getAccessibleCacheNames() {
return instance.getAccessibleCacheNames();
}
public CompletionStage<CacheEntry<Object, V>> getInternalEntry(String cacheName, Object key, MediaType keyContentType, MediaType mediaType, RestRequest request) {
return getInternalEntry(cacheName, key, false, keyContentType, mediaType, request);
}
public CompletionStage<V> remove(String cacheName, Object key, MediaType keyContentType, RestRequest restRequest) {
Cache<Object, V> cache = getCache(cacheName, keyContentType, MediaType.MATCH_ALL, restRequest);
return cache.removeAsync(key);
}
public CompletionStage<CacheEntry<Object, V>> getPrivilegedInternalEntry(AdvancedCache<Object, V> cache, Object key, boolean skipListener) {
AdvancedCache<Object, V> cacheSkip = skipListener ? cache.withFlags(Flag.SKIP_LISTENER_NOTIFICATION) : cache;
return SecurityActions.getCacheEntryAsync(cacheSkip, key);
}
private CompletionStage<CacheEntry<Object, V>> getInternalEntry(AdvancedCache<Object, V> cache, Object key, boolean skipListener) {
return skipListener ? cache.withFlags(Flag.SKIP_LISTENER_NOTIFICATION).getCacheEntryAsync(key) : cache.getCacheEntryAsync(key);
}
public MediaType getValueConfiguredFormat(String cacheName, RestRequest restRequest) {
return SecurityActions.getCacheConfiguration(getCache(cacheName, restRequest)).encoding().valueDataType().mediaType();
}
private CompletionStage<CacheEntry<Object, V>> getInternalEntry(String cacheName, Object key, boolean skipListener, MediaType keyContentType, MediaType mediaType, RestRequest restRequest) {
return getInternalEntry(getCache(cacheName, keyContentType, mediaType, restRequest), key, skipListener);
}
public String getNodeName() {
Address addressToBeReturned = instance.getAddress();
if (addressToBeReturned == null) {
return "0.0.0.0";
}
return addressToBeReturned.toString();
}
public String getServerAddress() {
Transport transport = instance.getTransport();
if (transport instanceof JGroupsTransport) {
return transport.getPhysicalAddresses().toString();
}
return "0.0.0.0";
}
public String getPrimaryOwner(String cacheName, Object key, RestRequest restRequest) {
DistributionManager dm = SecurityActions.getDistributionManager(getCache(cacheName, restRequest));
if (dm == null) {
//this is a local cache
return "0.0.0.0";
}
return dm.getCacheTopology().getDistribution(key).primary().toString();
}
public String getBackupOwners(String cacheName, Object key, RestRequest restRequest) {
DistributionManager dm = SecurityActions.getDistributionManager(getCache(cacheName, restRequest));
if (dm == null) {
//this is a local cache
return "0.0.0.0";
}
return dm.getCacheTopology().getDistribution(key).writeBackups().stream().map(a -> a.toString()).collect(Collectors.joining(" "));
}
public EmbeddedCacheManager getInstance() {
return instance;
}
public Authorizer getAuthorizer() {
return authorizer;
}
public EmbeddedCacheManagerAdmin getCacheManagerAdmin(RestRequest restRequest) {
Subject subject = restRequest.getSubject();
if (subject == null) {
return instance.administration();
} else {
return Security.doAs(subject, () -> instance.administration().withSubject(subject));
}
}
public void stop() {
if (removeCacheListener != null) {
CompletionStages.join(SecurityActions.removeListenerAsync(instance, removeCacheListener));
}
}
public void resetCacheInfo(String cacheName) {
knownCaches.remove(cacheName);
}
public CompletionStage<List<CacheDistributionInfo>> cacheDistribution(String cacheName, RestRequest request) {
AdvancedCache<?, ?> ac = getCache(cacheName, request);
checkCachePermission(ac, request.getSubject(), AuthorizationPermission.MONITOR);
DistributionManager dm = SecurityActions.getDistributionManager(ac);
if (dm == null) {
CacheDistributionInfo local = CacheDistributionInfo.resolve(ac, instance.getCacheManagerInfo());
return CompletableFuture.completedFuture(Collections.singletonList(local));
}
return requestMembers(dm.getCacheTopology().getMembers(), ecm -> {
Cache<?, ?> c = SecurityActions.getCache(ecm, cacheName);
return CacheDistributionInfo.resolve(c.getAdvancedCache());
});
}
public CompletionStage<CompleteKeyDistribution> getKeyDistribution(String cacheName, Object key, RestRequest request) {
AdvancedCache<Object, ?> cache = getCache(cacheName, request.keyContentType(), request);
checkCachePermission(cache, request.getSubject(), AuthorizationPermission.MONITOR);
return SecurityActions.cacheContainsKeyAsync(cache, key)
.thenCompose(contains -> {
DistributionManager dm = SecurityActions.getDistributionManager(cache);
if (dm == null) {
KeyDistributionInfo local = KeyDistributionInfo.resolve(cache, true);
return CompletableFuture.completedFuture(new CompleteKeyDistribution(Collections.singletonList(local), contains));
}
LocalizedCacheTopology topology = dm.getCacheTopology();
List<Address> members = topology.getMembers();
Address primary = null;
if (contains) {
DistributionInfo distribution = topology.getDistribution(key);
members = distribution.readOwners();
primary = distribution.primary();
}
final Address p = primary;
return requestMembers(members, ecm -> {
Cache<?, ?> c = SecurityActions.getCache(ecm, cacheName);
boolean isPrimary = p != null && ecm.getAddress().equals(p);
return KeyDistributionInfo.resolve(c.getAdvancedCache(), isPrimary);
}).thenApply(d -> new CompleteKeyDistribution(d, contains));
});
}
private <T> CompletionStage<List<T>> requestMembers(List<Address> addresses, SerializableFunction<EmbeddedCacheManager, T> function) {
Map<Address, T> responses = new ConcurrentHashMap<>();
ClusterExecutor executor = SecurityActions.getClusterExecutor(instance);
return executor.filterTargets(addresses)
.submitConsumer(function, (address, res, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
}
responses.put(address, res);
}).thenApply(ignore -> Immutables.immutableListConvert(responses.values()));
}
private void checkCachePermission(AdvancedCache<?, ?> ac, Subject subject, AuthorizationPermission permission) {
AuthorizationManager am = SecurityActions.getCacheAuthorizationManager(ac);
if (am != null) {
am.checkPermission(subject, permission);
}
}
@Listener
class RemoveCacheListener {
@CacheStopped
public void cacheStopped(CacheStoppedEvent event) {
resetCacheInfo(event.getCacheName());
}
}
}
| 13,713
| 43.381877
| 192
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/cachemanager/exceptions/CacheNotFoundException.java
|
package org.infinispan.rest.cachemanager.exceptions;
import org.infinispan.commons.CacheException;
public class CacheNotFoundException extends CacheException {
public CacheNotFoundException(String msg) {
super(msg);
}
}
| 234
| 22.5
| 60
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/cachemanager/exceptions/CacheUnavailableException.java
|
package org.infinispan.rest.cachemanager.exceptions;
import org.infinispan.commons.CacheException;
public class CacheUnavailableException extends CacheException {
public CacheUnavailableException(String msg) {
super(msg);
}
}
| 240
| 23.1
| 63
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/logging/Messages.java
|
package org.infinispan.rest.logging;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageBundle;
/**
* Informational Scripting messages. These start from 12500 so as not to overlap with the logging
* messages defined in {@link Log} Messages.
*
* @author Tristan Tarrant
* @since 12.1
*/
@MessageBundle(projectCode = "ISPN")
public interface Messages {
Messages MSG = org.jboss.logging.Messages.getBundle(Messages.class);
@Message(value = "Reject rule '%s' matches request address '%s'", id = 12500)
String rejectRuleMatchesRequestAddress(Object rule, Object address);
@Message(value = "Request to stop connector '%s' attempted from the connector itself", id = 12501)
String connectorMatchesRequest(String connectorName);
@Message(value = "Connection to data source '%s' successful", id = 12502)
String dataSourceTestOk(String name);
@Message(value = "Connection to data source '%s' failed. Verify that the JDBC URL and credentials are correct and that the driver is present in the server library directory", id = 12503)
String dataSourceTestFail(String name);
}
| 1,139
| 38.310345
| 189
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/logging/Log.java
|
package org.infinispan.rest.logging;
import static org.jboss.logging.Logger.Level.ERROR;
import static org.jboss.logging.Logger.Level.INFO;
import static org.jboss.logging.Logger.Level.WARN;
import java.io.IOException;
import java.util.NoSuchElementException;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.rest.cachemanager.exceptions.CacheUnavailableException;
import org.infinispan.rest.framework.Invocation;
import org.infinispan.rest.framework.Method;
import org.infinispan.rest.framework.RegistrationException;
import org.infinispan.rest.operations.exceptions.NoCacheFoundException;
import org.infinispan.rest.operations.exceptions.ServiceUnavailableException;
import org.infinispan.rest.operations.exceptions.UnacceptableDataFormatException;
import org.jboss.logging.BasicLogger;
import org.jboss.logging.Logger;
import org.jboss.logging.annotations.Cause;
import org.jboss.logging.annotations.LogMessage;
import org.jboss.logging.annotations.Message;
import org.jboss.logging.annotations.MessageLogger;
/**
* Log abstraction for the REST server module. For this module, message ids ranging from 12001 to 13000 inclusively have
* been reserved.
*
* @author Galder Zamarreño
* @since 5.0
*/
@MessageLogger(projectCode = "ISPN")
public interface Log extends BasicLogger {
Log REST = Logger.getMessageLogger(Log.class, org.infinispan.util.logging.Log.LOG_ROOT + "REST");
// @Message(value = "Error transcoding content", id = 495)
// EncodingException errorTranscoding(@Cause Throwable cause);
@Message(value = "Unsupported configuration option", id = 12004)
UnsupportedOperationException unsupportedConfigurationOption();
@LogMessage(level = ERROR)
@Message(value = "An error occurred while responding to the client", id = 12005)
void errorWhileResponding(@Cause Throwable t);
@LogMessage(level = ERROR)
@Message(value = "Uncaught exception in the pipeline", id = 12006)
void uncaughtExceptionInThePipeline(@Cause Throwable e);
@Message(value = "Cannot convert to %s", id = 12007)
UnacceptableDataFormatException unsupportedDataFormat(String mediaType);
@Message(value = "Cache with name '%s' is temporarily unavailable.", id = 12008)
ServiceUnavailableException cacheUnavailable(String cacheName);
@Message(value = "Cannot obtain cache '%s', without required MediaType", id = 12009)
NullPointerException missingRequiredMediaType(String cacheName);
@Message(value = "Cache with name '%s' not found amongst the configured caches", id = 12010)
NoCacheFoundException cacheNotFound(String cacheName);
@Message(value = "Remote requests are not allowed to private caches. Do no send remote requests to cache '%s'", id = 12011)
CacheUnavailableException requestNotAllowedToInternalCaches(String cacheName);
@Message(value = "Remote requests are not allowed to internal caches when authorization is disabled. Do no send remote requests to cache '%s'", id = 12012)
CacheUnavailableException requestNotAllowedToInternalCachesWithoutAuthz(String cacheName);
@Message(value = "Illegal compression level '%d'. The value must be >= 0 and <= 9", id = 12014)
CacheConfigurationException illegalCompressionLevel(int compressionLevel);
@Message(value = "Cannot register invocation '%s': resource already registered for method '%s' at the destination path '/%s'", id = 12015)
RegistrationException duplicateResourceMethod(String invocationName, Method method, String existingPath);
@LogMessage(level = WARN)
@Message(value = "Header '%s' will be ignored, expecting a number but got '%s'", id = 12016)
void warnInvalidNumber(String header, String value);
@Message(value = "Cannot enable authentication without an authenticator", id = 12017)
CacheConfigurationException authenticationWithoutAuthenticator();
@Message(value = "Cannot register invocation with path '%s': '*' is only allowed at the end", id = 12018)
RegistrationException invalidPath(String path);
@Message(value = "Cannot register path '%s' for invocation '%s', since it conflicts with resource '%s'", id = 12019)
RegistrationException duplicateResource(String candidate, Invocation invocation, String existingPath);
@LogMessage(level = INFO)
@Message(value = "MassIndexer started", id = 12020)
void asyncMassIndexerStarted();
@LogMessage(level = INFO)
@Message(value = "MassIndexer completed successfully", id = 12021)
void asyncMassIndexerSuccess();
@LogMessage(level = ERROR)
@Message(value = "Error executing MassIndexer", id = 12022)
void errorExecutingMassIndexer(@Cause Throwable e);
@Message(value = "Argument '%s' has illegal value '%s'", id = 12023)
IllegalArgumentException illegalArgument(String name, Object value);
@Message(value = "Synchronized %d entries", id = 12024)
String synchronizedEntries(long hotrod);
@LogMessage(level = WARN)
@Message(value = "Ignoring invalid origin '%s' when reading '-D%s'", id = 12025)
void invalidOrigin(String origin, String prop);
@LogMessage(level = WARN)
@Message(value = "The REST invocation [%s] has been deprecated. Please consult the upgrade guide", id = 12026)
void warnDeprecatedCall(String invocation);
@Message(value = "Security authorization is not enabled on this server.", id = 12027)
IllegalArgumentException authorizationNotEnabled();
@Message(value = "The principal-role mapper is not mutable", id = 12028)
String principalRoleMapperNotMutable();
@Message(value = "The role-permission mapper is not mutable", id = 12029)
String rolePermissionMapperNotMutable();
@Message(value = "Heap dump generation failed", id = 12030)
RuntimeException heapDumpFailed(@Cause IOException e);
@Message(value = "Method requires content", id = 12031)
IllegalArgumentException missingContent();
@Message(value = "Wrong media type '%s'. Expecting '%s'", id = 12032)
IllegalArgumentException wrongMediaType(String mediaType, String expected);
@Message(value = "Wrong content: expecting multipart/form-data with two parts", id = 12033)
IllegalArgumentException cacheCompareWrongContent();
@Message(value = "Wrong method '%s'", id = 12034)
IllegalArgumentException wrongMethod(String method);
@Message(value = "Attribute '%s' is immutable", id = 12035)
IllegalArgumentException immutableAttribute(String attributeName);
@Message(value = "More than one remote store detected, rolling upgrades aren't supported", id = 12036)
IllegalStateException multipleRemoteStores();
@Message(value = "Unknown action '%s'", id = 12037)
IllegalArgumentException unknownAction(String action);
@Message(value = "'%s' must be a directory", id = 12038)
IllegalArgumentException notADirectory(String dir);
@Message(value = "Restore failed", id = 12039)
IllegalStateException restoreFailed();
@Message(value = "Missing required argument '%s'", id = 12040)
IllegalArgumentException missingArgument(String arg);
@Message(value = "Backup delete failed", id = 12041)
IllegalStateException backupDeleteFailed();
@Message(value = "Backup failed", id = 12042)
IllegalStateException backupFailed();
@Message(value = "Invalid request content", id = 12043)
IllegalArgumentException invalidContent();
@Message(value = "Missing at least one argument in '%s'", id = 12044)
IllegalArgumentException missingArguments(String... level);
@Message(value = "Cache '%s' is not indexed", id = 12045)
IllegalArgumentException cacheNotIndexed(String cacheName);
@Message(value = "Cache '%s' does not have statistics enabled", id = 12046)
IllegalArgumentException statisticsNotEnabled(String name);
@Message(value = "Site operation on '%s' failed: '%s'", id = 12047)
IllegalStateException siteOperationFailed(String site, String status);
@Message(value = "No such script '%s'", id = 12048)
NoSuchElementException noSuchScript(String taskName);
}
| 7,974
| 43.553073
| 158
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/logging/RestAccessLoggingHandler.java
|
package org.infinispan.rest.logging;
import java.net.InetSocketAddress;
import java.util.Map;
import org.infinispan.util.logging.LogFactory;
import org.jboss.logging.Logger;
import org.jboss.logging.MDC;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpResponse;
/**
* Logging filter that can be used to output requests in a similar fashion to HTTPD log output
*
* @author wburns
* @since 9.0
*/
public class RestAccessLoggingHandler {
private final static Logger log = LogFactory.getLogger("REST_ACCESS_LOG");
final static String X_REQUEST_TIME = "X-Request-Time";
final static String X_FORWARDED_FOR = "X-Forwarded-For";
final static String X_PRINCIPAL = "X-Principal";
private boolean isEnabled() {
return log.isTraceEnabled();
}
public void preLog(FullHttpRequest request) {
if (isEnabled()) {
// Set the starting time
request.headers().add(X_REQUEST_TIME, Long.toString(System.currentTimeMillis()));
}
}
public void log(ChannelHandlerContext ctx, FullHttpRequest request, HttpResponse response) {
if (isEnabled()) {
// IP
String remoteAddress = request.headers().getAsString(X_FORWARDED_FOR);
if (remoteAddress == null)
remoteAddress = ((InetSocketAddress) ctx.channel().remoteAddress()).getHostString();
// User
String who = request.headers().get(X_PRINCIPAL);
if (who == null)
who = "-";
// Date
long now = System.currentTimeMillis();
String requestTimeString = request.headers().get(X_REQUEST_TIME);
long requestTime = requestTimeString != null ? Long.parseLong(requestTimeString) : now;
// Request method | path | protocol
String requestMethod = request.method().toString();
String uri = request.uri();
// Status code
int status = response.status().code();
// Body request size
int requestSize = request.content().readableBytes();
// Body response Size - usually -1 so we calculate below
String contentLength = response.headers().get(HttpHeaderNames.CONTENT_LENGTH.toString());
int responseSize = contentLength == null ? 0 : Integer.parseInt(contentLength);
// Response time
long duration = now - requestTime;
MDC.clear();
for (Map.Entry<String, String> s : request.headers().entries()) {
MDC.put("h:" + s.getKey(), s.getValue());
}
MDC.put("address", remoteAddress);
MDC.put("user", who);
MDC.put("method", requestMethod);
MDC.put("protocol", request.protocolVersion().text());
MDC.put("status", status);
MDC.put("responseSize", responseSize);
MDC.put("requestSize", requestSize);
MDC.put("duration", duration);
log.tracef("%s", uri);
}
}
}
| 3,026
| 35.914634
| 98
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/authentication/SecurityDomain.java
|
package org.infinispan.rest.authentication;
import javax.security.auth.Subject;
/**
* Pluggable security domain which could be used as a bridge between {@link RestAuthenticator} and
* WildFly Security Realms.
*/
public interface SecurityDomain {
/**
* Returns {@link Subject} based on user/password combination.
*
* @param username User name.
* @param password Password.
* @return Subject if authentication was successful.
* @throws SecurityException Thrown in case of error or authentication failure.
*/
Subject authenticate(String username, String password) throws SecurityException;
}
| 628
| 28.952381
| 98
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/authentication/package-info.java
|
/**
* Authentication API for REST.
*
* @api.public
*/
package org.infinispan.rest.authentication;
| 102
| 13.714286
| 43
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/authentication/RestAuthenticator.java
|
package org.infinispan.rest.authentication;
import java.io.Closeable;
import java.io.IOException;
import java.util.concurrent.CompletionStage;
import org.infinispan.rest.RestServer;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import io.netty.channel.ChannelHandlerContext;
/**
* Authentication mechanism.
*
* @author Sebastian Łaskawiec
*/
public interface RestAuthenticator extends Closeable {
/**
* Challenges specific {@link RestRequest} for authentication.
*
* @param request Request to be challenged.
* @return a {@link RestResponse} wrapped in a {@link CompletionStage}
*/
CompletionStage<RestResponse> challenge(RestRequest request, ChannelHandlerContext ctx);
/**
* Invoked by the {@link RestServer} on startup. Can perform additional configuration
* @param restServer
*/
default void init(RestServer restServer) {}
/**
* Returns whether the realm backing this authenticator is ready to authenticate users
* @return a boolean indicating whether the real is empty (i.e. has no users)
*/
default boolean isReadyForHttpChallenge() {
return true;
}
@Override
default void close() throws IOException {
// No-op
}
}
| 1,273
| 26.106383
| 91
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/authentication/impl/ClientCertAuthenticator.java
|
package org.infinispan.rest.authentication.impl;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import javax.net.ssl.SSLPeerUnverifiedException;
import javax.net.ssl.SSLSession;
import javax.security.auth.Subject;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.authentication.RestAuthenticator;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.ssl.SslHandler;
/**
* Client Certificate authentication mechanism.
*
* @author Tristan Tarrant
* @author Sebastian Łaskawiec
*/
public class ClientCertAuthenticator implements RestAuthenticator {
public ClientCertAuthenticator() {
}
@Override
public CompletionStage<RestResponse> challenge(RestRequest request, ChannelHandlerContext ctx) {
try {
SslHandler sslHandler = ctx.pipeline().get(SslHandler.class);
SSLSession session = sslHandler.engine().getSession();
Subject subject = new Subject();
subject.getPrincipals().add(session.getPeerPrincipal());
request.setSubject(subject);
return CompletableFuture.completedFuture(new NettyRestResponse.Builder().build());
} catch (SSLPeerUnverifiedException e) {
// Ignore any SSLPeerUnverifiedExceptions
}
return CompletableFuture.completedFuture(new NettyRestResponse.Builder().status(HttpResponseStatus.UNAUTHORIZED).build());
}
}
| 1,584
| 34.222222
| 128
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/authentication/impl/BasicAuthenticator.java
|
package org.infinispan.rest.authentication.impl;
import java.util.Base64;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.RestServer;
import org.infinispan.rest.authentication.RestAuthenticator;
import org.infinispan.rest.authentication.SecurityDomain;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.util.concurrent.BlockingManager;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* BASIC authentication mechanism.
*
* @author Tristan Tarrant
* @author Sebastian Łaskawiec
*/
public class BasicAuthenticator implements RestAuthenticator {
private final SecurityDomain domain;
private final String authenticateHeader;
private BlockingManager blockingManager;
public BasicAuthenticator(SecurityDomain domain, String realm) {
this.domain = domain;
this.authenticateHeader = realm != null ? String.format("Basic realm=\"%s\"", realm) : "Basic";
}
@Override
public CompletionStage<RestResponse> challenge(RestRequest request, ChannelHandlerContext ctx) {
String auth = request.getAuthorizationHeader();
if (auth != null && auth.length() > 5) {
String type = auth.substring(0, 5);
if ("basic".equalsIgnoreCase(type)) {
String cookie = auth.substring(6);
cookie = new String(Base64.getDecoder().decode(cookie.getBytes()));
String[] split = cookie.split(":");
return blockingManager.supplyBlocking(() -> {
request.setSubject(domain.authenticate(split[0], split[1]));
return new NettyRestResponse.Builder().build();
}, "auth");
}
}
return CompletableFuture.completedFuture(new NettyRestResponse.Builder().status(HttpResponseStatus.UNAUTHORIZED).authenticate(authenticateHeader).build());
}
@Override
public void init(RestServer restServer) {
blockingManager = restServer.getBlockingManager();
}
}
| 2,144
| 35.982759
| 161
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/tracing/RestTelemetryService.java
|
package org.infinispan.rest.tracing;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.server.core.telemetry.TelemetryService;
import io.opentelemetry.api.trace.Span;
import io.opentelemetry.context.propagation.TextMapGetter;
public class RestTelemetryService {
private static final TextMapGetter<RestRequest> REST_REQUEST_TEXT_MAP_GETTER =
new TextMapGetter<>() {
@Override
public String get(RestRequest carrier, String key) {
return carrier.header(key);
}
@Override
public Iterable<String> keys(RestRequest carrier) {
return carrier.headersKeys();
}
};
private final TelemetryService telemetryService;
public RestTelemetryService(TelemetryService telemetryService) {
this.telemetryService = telemetryService;
}
public Span requestStart(String operationName, RestRequest request) {
return telemetryService.requestStart(operationName, REST_REQUEST_TEXT_MAP_GETTER, request);
}
public void requestEnd(Object span) {
telemetryService.requestEnd(span);
}
public void recordException(Object span, Throwable throwable) {
telemetryService.recordException(span, throwable);
}
}
| 1,277
| 29.428571
| 97
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/package-info.java
|
/**
* REST Server Operations classes.
*
* @api.private
*/
package org.infinispan.rest.operations;
| 102
| 13.714286
| 39
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/CacheOperationsHelper.java
|
package org.infinispan.rest.operations;
import java.util.Arrays;
import java.util.Date;
import java.util.OptionalInt;
import java.util.concurrent.TimeUnit;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.metadata.Metadata;
import org.infinispan.rest.CacheControl;
import org.infinispan.rest.configuration.RestServerConfiguration;
public class CacheOperationsHelper {
private CacheOperationsHelper() {
}
public static Metadata createMetadata(Configuration cfg, Long ttl, Long idleTime) {
EmbeddedMetadata.Builder metadata = new EmbeddedMetadata.Builder();
if (ttl != null) {
if (ttl < 0) {
metadata.lifespan(-1);
} else if (ttl == 0) {
metadata.lifespan(cfg.expiration().lifespan(), TimeUnit.MILLISECONDS);
} else {
metadata.lifespan(ttl, TimeUnit.SECONDS);
}
} else {
metadata.lifespan(cfg.expiration().lifespan(), TimeUnit.MILLISECONDS);
}
if (idleTime != null) {
if (idleTime < 0) {
metadata.maxIdle(-1);
} else if (idleTime == 0) {
metadata.maxIdle(cfg.expiration().maxIdle(), TimeUnit.MILLISECONDS);
} else {
metadata.maxIdle(idleTime, TimeUnit.SECONDS);
}
} else {
metadata.maxIdle(cfg.expiration().maxIdle(), TimeUnit.MILLISECONDS);
}
return metadata.build();
}
public static boolean supportsExtendedHeaders(RestServerConfiguration restServerConfiguration, String extended) {
switch (restServerConfiguration.extendedHeaders()) {
case NEVER:
return false;
case ON_DEMAND:
return extended != null;
default:
return false;
}
}
public static CacheControl calcCacheControl(Date expires) {
if (expires == null) {
return null;
}
int maxAgeSeconds = calcFreshness(expires);
if (maxAgeSeconds > 0)
return CacheControl.maxAge(maxAgeSeconds);
else
return CacheControl.noCache();
}
public static boolean entryFreshEnough(Date entryExpires, OptionalInt minFresh) {
return !minFresh.isPresent() || minFresh.getAsInt() < calcFreshness(entryExpires);
}
public static int calcFreshness(Date expires) {
if (expires == null) {
return Integer.MAX_VALUE;
} else {
return ((int) (expires.getTime() - new Date().getTime()) / 1000);
}
}
public static OptionalInt minFresh(String cacheControl) {
return Arrays.stream(cacheControl.split(","))
.filter(s -> s.contains("min-fresh"))
.map(s -> {
String[] equals = s.split("=");
return OptionalInt.of(Integer.parseInt(equals[equals.length - 1].trim()));
})
.findFirst()
.orElse(OptionalInt.empty());
}
public static <K, V> Long lastModified(InternalCacheEntry<K, V> ice) {
long created = ice.getCreated();
return created == -1 ? null : ice.getCreated();
}
}
| 3,179
| 30.176471
| 116
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/mediatypes/Charset.java
|
package org.infinispan.rest.operations.mediatypes;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.rest.logging.Log;
import org.infinispan.util.logging.LogFactory;
/**
* Represents Charset.
*
* <p>
* Charsets are technically an optional part of a {@link MediaType}.
* </p>
*
* @author Sebastian Łaskawiec
*/
public class Charset {
/**
* Default {@link Charset} - UTF8.
*/
public static final Charset UTF8 = new Charset("UTF-8");
private static final String CHARSET_HEADER = "charset=";
protected final static Log logger = LogFactory.getLog(Charset.class, Log.class);
private final java.nio.charset.Charset javaCharset;
private final String charset;
private Charset(String charset) {
javaCharset = java.nio.charset.Charset.forName(charset);
this.charset = charset;
}
/**
* Creates {@link Charset} based on {@link org.infinispan.commons.dataconversion.MediaType} as string.
*
* @param mediaType {@link org.infinispan.commons.dataconversion.MediaType} value.
* @return Returns {@link Charset} value or <code>null</code> if charset is not supported.
*/
public static Charset fromMediaType(String mediaType) {
if (mediaType == null) return null;
int indexOfCharset = mediaType.indexOf(CHARSET_HEADER);
if (indexOfCharset != -1) {
try {
return new Charset(mediaType.substring(indexOfCharset + CHARSET_HEADER.length()));
} catch (Exception e) {
logger.trace("Unrecognized charset from media type " + mediaType, e);
}
}
return null;
}
/**
* Creates Java {@link java.nio.charset.Charset} from this object.
*
* @return Java {@link java.nio.charset.Charset} from this object.
*/
public java.nio.charset.Charset getJavaCharset() {
return javaCharset;
}
@Override
public String toString() {
return CHARSET_HEADER + charset;
}
}
| 1,966
| 27.926471
| 105
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/WrongDateFormatException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class WrongDateFormatException extends RestResponseException {
public WrongDateFormatException(String description) {
super(HttpResponseStatus.BAD_REQUEST, description);
}
}
| 353
| 24.285714
| 69
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/NoDataFoundException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class NoDataFoundException extends RestResponseException {
public NoDataFoundException() {
super(HttpResponseStatus.BAD_REQUEST, "No data supplied");
}
public NoDataFoundException(String message) {
super(HttpResponseStatus.BAD_REQUEST, message);
}
}
| 442
| 25.058824
| 65
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/UnacceptableDataFormatException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class UnacceptableDataFormatException extends RestResponseException {
public UnacceptableDataFormatException() {
super(HttpResponseStatus.NOT_ACCEPTABLE, "Data format not supported");
}
public UnacceptableDataFormatException(String reason) {
super(HttpResponseStatus.NOT_ACCEPTABLE, reason);
}
}
| 488
| 27.764706
| 76
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/NotAllowedException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* @since 10.0
*/
public class NotAllowedException extends RestResponseException {
public NotAllowedException() {
super(HttpResponseStatus.METHOD_NOT_ALLOWED, "Not allowed");
}
}
| 357
| 20.058824
| 66
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/NoCacheFoundException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class NoCacheFoundException extends RestResponseException {
public NoCacheFoundException(String description) {
super(HttpResponseStatus.NOT_FOUND, description);
}
}
| 345
| 23.714286
| 66
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/ResourceNotFoundException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class ResourceNotFoundException extends RestResponseException {
public ResourceNotFoundException() {
super(HttpResponseStatus.NOT_FOUND, "Resource not found");
}
}
| 344
| 23.642857
| 70
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/ServiceUnavailableException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class ServiceUnavailableException extends RestResponseException {
public ServiceUnavailableException(String text) {
super(HttpResponseStatus.SERVICE_UNAVAILABLE, text);
}
}
| 353
| 24.285714
| 72
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/InvalidFlagException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* @since 10.0
*/
public class InvalidFlagException extends RestResponseException {
public InvalidFlagException(Throwable error) {
super(HttpResponseStatus.BAD_REQUEST, error);
}
}
| 359
| 20.176471
| 65
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/MalformedRequest.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* @since 9.2
*/
public class MalformedRequest extends RestResponseException {
public MalformedRequest(String description) {
super(HttpResponseStatus.BAD_REQUEST, description);
}
}
| 358
| 21.4375
| 61
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/NoKeyException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class NoKeyException extends RestResponseException {
public NoKeyException() {
super(HttpResponseStatus.BAD_REQUEST, "No key specified");
}
public NoKeyException(String paramName) {
super(HttpResponseStatus.BAD_REQUEST, "No key " + paramName + " specified");
}
}
| 456
| 24.388889
| 82
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/operations/exceptions/ServerInternalException.java
|
package org.infinispan.rest.operations.exceptions;
import org.infinispan.rest.RestResponseException;
import io.netty.handler.codec.http.HttpResponseStatus;
public class ServerInternalException extends RestResponseException {
public ServerInternalException(Exception e) {
super(HttpResponseStatus.INTERNAL_SERVER_ERROR, "Internal server error occurred", e);
}
}
| 377
| 28.076923
| 91
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/RegistrationException.java
|
package org.infinispan.rest.framework;
/**
* @since 10.0
*/
public class RegistrationException extends RuntimeException {
public RegistrationException(String message) {
super(message);
}
}
| 206
| 14.923077
| 61
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/ResourceManager.java
|
package org.infinispan.rest.framework;
/**
* Handles registration and lookup of {@link ResourceHandler}.
*
* @since 10.0
*/
public interface ResourceManager {
void registerResource(String context, ResourceHandler handler) throws RegistrationException;
LookupResult lookupResource(Method method, String path, String action);
default LookupResult lookupResource(Method method, String path) {
return lookupResource(method, path, null);
}
}
| 464
| 23.473684
| 95
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/ContentSource.java
|
package org.infinispan.rest.framework;
/**
* @since 10.0
*/
public interface ContentSource {
String asString();
byte[] rawContent();
int size();
}
| 162
| 10.642857
| 38
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/Invocation.java
|
package org.infinispan.rest.framework;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
/**
* Defines an invocation to a REST resource.
*
* @since 10.0
*/
public interface Invocation {
/**
* Returns one or more methods supported.
*/
Set<Method> methods();
/**
* Returns the associated action (request parameter) or null.
*/
String getAction();
/**
* Returns one or more paths associated with the invocation.
* Paths can be constant, e.g. /a/b/c or use variables such as /a/{var1}/{var2}.
*/
Set<String> paths();
/**
* The user friendly name of the invocation
*/
default String getName() {
return toString();
}
/**
* Return the function to execute the invocation.
*/
Function<RestRequest, CompletionStage<RestResponse>> handler();
/**
* @return true whether the invocation can be done anonymously (without auth)
*/
boolean anonymous();
/**
* @return true if the invocation is deprecated
*/
boolean deprecated();
/**
* @return the required permission for this invocation when authorization is enabled
*/
AuthorizationPermission permission();
AuditContext auditContext();
}
| 1,370
| 21.112903
| 87
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/RestRequest.java
|
package org.infinispan.rest.framework;
import java.net.InetSocketAddress;
import java.util.EnumSet;
import java.util.List;
import java.util.Map;
import javax.security.auth.Subject;
import org.infinispan.commons.api.CacheContainerAdmin.AdminFlag;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.context.Flag;
/**
* @since 10.0
*/
public interface RestRequest {
Method method();
String path();
String uri();
ContentSource contents();
Map<String, List<String>> parameters();
String getParameter(String name);
Map<String, String> variables();
String getAction();
MediaType contentType();
MediaType keyContentType();
String getAcceptHeader();
String getAuthorizationHeader();
String getCacheControlHeader();
String getContentTypeHeader();
String getEtagIfMatchHeader();
String getIfModifiedSinceHeader();
String getEtagIfNoneMatchHeader();
String getIfUnmodifiedSinceHeader();
Long getMaxIdleTimeSecondsHeader();
Long getTimeToLiveSecondsHeader();
EnumSet<AdminFlag> getAdminFlags();
Flag[] getFlags();
Long getCreatedHeader();
Long getLastUsedHeader();
Subject getSubject();
void setSubject(Subject subject);
void setVariables(Map<String, String> variables);
void setAction(String action);
String header(String name);
List<String> headers(String name);
Iterable<String> headersKeys();
InetSocketAddress getRemoteAddress();
}
| 1,485
| 16.903614
| 64
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/RestDispatcher.java
|
package org.infinispan.rest.framework;
import java.util.concurrent.CompletionStage;
/**
* Routes a particular {@link RestRequest} to be executed by the correct {link @Invocation}, and produces the {@link RestResponse}.
*
* @since 10.0
*/
public interface RestDispatcher {
LookupResult lookupInvocation(RestRequest restRequest);
CompletionStage<RestResponse> dispatch(RestRequest restRequest);
CompletionStage<RestResponse> dispatch(RestRequest restRequest, LookupResult lookupResult);
}
| 506
| 25.684211
| 131
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/ResourceHandler.java
|
package org.infinispan.rest.framework;
import org.infinispan.rest.framework.impl.Invocations;
/**
* Handles all the logic related to a REST resource.
*
* @since 10.0
*/
public interface ResourceHandler {
/**
* Return the {@link Invocations} handled by this ResourceHandler.
*/
Invocations getInvocations();
}
| 331
| 17.444444
| 69
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/LookupResult.java
|
package org.infinispan.rest.framework;
import java.util.Map;
/**
* @since 10.0
*/
public interface LookupResult {
/**
* Status of the lookup operation.
*/
enum Status {
/**
* A resource was found to handle the request
*/
FOUND,
/**
* A resource was not found
*/
NOT_FOUND,
/**
* A resource was found but the Http Method is not allowed
*/
INVALID_METHOD,
/**
* A resource was found but the action parameter is missing or incorrect
*/
INVALID_ACTION
}
/**
* Returns the invocation to carry out a {@link RestRequest}
*/
Invocation getInvocation();
/**
* In case the invocation contains paths with {@link org.infinispan.rest.framework.impl.VariablePathItem},
* returns the value for each variable or empty otherwise.
*/
Map<String, String> getVariables();
/**
* @return Status of the lookup operation
*/
Status getStatus();
}
| 997
| 19.791667
| 109
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/Method.java
|
package org.infinispan.rest.framework;
/**
* @since 10.0
*/
public enum Method {
GET, PUT, POST, HEAD, DELETE, OPTIONS;
public static boolean contains(String method) {
for (Method m : values()) {
if (m.toString().equals(method)) {
return true;
}
}
return false;
}
}
| 327
| 17.222222
| 50
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/RestResponse.java
|
package org.infinispan.rest.framework;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
/**
* @since 10.0
*/
public interface RestResponse {
int getStatus();
Object getEntity();
default CompletionStage<RestResponse> toFuture() {
return CompletableFuture.completedFuture(this);
}
}
| 349
| 17.421053
| 53
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/LookupResultImpl.java
|
package org.infinispan.rest.framework.impl;
import java.util.Map;
import org.infinispan.rest.framework.Invocation;
import org.infinispan.rest.framework.LookupResult;
/**
* @since 10.0
*/
public class LookupResultImpl implements LookupResult {
private final Invocation invocation;
private final Map<String, String> variables;
private final Status status;
static LookupResult NOT_FOUND = new LookupResultImpl(Status.NOT_FOUND);
static LookupResult INVALID_METHOD = new LookupResultImpl(Status.INVALID_METHOD);
static LookupResult INVALID_ACTION = new LookupResultImpl(Status.INVALID_ACTION);
LookupResultImpl(Invocation invocation, Map<String, String> variables, Status status) {
this.invocation = invocation;
this.variables = variables;
this.status = status;
}
private LookupResultImpl(Status status) {
this.invocation = null;
this.variables = null;
this.status = status;
}
public Invocation getInvocation() {
return invocation;
}
public Map<String, String> getVariables() {
return variables;
}
@Override
public Status getStatus() {
return status;
}
}
| 1,168
| 24.413043
| 90
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/Invocations.java
|
package org.infinispan.rest.framework.impl;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import org.infinispan.rest.framework.Invocation;
/**
* Aggregator for {@link Invocation}.
*
* @since 10.0
*/
public class Invocations implements Iterable<Invocation> {
private final List<Invocation> invocations;
private Invocations(List<Invocation> invocations) {
this.invocations = invocations;
}
@Override
public Iterator<Invocation> iterator() {
return invocations.iterator();
}
public static class Builder {
private InvocationImpl.Builder currentBuilder;
List<Invocation> invocations = new LinkedList<>();
public InvocationImpl.Builder invocation() {
if (currentBuilder != null) {
invocations.add(currentBuilder.build());
}
currentBuilder = new InvocationImpl.Builder(this);
return currentBuilder;
}
public Invocations build(InvocationImpl.Builder lastBuilder) {
invocations.add(lastBuilder.build());
return new Invocations(invocations);
}
public Invocations create() {
if (currentBuilder != null) {
invocations.add(currentBuilder.build());
}
return new Invocations(invocations);
}
}
}
| 1,319
| 23.444444
| 68
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/ResourceNode.java
|
package org.infinispan.rest.framework.impl;
import static org.infinispan.rest.framework.impl.LookupResultImpl.INVALID_ACTION;
import static org.infinispan.rest.framework.impl.LookupResultImpl.INVALID_METHOD;
import static org.infinispan.rest.framework.impl.LookupResultImpl.NOT_FOUND;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import org.infinispan.rest.framework.Invocation;
import org.infinispan.rest.framework.LookupResult;
import org.infinispan.rest.framework.LookupResult.Status;
import org.infinispan.rest.framework.Method;
import org.infinispan.rest.logging.Log;
import org.infinispan.util.logging.LogFactory;
/**
* Tree structure where leaf is associated with one or more {@link Invocation}.
*
* @since 10.0
*/
class ResourceNode {
private final static Log logger = LogFactory.getLog(ResourceNode.class, Log.class);
private final PathItem pathItem;
private final Map<ExtendedMethod, Invocation> invocationTable = new HashMap<>();
private final Map<PathItem, ResourceNode> children = new HashMap<>();
ResourceNode(PathItem pathItem, Invocation invocation) {
this.pathItem = pathItem;
this.updateTable(invocation);
}
private void updateTable(Invocation invocation) {
if (invocation != null) {
String action = invocation.getAction();
if (action == null) {
invocation.methods().forEach(m -> {
String method = m.toString();
Invocation previous = invocationTable.put(new ExtendedMethod(method), invocation);
if (previous != null) {
throw logger.duplicateResourceMethod(invocation.getName(), m, pathItem.toString());
}
});
} else {
invocation.methods().forEach(m -> invocationTable.put(new ExtendedMethod(m.toString(), action), invocation));
}
}
}
private ResourceNode insert(PathItem label, Invocation invocation) {
if (!children.containsKey(label)) {
ResourceNode value = new ResourceNode(label, invocation);
children.put(label, value);
return value;
}
return null;
}
void insertPath(Invocation invocation, List<PathItem> path) {
insertPathInternal(this, invocation, path);
}
public String dumpTree() {
StringBuilder stringBuilder = new StringBuilder();
dumpTree(stringBuilder, this, 0);
return stringBuilder.toString();
}
@Override
public String toString() {
return "ResourceNode{" +
"pathItem=" + pathItem +
", invocationTable=" + invocationTable +
", children=" + children +
'}';
}
private void dumpTree(StringBuilder builder, ResourceNode node, int ident) {
for (int i = 0; i < ident; i++) builder.append(" ");
if (!node.pathItem.getPath().equals("/")) builder.append("/").append(node.pathItem);
else builder.append(node.pathItem);
node.invocationTable.forEach((k, v) -> builder.append(" ").append(k).append(":").append(v));
builder.append("\n");
node.children.forEach((key, value) -> dumpTree(builder, value, ident + 1));
}
private void insertPathInternal(ResourceNode node, Invocation invocation, List<PathItem> path) {
if (path.size() == 1) {
PathItem next = path.iterator().next();
if (next.getPath().equals("/")) {
node.updateTable(invocation);
return;
}
ResourceNode child = node.children.get(next);
ResourceNode conflict = getConflicts(node, next);
if (conflict != null) {
throw logger.duplicateResource(next.toString(), invocation, conflict.toString());
}
if (child == null) {
node.insert(next, invocation);
} else {
child.updateTable(invocation);
}
} else {
PathItem pathItem = path.iterator().next();
if (pathItem.getPath().equals("/")) {
insertPathInternal(node, invocation, path.subList(1, path.size()));
} else {
ResourceNode child = node.children.get(pathItem);
if (child == null) {
ResourceNode inserted = node.insert(pathItem, null);
insertPathInternal(inserted, invocation, path.subList(1, path.size()));
} else {
if (!child.pathItem.getPath().equals(pathItem.getPath())) {
throw logger.duplicateResource(pathItem.toString(), invocation, child.toString());
}
insertPathInternal(child, invocation, path.subList(1, path.size()));
}
}
}
}
private ResourceNode findMatch(String path, Map<String, String> variables) {
for (Map.Entry<PathItem, ResourceNode> e : children.entrySet()) {
if (e.getKey() instanceof VariablePathItem) {
VariablePathItem vpi = (VariablePathItem) e.getKey();
Map<String, String> vars = PathInterpreter.resolveVariables(vpi.getExpression(), path);
if (!vars.isEmpty()) {
variables.putAll(vars);
return e.getValue();
}
}
}
return null;
}
private ResourceNode getConflicts(ResourceNode node, PathItem candidate) {
Map<PathItem, ResourceNode> children = node.children;
for (Map.Entry<PathItem, ResourceNode> entry : children.entrySet()) {
PathItem pathItem = entry.getKey();
ResourceNode resourceNode = entry.getValue();
if (!pathItem.getClass().equals(candidate.getClass())) return resourceNode;
}
return null;
}
LookupResult find(Method method, List<PathItem> path, String action) {
ResourceNode current = this;
Map<String, String> variables = new HashMap<>();
boolean root = true;
for (PathItem pathItem : path) {
if (pathItem.equals(current.pathItem) && root) {
root = false;
continue;
}
ResourceNode resourceNode = current.children.get(pathItem);
ResourceNode matchAll = current.children.get(new StringPathItem("*"));
if (resourceNode != null) {
current = resourceNode;
} else {
if (matchAll != null) {
current = matchAll;
break;
}
ResourceNode variableMatch = current.findMatch(pathItem.getPath(), variables);
if (variableMatch == null) return NOT_FOUND;
current = variableMatch;
}
}
if (current.invocationTable.isEmpty()) return NOT_FOUND;
ExtendedMethod dispatchMethod = new ExtendedMethod(method.toString(), action);
Invocation invocation = current.invocationTable.get(dispatchMethod);
if (invocation != null) return new LookupResultImpl(invocation, variables, Status.FOUND);
if (current.invocationTable.keySet().stream().anyMatch(p -> p.method.equals(method.toString()))) {
return INVALID_ACTION;
}
return INVALID_METHOD;
}
private static class ExtendedMethod {
final String method;
final String action;
ExtendedMethod(String method, String action) {
this.method = method;
this.action = action;
}
ExtendedMethod(String method) {
this.method = method;
this.action = null;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ExtendedMethod that = (ExtendedMethod) o;
return method.equals(that.method) &&
Objects.equals(action, that.action);
}
@Override
public int hashCode() {
return Objects.hash(method, action);
}
}
}
| 7,818
| 34.866972
| 121
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/PathInterpreter.java
|
package org.infinispan.rest.framework.impl;
import static org.infinispan.rest.framework.impl.PathInterpreter.State.END_VAR;
import static org.infinispan.rest.framework.impl.PathInterpreter.State.TEXT;
import static org.infinispan.rest.framework.impl.PathInterpreter.State.VAR;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
/**
* @since 10.0
*/
class PathInterpreter {
enum State {VAR, END_VAR, TEXT}
/**
* Attempts to resolve an expression against a String.
* Example, an expression '{variable}' and a String 'value' yields Map(variable=value)
*
* @return each resolved variable with its value, or empty map if the expression is not compatible with the supplied string.
*/
static Map<String, String> resolveVariables(String expression, String str) {
if (expression == null || str == null) return Collections.emptyMap();
Map<String, String> resolvedVariables = new HashMap<>();
StringBuilder variableBuilder = new StringBuilder();
State state = State.TEXT;
int j = 0;
int expressionLength = expression.length();
for (int i = 0; i < expressionLength; i++) {
char e = expression.charAt(i);
switch (e) {
case '{':
if (state == END_VAR) return Collections.emptyMap();
state = VAR;
break;
case '}':
if (state != VAR) return Collections.emptyMap();
state = END_VAR;
if (i != expressionLength - 1) break;
default:
switch (state) {
case VAR:
variableBuilder.append(e);
break;
case END_VAR:
String replacement;
boolean ec = i == expressionLength - 1;
if (ec) {
replacement = str.substring(j);
} else {
int k = str.indexOf(e, j);
if (k == -1) return Collections.emptyMap();
replacement = str.substring(j, str.indexOf(e, j));
}
resolvedVariables.put(variableBuilder.toString(), replacement);
j += replacement.length();
if (j == str.length() && ec) return resolvedVariables;
variableBuilder.setLength(0);
state = TEXT;
case TEXT:
if (str.charAt(j) != e) return Collections.emptyMap();
j++;
}
}
}
return resolvedVariables;
}
}
| 2,670
| 34.144737
| 127
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/StringPathItem.java
|
package org.infinispan.rest.framework.impl;
/**
* Path item defined by a constant String.
*
* @since 10.0
*/
class StringPathItem extends PathItem {
private final String path;
StringPathItem(String path) {
this.path = path;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
StringPathItem that = (StringPathItem) o;
return path.equals(that.path);
}
@Override
public int hashCode() {
return path.hashCode();
}
@Override
public String toString() {
return path;
}
@Override
public String getPath() {
return path;
}
}
| 703
| 16.170732
| 64
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/VariablePathItem.java
|
package org.infinispan.rest.framework.impl;
/**
* Path item defined by an expression. The expression supports constant chars plus variable names enclosed by
* '{' and '}'.
*
* A path containing {@link VariablePathItem} can match multiple paths at runtime. Examples:
*
* /rest/{variable} can match /rest/a, /rest/b and so on
* /rest/{var1}_{var2} can match /rest/a_b, rest/var1_var2 but not /rest/path.
*
* @since 10.0
*/
class VariablePathItem extends PathItem {
private final String expression;
private final String normalized;
VariablePathItem(String expression) {
this.expression = expression;
this.normalized = normalize(expression);
}
String getExpression() {
return expression;
}
private static String normalize(String expression) {
if (expression == null) return null;
StringBuilder builder = new StringBuilder();
boolean variable = false;
for (char c : expression.toCharArray()) {
if (!variable) builder.append(c);
if (c == '{') variable = true;
if (c == '}' && variable) {
variable = false;
builder.append("}");
}
}
return builder.toString();
}
@Override
public String toString() {
return expression;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
VariablePathItem that = (VariablePathItem) o;
return normalized.equals(that.normalized);
}
@Override
public int hashCode() {
return normalized.hashCode();
}
@Override
public String getPath() {
return expression;
}
}
| 1,696
| 23.955882
| 109
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/InvocationImpl.java
|
package org.infinispan.rest.framework.impl;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import org.infinispan.rest.framework.Invocation;
import org.infinispan.rest.framework.Method;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
/**
* @since 10.0
*/
public class InvocationImpl implements Invocation {
private final Set<Method> methods;
private final Set<String> paths;
private final Function<RestRequest, CompletionStage<RestResponse>> handler;
private final String action;
private final String name;
private final boolean anonymous;
private final boolean deprecated;
private final AuthorizationPermission permission;
private final AuditContext auditContext;
private InvocationImpl(Set<Method> methods, Set<String> paths, Function<RestRequest,
CompletionStage<RestResponse>> handler, String action, String name, boolean anonymous, AuthorizationPermission permission, boolean deprecated, AuditContext auditContext) {
this.methods = methods;
this.paths = paths;
this.handler = handler;
this.action = action;
this.name = name;
this.anonymous = anonymous;
this.permission = permission;
this.deprecated = deprecated;
this.auditContext = auditContext;
}
public String getAction() {
return action;
}
@Override
public Set<Method> methods() {
return methods;
}
@Override
public Set<String> paths() {
return paths;
}
@Override
public String getName() {
return name;
}
@Override
public Function<RestRequest, CompletionStage<RestResponse>> handler() {
return handler;
}
@Override
public boolean anonymous() {
return anonymous;
}
@Override
public AuthorizationPermission permission() {
return permission;
}
@Override
public AuditContext auditContext() {
return auditContext;
}
@Override
public boolean deprecated() {
return deprecated;
}
public static class Builder {
private final Invocations.Builder parent;
private Set<Method> methods = new HashSet<>();
private Set<String> paths = new HashSet<>();
private Function<RestRequest, CompletionStage<RestResponse>> handler;
private String action = null;
private String name = null;
private boolean anonymous;
private boolean deprecated;
private AuthorizationPermission permission;
private AuditContext auditContext;
public Builder method(Method method) {
this.methods.add(method);
return this;
}
public Builder methods(Method... methods) {
Collections.addAll(this.methods, methods);
return this;
}
public Builder path(String path) {
this.paths.add(path);
return this;
}
public Builder name(String name) {
this.name = name;
return this;
}
public Builder handleWith(Function<RestRequest, CompletionStage<RestResponse>> handler) {
this.handler = handler;
return this;
}
public Builder anonymous(boolean anonymous) {
this.anonymous = anonymous;
return this;
}
public Builder anonymous() {
this.anonymous = true;
return this;
}
public Builder permission(AuthorizationPermission permission) {
this.permission = permission;
return this;
}
public Builder auditContext(AuditContext auditContext) {
this.auditContext = auditContext;
return this;
}
public Builder deprecated() {
this.deprecated = true;
return this;
}
public Builder withAction(String action) {
this.action = action;
return this;
}
public Invocations create() {
return parent.build(this);
}
public Builder invocation() {
return parent.invocation();
}
Builder(Invocations.Builder parent) {
this.parent = parent;
}
InvocationImpl build() {
return new InvocationImpl(methods, paths, handler, action, name, anonymous, permission, deprecated, auditContext);
}
}
@Override
public String toString() {
return "InvocationImpl{" +
"methods=" + methods +
", paths=" + paths +
", handler=" + handler +
", action='" + action + '\'' +
", name='" + name + '\'' +
", anonymous=" + anonymous +
", deprecated=" + deprecated +
", permission=" + permission +
", auditContext=" + auditContext +
'}';
}
}
| 4,922
| 25.047619
| 180
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/RestRequestBuilder.java
|
package org.infinispan.rest.framework.impl;
import java.util.Map;
import org.infinispan.rest.framework.ContentSource;
import org.infinispan.rest.framework.Method;
import org.infinispan.rest.framework.RestRequest;
/**
* @since 10.0
*/
public interface RestRequestBuilder<B extends RestRequestBuilder<B>> {
B setMethod(Method method);
B setPath(String path);
B setHeaders(Map<String, String> headers);
B setContents(ContentSource contents);
RestRequest build();
}
| 488
| 18.56
| 70
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/RestResponseBuilder.java
|
package org.infinispan.rest.framework.impl;
import java.util.Date;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.rest.CacheControl;
import org.infinispan.rest.framework.RestResponse;
/**
* @since 10.0
*/
public interface RestResponseBuilder<B extends RestResponseBuilder<B>> {
RestResponse build();
default CompletionStage<RestResponse> buildFuture() {
return CompletableFuture.completedFuture(build());
}
B status(int status);
B entity(Object entity);
B cacheControl(CacheControl cacheControl);
B header(String name, Object value);
B contentType(MediaType type);
B contentType(String type);
B contentLength(long length);
B expires(Date expires);
B lastModified(Long epoch);
B location(String location);
B addProcessedDate(Date d);
B eTag(String tag);
int getStatus();
Object getEntity();
Object getHeader(String header);
}
| 1,031
| 18.471698
| 72
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/PathItem.java
|
package org.infinispan.rest.framework.impl;
/**
* Represents each hop of a path. Example: /rest/a/b is formed by 3 path items: rest, a, b.
*
* @since 10.0
*/
abstract class PathItem {
static PathItem fromString(String path) {
if (isValidExpression(path)) return new VariablePathItem(path);
return new StringPathItem(path);
}
public abstract String getPath();
private static boolean isValidExpression(String path) {
if (path == null) return false;
int i = path.indexOf('{');
int j = path.indexOf('}');
return (i > -1 && j > -1 && j > i + 1);
}
}
| 605
| 23.24
| 91
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/RestDispatcherImpl.java
|
package org.infinispan.rest.framework.impl;
import static org.infinispan.rest.framework.LookupResult.Status.INVALID_ACTION;
import static org.infinispan.rest.framework.LookupResult.Status.INVALID_METHOD;
import static org.infinispan.rest.framework.LookupResult.Status.NOT_FOUND;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.rest.framework.Invocation;
import org.infinispan.rest.framework.LookupResult;
import org.infinispan.rest.framework.ResourceManager;
import org.infinispan.rest.framework.RestDispatcher;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.operations.exceptions.MalformedRequest;
import org.infinispan.rest.operations.exceptions.NotAllowedException;
import org.infinispan.rest.operations.exceptions.ResourceNotFoundException;
import org.infinispan.security.Security;
import org.infinispan.security.impl.Authorizer;
/**
* @since 10.0
*/
public class RestDispatcherImpl implements RestDispatcher {
private static final CompletionStage<RestResponse> NOT_FOUND_RESPONSE =
CompletableFuture.failedFuture(new ResourceNotFoundException());
private static final CompletionStage<RestResponse> NOT_ALLOWED =
CompletableFuture.failedFuture(new NotAllowedException());
private static final CompletionStage<RestResponse> MALFORMED =
CompletableFuture.failedFuture(new MalformedRequest("Invalid 'action' parameter supplied"));
private final ResourceManager manager;
private final Authorizer authorizer;
public RestDispatcherImpl(ResourceManager manager, Authorizer authorizer) {
this.manager = manager;
this.authorizer = authorizer;
}
@Override
public LookupResult lookupInvocation(RestRequest restRequest) {
return manager.lookupResource(restRequest.method(), restRequest.path(), restRequest.getAction());
}
@Override
public CompletionStage<RestResponse> dispatch(RestRequest restRequest) {
return dispatch(restRequest, lookupInvocation(restRequest));
}
@Override
public CompletionStage<RestResponse> dispatch(RestRequest restRequest, LookupResult lookupResult) {
String action = restRequest.getAction();
if (action != null && action.isEmpty()) {
return CompletableFuture.failedFuture(new MalformedRequest("Invalid action"));
}
LookupResult.Status status = lookupResult.getStatus();
if (status.equals(NOT_FOUND)) {
return NOT_FOUND_RESPONSE;
}
if (status.equals(INVALID_METHOD)) {
return NOT_ALLOWED;
}
if (status.equals(INVALID_ACTION)) {
return MALFORMED;
}
restRequest.setVariables(lookupResult.getVariables());
Invocation invocation = lookupResult.getInvocation();
try {
if (invocation.permission() != null) {
authorizer.checkPermission(restRequest.getSubject(), invocation.permission(), invocation.getName(), invocation.auditContext());
}
if (restRequest.getSubject() != null) {
return Security.doAs(restRequest.getSubject(), invocation.handler(), restRequest);
} else {
return invocation.handler().apply(restRequest);
}
} catch (Throwable t) {
return CompletableFuture.failedFuture(t);
}
}
}
| 3,398
| 35.945652
| 142
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/SimpleRestResponse.java
|
package org.infinispan.rest.framework.impl;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.rest.CacheControl;
import org.infinispan.rest.framework.RestResponse;
/**
* @since 10.0
*/
public class SimpleRestResponse implements RestResponse {
private final Builder builder;
private SimpleRestResponse(Builder builder) {
this.builder = builder;
}
@Override
public int getStatus() {
return builder.getStatus();
}
@Override
public Object getEntity() {
return builder.getEntity();
}
public static class Builder implements RestResponseBuilder<Builder> {
private Map<String, Object> headers = new HashMap<>();
private int status;
private Object entity;
@Override
public SimpleRestResponse build() {
return new SimpleRestResponse(this);
}
@Override
public Builder status(int status) {
this.status = status;
return this;
}
@Override
public Builder entity(Object entity) {
this.entity = entity;
return this;
}
@Override
public Builder cacheControl(CacheControl cacheControl) {
return this;
}
@Override
public Builder header(String name, Object value) {
headers.put(name, value);
return this;
}
@Override
public Builder contentType(MediaType type) {
contentType(type.toString());
return this;
}
@Override
public Builder contentType(String type) {
return this;
}
@Override
public Builder contentLength(long length) {
return this;
}
@Override
public Builder expires(Date expires) {
return this;
}
@Override
public Builder lastModified(Long epoch) {
return this;
}
@Override
public Builder addProcessedDate(Date d) {
return this;
}
@Override
public Builder location(String location) {
return this;
}
@Override
public Builder eTag(String tag) {
return this;
}
@Override
public int getStatus() {
return status;
}
@Override
public Object getEntity() {
return entity;
}
@Override
public Object getHeader(String header) {
return headers.get(header);
}
}
}
| 2,501
| 19.341463
| 72
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/framework/impl/ResourceManagerImpl.java
|
package org.infinispan.rest.framework.impl;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.infinispan.rest.framework.LookupResult;
import org.infinispan.rest.framework.Method;
import org.infinispan.rest.framework.RegistrationException;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.ResourceManager;
import org.infinispan.rest.logging.Log;
import org.infinispan.util.logging.LogFactory;
import io.netty.handler.codec.http.QueryStringDecoder;
/**
* @since 10.0
*/
public class ResourceManagerImpl implements ResourceManager {
private final static Log logger = LogFactory.getLog(ResourceManagerImpl.class, Log.class);
private final ResourceNode resourceTree;
public ResourceManagerImpl() {
this.resourceTree = new ResourceNode(new StringPathItem("/"), null);
}
@Override
public void registerResource(String context, ResourceHandler handler) throws RegistrationException {
handler.getInvocations().forEach(invocation -> {
Set<String> paths = invocation.paths();
paths.forEach(path -> {
validate(path);
List<PathItem> p = Arrays.stream(path.split("/")).filter(s -> !s.isEmpty()).map(PathItem::fromString).collect(Collectors.toList());
List<PathItem> pathWithCtx = new ArrayList<>();
pathWithCtx.add(new StringPathItem(context));
pathWithCtx.addAll(p);
resourceTree.insertPath(invocation, pathWithCtx);
});
});
}
private void validate(String path) {
if (path.contains("*") && !path.endsWith("*")) {
throw logger.invalidPath(path);
}
}
@Override
public LookupResult lookupResource(Method method, String path, String action) {
List<PathItem> pathItems = Arrays.stream(path.replaceAll("//+", "/").split("/"))
.map(s -> s.isEmpty() ? "/" : s).map(QueryStringDecoder::decodeComponent).map(StringPathItem::new).collect(Collectors.toList());
return resourceTree.find(method, pathItems, action);
}
}
| 2,140
| 34.098361
| 143
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/RedirectResource.java
|
package org.infinispan.rest.resources;
import static org.infinispan.rest.framework.Method.GET;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* REST resource to serve redirects
*
* @since 10.1
*/
public class RedirectResource implements ResourceHandler {
private final String path;
private final String redirectPath;
private final boolean anonymous;
private final InvocationHelper invocationHelper;
public RedirectResource(InvocationHelper invocationHelper, String path, String redirectPath, boolean anonymous) {
this.invocationHelper = invocationHelper;
this.path = path;
this.redirectPath = redirectPath;
this.anonymous = anonymous;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(GET).path(path).anonymous(anonymous).handleWith(this::redirect)
.create();
}
private CompletionStage<RestResponse> redirect(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.status(HttpResponseStatus.TEMPORARY_REDIRECT).header("Location", redirectPath);
return CompletableFuture.completedFuture(responseBuilder.build());
}
}
| 1,660
| 32.897959
| 116
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/ProtobufResource.java
|
package org.infinispan.rest.resources;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.framework.Method.PUT;
import static org.infinispan.rest.resources.ResourceUtil.addEntityAsJson;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponse;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.Comparator;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.query.remote.ProtobufMetadataManager;
import org.infinispan.query.remote.client.ProtobufMetadataManagerConstants;
import org.infinispan.query.remote.impl.ProtobufMetadataManagerImpl;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.cachemanager.RestCacheManager;
import org.infinispan.rest.framework.ContentSource;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.operations.exceptions.NoDataFoundException;
import org.infinispan.rest.operations.exceptions.NoKeyException;
import org.infinispan.rest.tracing.RestTelemetryService;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.rxjava3.core.Flowable;
/**
* Protobuf schema manipulation Resource
*
* @author Katia Aresti
* @since 11
*/
public class ProtobufResource extends BaseCacheResource implements ResourceHandler {
public ProtobufResource(InvocationHelper invocationHelper, RestTelemetryService telemetryService) {
super(invocationHelper, telemetryService);
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
// Key related operations
.invocation().methods(GET).path("/v2/schemas").handleWith(this::getSchemasNames)
.invocation().methods(GET).path("/v2/schemas").withAction("types").handleWith(this::getTypes)
.invocation().methods(POST).path("/v2/schemas/{schemaName}")
.permission(AuthorizationPermission.CREATE).auditContext(AuditContext.SERVER).name("SCHEMA CREATE")
.handleWith(r -> createOrReplace(r, true))
.invocation().methods(PUT).path("/v2/schemas/{schemaName}")
.permission(AuthorizationPermission.CREATE).auditContext(AuditContext.SERVER).name("SCHEMA CREATE")
.handleWith(r -> createOrReplace(r, false))
.invocation().methods(GET).path("/v2/schemas/{schemaName}").handleWith(this::getSchema)
.invocation().method(DELETE).path("/v2/schemas/{schemaName}")
.permission(AuthorizationPermission.CREATE).auditContext(AuditContext.SERVER).name("SCHEMA DELETE")
.handleWith(this::deleteSchema)
.create();
}
private CompletionStage<RestResponse> getSchemasNames(RestRequest request) {
AdvancedCache<Object, Object> cache = invocationHelper.getRestCacheManager()
.getCache(ProtobufMetadataManager.PROTOBUF_METADATA_CACHE_NAME, request);
boolean pretty = isPretty(request);
return CompletableFuture.supplyAsync(() ->
Flowable.fromIterable(cache.keySet())
.filter(key -> !((String) key).endsWith(ProtobufMetadataManager.ERRORS_KEY_SUFFIX))
.map(key -> {
String error = (String) cache
.get(key + ProtobufMetadataManagerConstants.ERRORS_KEY_SUFFIX);
ProtoSchema protoSchema = new ProtoSchema();
protoSchema.name = (String) key;
if (error != null) {
protoSchema.error = createErrorContent(protoSchema.name, error);
}
return protoSchema;
})
.sorted(Comparator.comparing(s -> s.name))
.collect(Collectors.toList())
.map(protoSchemas -> asJsonResponse(invocationHelper.newResponse(request), Json.make(protoSchemas), pretty))
.toCompletionStage()
, invocationHelper.getExecutor())
.thenCompose(Function.identity());
}
private CompletionStage<RestResponse> createOrReplace(RestRequest request, boolean create) {
String schemaName = checkMandatorySchemaName(request);
ContentSource contents = request.contents();
if (contents == null || contents.size() == 0) throw new NoDataFoundException("Schema data not sent in the request");
AdvancedCache<Object, Object> cache = invocationHelper.getRestCacheManager()
.getCache(ProtobufMetadataManager.PROTOBUF_METADATA_CACHE_NAME, request);
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
CompletableFuture<Object> putSchema;
if (create) {
putSchema = cache.putIfAbsentAsync(schemaName, contents.asString()).thenApply(result -> {
if (result == null) {
builder.status(HttpResponseStatus.CREATED);
} else {
builder.status(HttpResponseStatus.CONFLICT);
}
return result;
});
} else {
putSchema = cache.putAsync(schemaName, contents.asString()).thenApply(result -> builder.status(HttpResponseStatus.OK));
}
return putSchema.thenCompose(r -> {
if (isOkOrCreated(builder)) {
return cache.getAsync(schemaName + ProtobufMetadataManagerConstants.ERRORS_KEY_SUFFIX);
} else {
return CompletableFutures.completedNull();
}
}).thenApply(validationError -> {
if (isOkOrCreated(builder)) {
ProtoSchema protoSchema = new ProtoSchema();
protoSchema.name = schemaName;
if (validationError != null) {
protoSchema.error = createErrorContent(schemaName, (String) validationError);
}
addEntityAsJson(protoSchema, builder);
}
return builder.build();
});
}
private boolean isOkOrCreated(NettyRestResponse.Builder builder) {
return builder.getHttpStatus() == HttpResponseStatus.CREATED || builder.getHttpStatus() == HttpResponseStatus.OK;
}
private CompletionStage<RestResponse> getSchema(RestRequest request) {
String schemaName = checkMandatorySchemaName(request);
AdvancedCache<Object, Object> cache = invocationHelper.getRestCacheManager()
.getCache(ProtobufMetadataManager.PROTOBUF_METADATA_CACHE_NAME, request);
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
return restCacheManager.getPrivilegedInternalEntry(cache, schemaName, true).thenApply(entry -> {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
if (entry == null) {
responseBuilder.status(HttpResponseStatus.NOT_FOUND);
} else {
responseBuilder.status(HttpResponseStatus.OK);
responseBuilder.contentType(MediaType.TEXT_PLAIN);
responseBuilder.entity(entry.getValue());
}
return responseBuilder.build();
});
}
private CompletionStage<RestResponse> getTypes(RestRequest request) {
ProtobufMetadataManagerImpl protobufMetadataManager = (ProtobufMetadataManagerImpl) invocationHelper.protobufMetadataManager();
Set<String> knownTypes = protobufMetadataManager.getKnownTypes();
Json protobufTypes = Json.array();
for (String type: knownTypes) {
protobufTypes.add(type);
}
return asJsonResponseFuture(invocationHelper.newResponse(request), protobufTypes, isPretty(request));
}
private CompletionStage<RestResponse> deleteSchema(RestRequest request) {
String schemaName = checkMandatorySchemaName(request);
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
AdvancedCache<Object, Object> protobufCache = restCacheManager.getCache(ProtobufMetadataManager.PROTOBUF_METADATA_CACHE_NAME, request);
return restCacheManager.getPrivilegedInternalEntry(protobufCache, schemaName, true).thenCompose(entry -> {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.status(HttpResponseStatus.NOT_FOUND);
if (entry instanceof InternalCacheEntry) {
responseBuilder.status(HttpResponseStatus.NO_CONTENT);
return restCacheManager.remove(ProtobufMetadataManager.PROTOBUF_METADATA_CACHE_NAME, schemaName,
MediaType.MATCH_ALL, request)
.thenApply(v -> responseBuilder.build());
}
return CompletableFuture.completedFuture(responseBuilder.build());
});
}
private ValidationError createErrorContent(String schemaName, String cause) {
String message = "Schema " + schemaName + " has errors";
ValidationError validationError = new ValidationError();
validationError.message = message;
validationError.cause = cause;
return validationError;
}
private String checkMandatorySchemaName(RestRequest request) {
String schemaName = request.variables().get("schemaName");
if (schemaName == null)
throw new NoKeyException("schemaName");
return schemaName.endsWith(ProtobufMetadataManager.PROTO_KEY_SUFFIX) ? schemaName : schemaName + ProtobufMetadataManager.PROTO_KEY_SUFFIX;
}
static class ValidationError implements JsonSerialization {
public String message;
public String cause;
@Override
public Json toJson() {
return Json.object().set("message", message).set("cause", cause);
}
}
static class ProtoSchema implements JsonSerialization {
public String name;
public ValidationError error;
@Override
public Json toJson() {
return Json.object("name", name).set("error", error == null ? null : error.toJson());
}
}
}
| 10,919
| 45.271186
| 144
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/JsonErrorResponseEntity.java
|
package org.infinispan.rest.resources;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.commons.dataconversion.internal.Json;
class JsonErrorResponseEntity implements JsonSerialization {
private final String message;
private final String cause;
public JsonErrorResponseEntity(String message, String cause) {
this.message = message;
this.cause = cause;
}
@Override
public Json toJson() {
return Json.object("error").set("message", message).set("cause", cause);
}
}
| 555
| 24.272727
| 78
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/ContainerResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Collections.emptyMap;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_XML;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_YAML;
import static org.infinispan.commons.dataconversion.MediaType.TEXT_EVENT_STREAM;
import static org.infinispan.commons.dataconversion.MediaType.TEXT_PLAIN;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.HEAD;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.resources.MediaTypeUtils.negotiateMediaType;
import static org.infinispan.rest.resources.ResourceUtil.addEntityAsJson;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.io.ByteArrayOutputStream;
import java.io.StringWriter;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.stream.Collectors;
import org.infinispan.Cache;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.commons.io.StringBuilderWriter;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.concurrent.CompletableFutures;
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.factories.GlobalComponentRegistry;
import org.infinispan.health.CacheHealth;
import org.infinispan.health.ClusterHealth;
import org.infinispan.health.Health;
import org.infinispan.health.HealthStatus;
import org.infinispan.lifecycle.ComponentStatus;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachemanagerlistener.annotation.ConfigurationChanged;
import org.infinispan.notifications.cachemanagerlistener.event.ConfigurationChangedEvent;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.rest.EventStream;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.ServerSentEvent;
import org.infinispan.rest.cachemanager.RestCacheManager;
import org.infinispan.rest.framework.ContentSource;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.BackupManager;
import org.infinispan.server.core.ServerStateManager;
import org.infinispan.topology.LocalTopologyManager;
import org.infinispan.util.logging.annotation.impl.Logged;
import org.infinispan.util.logging.events.EventLog;
import org.infinispan.util.logging.events.EventLogCategory;
import org.infinispan.util.logging.events.EventLogSerializer;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.reactivex.rxjava3.core.Flowable;
/**
* REST resource to manage the cache container.
*
* @since 10.0
*/
public class ContainerResource implements ResourceHandler {
private final InvocationHelper invocationHelper;
private final InternalCacheRegistry internalCacheRegistry;
private final ParserRegistry parserRegistry = new ParserRegistry();
private final String cacheManagerName;
private final RestCacheManager<Object> restCacheManager;
private final ServerStateManager serverStateManager;
public ContainerResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
this.restCacheManager = invocationHelper.getRestCacheManager();
GlobalConfiguration globalConfiguration = SecurityActions.getCacheManagerConfiguration(cacheManager);
this.cacheManagerName = globalConfiguration.cacheManagerName();
GlobalComponentRegistry globalComponentRegistry = SecurityActions.getGlobalComponentRegistry(cacheManager);
this.internalCacheRegistry = globalComponentRegistry.getComponent(InternalCacheRegistry.class);
this.serverStateManager = globalComponentRegistry.getComponent(ServerStateManager.class);
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
// Health
.invocation().methods(GET, HEAD).path("/v2/cache-managers/{name}/health").handleWith(this::getHealth)
.invocation().methods(GET, HEAD).anonymous(true).path("/v2/cache-managers/{name}/health/status").handleWith(this::getHealthStatus)
// Config
.invocation().methods(GET).path("/v2/cache-managers/{name}/cache-configs").handleWith(this::getAllCachesConfiguration)
.invocation().methods(GET).path("/v2/cache-managers/{name}/cache-configs/templates").handleWith(this::getAllCachesConfigurationTemplates)
.invocation().methods(POST).path("/v2/cache-managers/{name}/config").withAction("toJSON").handleWith(this::convertToJson)
// Cache Manager config
.invocation().methods(GET).path("/v2/cache-managers/{name}/config").handleWith(this::getConfig)
// Shutdown the container content
.invocation().methods(POST).path("/v2/container").withAction("shutdown").name("SHUTDOWN CONTAINER")
.auditContext(AuditContext.CACHEMANAGER).handleWith(this::shutdown)
// Container configuration listener
.invocation().methods(GET).path("/v2/container/config").withAction("listen")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::listenConfig)
// Container lifecycle listener
.invocation().method(GET).path("/v2/container").withAction("listen")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::listenLifecycle)
// Cache Manager info
.invocation().methods(GET).path("/v2/cache-managers/{name}").handleWith(this::getInfo)
// Enable Rebalance
.invocation().methods(POST).path("/v2/cache-managers/{name}").withAction("enable-rebalancing")
.permission(AuthorizationPermission.ADMIN).name("ENABLE REBALANCE GLOBAL").auditContext(AuditContext.CACHEMANAGER)
.handleWith(r -> setRebalancing(true, r))
// Disable Rebalance
.invocation().methods(POST).path("/v2/cache-managers/{name}").withAction("disable-rebalancing")
.permission(AuthorizationPermission.ADMIN).name("DISABLE REBALANCE GLOBAL").auditContext(AuditContext.CACHEMANAGER)
.handleWith(r -> setRebalancing(false, r))
// Stats
.invocation().methods(GET).path("/v2/cache-managers/{name}/stats").handleWith(this::getStats)
.invocation().methods(POST).path("/v2/cache-managers/{name}/stats").withAction("reset").permission(AuthorizationPermission.ADMIN).handleWith(this::resetStats)
// Caches
.invocation().methods(GET).path("/v2/cache-managers/{name}/caches").handleWith(this::getCaches)
// BackupManager
.invocation().methods(GET).path("/v2/cache-managers/{name}/backups").handleWith(this::getAllBackupNames)
.invocation().methods(DELETE, GET, HEAD, POST).path("/v2/cache-managers/{name}/backups/{backupName}")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).name("BACKUP")
.handleWith(this::backup)
.invocation().methods(GET).path("/v2/cache-managers/{name}/restores")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).name("BACKUP")
.handleWith(this::getAllRestoreNames)
.invocation().methods(DELETE, HEAD, POST).path("/v2/cache-managers/{name}/restores/{restoreName}")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).name("BACKUP")
.handleWith(this::restore)
.create();
}
private CompletionStage<RestResponse> getInfo(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
Json cacheManagerInfo = cacheManager.getCacheManagerInfo().toJson();
return asJsonResponseFuture(invocationHelper.newResponse(request), cacheManagerInfo, isPretty(request));
}
private CompletionStage<RestResponse> setRebalancing(boolean enable, RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND)
return completedFuture(responseBuilder.build());
return CompletableFuture.supplyAsync(()-> {
try {
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
SecurityActions.getGlobalComponentRegistry(cacheManager).getLocalTopologyManager().setRebalancingEnabled(enable);
responseBuilder.status(NO_CONTENT);
} catch (Exception e) {
throw Util.unchecked(e);
}
return responseBuilder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getConfig(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
EmbeddedCacheManager embeddedCacheManager = invocationHelper.getRestCacheManager().getInstance().withSubject(request.getSubject());
GlobalConfiguration globalConfiguration = SecurityActions.getCacheManagerConfiguration(embeddedCacheManager);
MediaType format = MediaTypeUtils.negotiateMediaType(request, APPLICATION_JSON, APPLICATION_XML);
try {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try (ConfigurationWriter writer = ConfigurationWriter.to(baos).withType(format).prettyPrint(isPretty(request)).build()) {
parserRegistry.serialize(writer, globalConfiguration, emptyMap());
}
responseBuilder.contentType(format);
responseBuilder.entity(baos.toByteArray());
} catch (Exception e) {
throw Util.unchecked(e);
}
return completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> getStats(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
return CompletableFuture.supplyAsync(() -> Security.doAs(request.getSubject(), cacheManager::getStats).toJson(), invocationHelper.getExecutor())
.thenCompose(json -> asJsonResponseFuture(invocationHelper.newResponse(request), json, isPretty(request)));
}
private CompletionStage<RestResponse> resetStats(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
return CompletableFuture.supplyAsync(() -> {
Security.doAs(request.getSubject(), () -> cacheManager.getStats().reset());
return invocationHelper.newResponse(request, NO_CONTENT);
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getHealth(RestRequest request) {
return getHealth(request, false);
}
private CompletionStage<RestResponse> getHealthStatus(RestRequest request) {
return getHealth(request, true);
}
private CompletionStage<RestResponse> getHealth(RestRequest request, boolean anon) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
// If /v2/containers?action=shutdown has been executed, we must still return OK so that the k8s probes don't fail
// before the StatefulSet has been scaled down
boolean isStopping = anon && invocationHelper.getServer().getStatus().isStopping();
if (request.method() == HEAD || isStopping)
return completedFuture(invocationHelper.newResponse(request).status(OK).build());
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
Health health = cacheManager.withSubject(request.getSubject()).getHealth();
HealthInfo healthInfo = new HealthInfo(health.getClusterHealth(), health.getCacheHealth());
if (anon) {
responseBuilder
.contentType(TEXT_PLAIN)
.entity(Security.doAs(request.getSubject(), () -> healthInfo.clusterHealth.getHealthStatus().toString()))
.status(OK);
} else {
addEntityAsJson(healthInfo.toJson(), responseBuilder, isPretty(request));
}
return completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> getCaches(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
EmbeddedCacheManager subjectCacheManager = cacheManager.withSubject(request.getSubject());
// Remove internal caches
Set<String> cacheNames = new HashSet<>(subjectCacheManager.getAccessibleCacheNames());
cacheNames.removeAll(internalCacheRegistry.getInternalCacheNames());
Set<String> ignoredCaches = serverStateManager.getIgnoredCaches();
List<CacheHealth> cachesHealth = SecurityActions.getHealth(subjectCacheManager).getCacheHealth(cacheNames);
LocalTopologyManager localTopologyManager = null;
Boolean clusterRebalancingEnabled = null;
try {
localTopologyManager = SecurityActions.getGlobalComponentRegistry(cacheManager).getLocalTopologyManager();
if (localTopologyManager != null) {
clusterRebalancingEnabled = localTopologyManager.isRebalancingEnabled();
}
} catch (Exception e) {
// Unable to get the component. Just ignore.
}
// We rely on the fact that getCacheNames doesn't block for embedded - remote it does unfortunately
LocalTopologyManager finalLocalTopologyManager = localTopologyManager;
Boolean finalClusterRebalancingEnabled = clusterRebalancingEnabled;
boolean pretty = isPretty(request);
return Flowable.fromIterable(cachesHealth)
.map(chHealth -> getCacheInfo(request, cacheManager, subjectCacheManager, ignoredCaches,
finalLocalTopologyManager, finalClusterRebalancingEnabled, chHealth))
.sorted(Comparator.comparing(c -> c.name))
.collect(Collectors.toList()).map(cacheInfos -> (RestResponse) addEntityAsJson(Json.make(cacheInfos), responseBuilder, pretty).build())
.toCompletionStage();
}
private CacheInfo getCacheInfo(RestRequest request, EmbeddedCacheManager cacheManager,
EmbeddedCacheManager subjectCacheManager, Set<String> ignoredCaches,
LocalTopologyManager finalLocalTopologyManager,
Boolean finalClusterRebalancingEnabled, CacheHealth chHealth) {
CacheInfo cacheInfo = new CacheInfo();
String cacheName = chHealth.getCacheName();
cacheInfo.name = cacheName;
HealthStatus cacheHealth = chHealth.getStatus();
cacheInfo.health = cacheHealth;
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(subjectCacheManager, cacheName);
cacheInfo.type = cacheConfiguration.clustering().cacheMode().toCacheType();
boolean isPersistent = false;
if (chHealth.getStatus() != HealthStatus.FAILED) {
PersistenceManager pm = SecurityActions.getPersistenceManager(cacheManager, cacheName);
isPersistent = pm.isEnabled();
}
cacheInfo.simpleCache = cacheConfiguration.simpleCache();
cacheInfo.transactional = cacheConfiguration.transaction().transactionMode().isTransactional();
cacheInfo.persistent = isPersistent;
cacheInfo.persistent = cacheConfiguration.persistence().usingStores();
cacheInfo.bounded = cacheConfiguration.memory().whenFull().isEnabled();
cacheInfo.secured = cacheConfiguration.security().authorization().enabled();
cacheInfo.indexed = cacheConfiguration.indexing().enabled();
cacheInfo.hasRemoteBackup = cacheConfiguration.sites().hasBackups();
// If the cache is ignored, status is IGNORED
if (ignoredCaches.contains(cacheName)) {
cacheInfo.status = "IGNORED";
} else {
switch (cacheHealth) {
case FAILED:
cacheInfo.status = ComponentStatus.FAILED.toString();
break;
case INITIALIZING:
cacheInfo.status = ComponentStatus.INITIALIZING.toString();
break;
default:
Cache<?, ?> cache = restCacheManager.getCache(cacheName, request);
cacheInfo.status = cache.getStatus().toString();
break;
}
}
// if any of those are null, don't keep trying to retrieve the rebalancing status
if (finalLocalTopologyManager != null && finalClusterRebalancingEnabled != null) {
Boolean perCacheRebalancing = null;
if (finalClusterRebalancingEnabled) {
// if the global rebalancing is enabled, retrieve each cache status
try {
perCacheRebalancing = finalLocalTopologyManager.isCacheRebalancingEnabled(cacheName);
} catch (Exception ex) {
// There was an error retrieving this value. Just ignore
}
} else {
// set all to false. global disabled rebalancing disables all caches rebalancing
perCacheRebalancing = Boolean.FALSE;
}
cacheInfo.rebalancing_enabled = perCacheRebalancing;
}
return cacheInfo;
}
private CompletionStage<RestResponse> getAllCachesConfiguration(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
boolean pretty = isPretty(request);
EmbeddedCacheManager subjectCacheManager = invocationHelper.getRestCacheManager().getInstance().withSubject(request.getSubject());
Set<String> cacheConfigurationNames = subjectCacheManager.getCacheConfigurationNames();
List<NamedCacheConfiguration> configurations = cacheConfigurationNames.stream()
.filter(n -> !internalCacheRegistry.isInternalCache(n))
.distinct()
.map(n -> getNamedCacheConfiguration(subjectCacheManager, n, pretty))
.sorted(Comparator.comparing(c -> c.name))
.collect(Collectors.toList());
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(configurations), pretty);
}
private CompletionStage<RestResponse> getAllCachesConfigurationTemplates(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
boolean pretty = isPretty(request);
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
EmbeddedCacheManager subjectCacheManager = cacheManager.withSubject(request.getSubject());
Set<String> cacheConfigurationNames = subjectCacheManager.getCacheConfigurationNames();
List<NamedCacheConfiguration> configurations = cacheConfigurationNames.stream()
.filter(n -> !internalCacheRegistry.isInternalCache(n))
.filter(n -> SecurityActions.getCacheConfiguration(subjectCacheManager, n).isTemplate())
.distinct()
.map(n -> {
return getNamedCacheConfiguration(subjectCacheManager, n, pretty);
})
.sorted(Comparator.comparing(c -> c.name))
.collect(Collectors.toList());
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(configurations), pretty);
}
private NamedCacheConfiguration getNamedCacheConfiguration(EmbeddedCacheManager subjectCacheManager, String n, boolean pretty) {
Configuration config = SecurityActions.getCacheConfiguration(subjectCacheManager, n);
StringBuilderWriter sw = new StringBuilderWriter();
try (ConfigurationWriter w = ConfigurationWriter.to(sw).withType(APPLICATION_JSON).prettyPrint(pretty).build()) {
invocationHelper.getParserRegistry().serialize(w, n, config);
}
return new NamedCacheConfiguration(n, sw.toString());
}
private CompletionStage<RestResponse> getAllBackupNames(RestRequest request) {
BackupManager backupManager = invocationHelper.getServer().getBackupManager();
Set<String> names = backupManager.getBackupNames();
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(names), isPretty(request));
}
private CompletionStage<RestResponse> backup(RestRequest request) {
BackupManager backupManager = invocationHelper.getServer().getBackupManager();
return BackupManagerResource.handleBackupRequest(invocationHelper, request, backupManager, (name, workingDir, json) -> {
BackupManager.Resources resources = BackupManagerResource.getResources(json);
Map<String, BackupManager.Resources> backupParams = Collections.singletonMap(cacheManagerName, resources);
backupManager.create(name, workingDir, backupParams);
});
}
private CompletionStage<RestResponse> getAllRestoreNames(RestRequest request) {
BackupManager backupManager = invocationHelper.getServer().getBackupManager();
Set<String> names = backupManager.getRestoreNames();
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(names), isPretty(request));
}
private CompletionStage<RestResponse> restore(RestRequest request) {
BackupManager backupManager = invocationHelper.getServer().getBackupManager();
return BackupManagerResource.handleRestoreRequest(invocationHelper, request, backupManager, (name, path, json) -> {
BackupManager.Resources resources = BackupManagerResource.getResources(json);
Map<String, BackupManager.Resources> restoreParams = Collections.singletonMap(cacheManagerName, resources);
return backupManager.restore(name, path, restoreParams);
});
}
private CompletionStage<RestResponse> convertToJson(RestRequest request) {
NettyRestResponse.Builder responseBuilder = checkCacheManager(request);
if (responseBuilder.getHttpStatus() == NOT_FOUND) return completedFuture(responseBuilder.build());
ContentSource contents = request.contents();
ConfigurationBuilderHolder builderHolder = parserRegistry.parse(new String(contents.rawContent(), UTF_8));
Map.Entry<String, ConfigurationBuilder> entry = builderHolder.getNamedConfigurationBuilders().entrySet().iterator().next();
StringBuilderWriter sw = new StringBuilderWriter();
try (ConfigurationWriter w = ConfigurationWriter.to(sw).withType(APPLICATION_JSON).prettyPrint(isPretty(request)).build()) {
invocationHelper.getParserRegistry().serialize(w, entry.getKey(), entry.getValue().build());
}
responseBuilder.contentType(APPLICATION_JSON).entity(sw.toString());
return completedFuture(responseBuilder.build());
}
private NettyRestResponse.Builder checkCacheManager(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String name = request.variables().get("name");
if (!name.equals(cacheManagerName)) {
responseBuilder.status(HttpResponseStatus.NOT_FOUND);
}
return responseBuilder;
}
static class HealthInfo implements JsonSerialization {
private final ClusterHealth clusterHealth;
private final List<CacheHealth> cacheHealth;
HealthInfo(ClusterHealth clusterHealth, List<CacheHealth> cacheHealth) {
this.clusterHealth = clusterHealth;
this.cacheHealth = cacheHealth;
}
@Override
public Json toJson() {
return Json.object()
.set("cluster_health", clusterHealth.toJson())
.set("cache_health", Json.make(cacheHealth));
}
}
static class NamedCacheConfiguration implements JsonSerialization {
String name;
String configuration;
NamedCacheConfiguration(String name, String configuration) {
this.name = name;
this.configuration = configuration;
}
@Override
public Json toJson() {
return Json.object()
.set("name", name)
.set("configuration", Json.factory().raw(configuration));
}
}
static class CacheInfo implements JsonSerialization {
public String status;
public String name;
public String type;
public boolean simpleCache;
public boolean transactional;
public boolean persistent;
public boolean bounded;
public boolean indexed;
public boolean secured;
public boolean hasRemoteBackup;
public HealthStatus health;
public Boolean rebalancing_enabled;
@Override
public Json toJson() {
Json payload = Json.object()
.set("status", status)
.set("name", name)
.set("type", type)
.set("simple_cache", simpleCache)
.set("transactional", transactional)
.set("persistent", persistent)
.set("bounded", bounded)
.set("secured", secured)
.set("indexed", indexed)
.set("has_remote_backup", hasRemoteBackup)
.set("health", health);
if (rebalancing_enabled != null) {
payload.set("rebalancing_enabled", rebalancing_enabled);
}
return payload;
}
}
private CompletionStage<RestResponse> shutdown(RestRequest request) {
return CompletableFuture.supplyAsync(() -> {
Security.doAs(request.getSubject(), invocationHelper.getServer()::containerStop);
return invocationHelper.newResponse(request).status(NO_CONTENT).build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> listenConfig(RestRequest request) {
return streamConfigurationAndEvents(request, false);
}
private CompletionStage<RestResponse> listenLifecycle(RestRequest request) {
return streamConfigurationAndEvents(request, true);
}
private CompletionStage<RestResponse> streamConfigurationAndEvents(RestRequest request, boolean includeLifecycle) {
MediaType mediaType = negotiateMediaType(request, APPLICATION_YAML, APPLICATION_JSON, APPLICATION_XML);
boolean includeCurrentState = Boolean.parseBoolean(request.getParameter("includeCurrentState"));
boolean pretty = isPretty(request);
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
ConfigurationListener listener = new ConfigurationListener(cacheManager, mediaType, includeCurrentState, pretty);
responseBuilder.contentType(TEXT_EVENT_STREAM).entity(listener.getEventStream());
CompletionStage<?> cs = SecurityActions.addListenerAsync(cacheManager, listener);
if (includeLifecycle) {
cs = cs.thenCompose(ignore -> SecurityActions.addLoggerListenerAsync(cacheManager, listener));
}
return cs.thenApply(v -> responseBuilder.build());
}
private String serializeConfig(Configuration cacheConfiguration, String name, MediaType mediaType, boolean pretty) {
StringWriter sw = new StringWriter();
try (ConfigurationWriter writer = ConfigurationWriter.to(sw).withType(mediaType).prettyPrint(pretty).build()) {
parserRegistry.serialize(writer, null, Collections.singletonMap(name, cacheConfiguration));
}
return sw.toString();
}
private String serializeEvent(EventLog event, MediaType mediaType, boolean pretty) {
StringWriter sw = new StringWriter();
try (ConfigurationWriter writer = ConfigurationWriter.to(sw).withType(mediaType).prettyPrint(pretty).build()) {
parserRegistry.serializeWith(writer, new EventLogSerializer(), event);
}
return sw.toString();
}
@Listener
public class ConfigurationListener {
final EmbeddedCacheManager cacheManager;
final EventStream eventStream;
final MediaType mediaType;
private final boolean pretty;
protected ConfigurationListener(EmbeddedCacheManager cacheManager, MediaType mediaType, boolean includeCurrentState, boolean pretty) {
this.cacheManager = cacheManager;
this.mediaType = mediaType;
this.pretty = pretty;
this.eventStream = new EventStream(
includeCurrentState ?
(stream) -> {
for (String configName : cacheManager.getCacheConfigurationNames()) {
Configuration config = SecurityActions.getCacheConfiguration(cacheManager, configName);
String eventType = config.isTemplate() ? "create-template" : "create-cache";
stream.sendEvent(new ServerSentEvent(eventType, serializeConfig(config, configName, mediaType, pretty)));
}
} : null,
() -> Security.doPrivileged(() -> {
cacheManager.removeListenerAsync(this);
}));
}
public EventStream getEventStream() {
return eventStream;
}
@Logged
public CompletionStage<Void> onDataLogged(EventLog event) {
if (event.getCategory() != EventLogCategory.LIFECYCLE) return CompletableFutures.completedNull();
final ServerSentEvent sse = new ServerSentEvent("lifecycle-event", serializeEvent(event, mediaType, pretty));
return eventStream.sendEvent(sse);
}
@ConfigurationChanged
public CompletionStage<Void> onConfigurationEvent(ConfigurationChangedEvent event) {
String eventType = event.getConfigurationEventType().toString().toLowerCase() + "-" + event.getConfigurationEntityType();
final ServerSentEvent sse;
if (event.getConfigurationEventType() == ConfigurationChangedEvent.EventType.REMOVE) {
sse = new ServerSentEvent(eventType, event.getConfigurationEntityName());
} else {
switch (event.getConfigurationEntityType()) {
case "cache":
case "template":
Configuration config = SecurityActions.getCacheConfiguration(cacheManager, event.getConfigurationEntityName());
sse = new ServerSentEvent(eventType, serializeConfig(config, event.getConfigurationEntityName(), mediaType, pretty));
break;
default:
// Unhandled entity type, ignore
return CompletableFutures.completedNull();
}
}
return eventStream.sendEvent(sse);
}
}
}
| 33,371
| 49.717325
| 170
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/BackupManagerResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.ACCEPTED;
import static io.netty.handler.codec.http.HttpResponseStatus.CONFLICT;
import static io.netty.handler.codec.http.HttpResponseStatus.CREATED;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static io.netty.handler.codec.http.HttpResponseStatus.UNSUPPORTED_MEDIA_TYPE;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.hibernate.search.util.common.function.TriFunction;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.util.Util;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestRequest;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.Method;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.logging.Log;
import org.infinispan.server.core.BackupManager;
import org.infinispan.server.core.backup.BackupManagerResources;
import org.infinispan.util.function.TriConsumer;
import org.infinispan.util.logging.LogFactory;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.multipart.DefaultHttpDataFactory;
import io.netty.handler.codec.http.multipart.DiskAttribute;
import io.netty.handler.codec.http.multipart.DiskFileUpload;
import io.netty.handler.codec.http.multipart.HttpPostMultipartRequestDecoder;
import io.netty.handler.codec.http.multipart.InterfaceHttpPostRequestDecoder;
/**
* A helper class for common functionality related to the {@link BackupManager}.
*
* @author Ryan Emerson
* @since 12.0
*/
class BackupManagerResource {
private static final Log LOG = LogFactory.getLog(BackupManagerResource.class, Log.class);
private static final String DIR_KEY = "directory";
private static final String LOCATION_KEY = "location";
private static final String RESOURCES_KEY = "resources";
static CompletionStage<RestResponse> handleBackupRequest(InvocationHelper invocationHelper, RestRequest request, BackupManager backupManager,
TriConsumer<String, Path, Json> creationConsumer) {
String name = request.variables().get("backupName");
Method method = request.method();
switch (method) {
case DELETE:
return handleDeleteBackup(invocationHelper, name, request, backupManager);
case GET:
case HEAD:
return handleGetBackup(invocationHelper, name, request, backupManager, method);
case POST:
return handleCreateBackup(invocationHelper, name, request, backupManager, creationConsumer);
default:
throw Log.REST.wrongMethod(method.toString());
}
}
private static CompletionStage<RestResponse> handleCreateBackup(InvocationHelper invocationHelper, String name, RestRequest request, BackupManager backupManager,
TriConsumer<String, Path, Json> creationConsumer) {
BackupManager.Status existingStatus = backupManager.getBackupStatus(name);
if (existingStatus != BackupManager.Status.NOT_FOUND)
return invocationHelper.newResponse(request, CONFLICT).toFuture();
String body = request.contents().asString();
Json json = !body.isEmpty() ? Json.read(body) : Json.object();
Json dirJson = json.at(DIR_KEY);
Path workingDir = dirJson == null ? null : Paths.get(dirJson.asString());
if (workingDir != null && !Files.isDirectory(workingDir)) {
throw Log.REST.notADirectory(dirJson.asString());
}
Json requestsJson = json.at(RESOURCES_KEY);
creationConsumer.accept(name, workingDir, requestsJson);
return invocationHelper.newResponse(request, ACCEPTED).toFuture();
}
private static CompletionStage<RestResponse> handleDeleteBackup(InvocationHelper invocationHelper, String name, RestRequest request, BackupManager backupManager) {
return backupManager.removeBackup(name).handle((BackupManager.Status s, Throwable t) -> handleDelete(invocationHelper, request, s, t));
}
private static CompletionStage<RestResponse> handleGetBackup(InvocationHelper invocationHelper, String name, RestRequest request, BackupManager backupManager, Method method) {
BackupManager.Status status = backupManager.getBackupStatus(name);
switch (status) {
case FAILED:
throw Log.REST.backupFailed();
case NOT_FOUND:
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
case IN_PROGRESS:
return invocationHelper.newResponse(request, ACCEPTED).toFuture();
default:
File zip = backupManager.getBackupLocation(name).toFile();
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request)
.contentType(MediaType.APPLICATION_ZIP)
.header("Content-Disposition", String.format("attachment; filename=%s", zip.getName()))
.contentLength(zip.length());
if (method == Method.GET)
responseBuilder.entity(zip);
return CompletableFuture.completedFuture(responseBuilder.build());
}
}
static CompletionStage<RestResponse> handleRestoreRequest(InvocationHelper invocationHelper, RestRequest request, BackupManager backupManager,
TriFunction<String, Path, Json, CompletionStage<Void>> function) {
String name = request.variables().get("restoreName");
Method method = request.method();
switch (method) {
case DELETE:
return handleDeleteRestore(invocationHelper, name, request, backupManager);
case HEAD:
return handleRestoreStatus(invocationHelper, name, request, backupManager);
case POST:
return handleRestore(invocationHelper, name, request, backupManager, function);
default:
throw Log.REST.wrongMethod(method.toString());
}
}
static CompletionStage<RestResponse> handleDeleteRestore(InvocationHelper invocationHelper, String name, RestRequest request, BackupManager backupManager) {
return backupManager.removeRestore(name).handle((BackupManager.Status s, Throwable t) -> handleDelete(invocationHelper, request, s, t));
}
static CompletionStage<RestResponse> handleRestoreStatus(InvocationHelper invocationHelper, String name, RestRequest request, BackupManager backupManager) {
BackupManager.Status status = backupManager.getRestoreStatus(name);
switch (status) {
case NOT_FOUND:
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
case IN_PROGRESS:
return invocationHelper.newResponse(request, ACCEPTED).toFuture();
case COMPLETE:
return invocationHelper.newResponse(request, CREATED).toFuture();
default:
throw Log.REST.restoreFailed();
}
}
static CompletionStage<RestResponse> handleRestore(InvocationHelper invocationHelper, String name, RestRequest request, BackupManager backupManager,
TriFunction<String, Path, Json, CompletionStage<Void>> function) {
BackupManager.Status existingStatus = backupManager.getRestoreStatus(name);
if (existingStatus != BackupManager.Status.NOT_FOUND)
return invocationHelper.newResponse(request, CONFLICT).toFuture();
Path path;
Json resourcesJson = Json.object();
MediaType contentType = request.contentType();
boolean uploadedBackup = contentType.match(MediaType.MULTIPART_FORM_DATA);
try {
if (uploadedBackup) {
FullHttpRequest nettyRequest = ((NettyRestRequest) request).getFullHttpRequest();
DefaultHttpDataFactory factory = new DefaultHttpDataFactory(true);
InterfaceHttpPostRequestDecoder decoder = new HttpPostMultipartRequestDecoder(factory, nettyRequest);
DiskFileUpload backup = (DiskFileUpload) decoder.getBodyHttpData("backup");
path = backup.getFile().toPath();
DiskAttribute resources = (DiskAttribute) decoder.getBodyHttpData("resources");
if (resources != null)
resourcesJson = Json.read(resources.getString());
} else if (contentType.match(MediaType.APPLICATION_JSON)) {
// Attempt to parse body as json
Json json = Json.read(request.contents().asString());
Json resources = json.at(RESOURCES_KEY);
if (resources != null)
resourcesJson = resources;
Json backupPath = json.at(LOCATION_KEY);
if (backupPath == null) {
throw Log.REST.missingArgument("backup-location");
}
path = Paths.get(backupPath.asString());
} else {
return invocationHelper.newResponse(request, UNSUPPORTED_MEDIA_TYPE).toFuture();
}
function.apply(name, path, resourcesJson).whenComplete((Void, t) -> {
if (t != null) {
LOG.error(t);
}
if (uploadedBackup) {
try {
Files.delete(path);
} catch (IOException e) {
LOG.warnf(e, "Unable to delete uploaded backup file '%s'", path);
}
}
}
);
return invocationHelper.newResponse(request, ACCEPTED).toFuture();
} catch (IOException e) {
throw Util.unchecked(e);
}
}
static BackupManager.Resources getResources(Json json) {
BackupManagerResources.Builder builder = new BackupManagerResources.Builder();
if (json == null || json.isNull())
return builder.includeAll().build();
Map<String, Object> jsonMap = json.asMap();
if (jsonMap.isEmpty())
return builder.includeAll().build();
for (Map.Entry<String, Object> e : jsonMap.entrySet()) {
@SuppressWarnings("unchecked")
List<String> resources = (List<String>) e.getValue();
BackupManager.Resources.Type type = BackupManager.Resources.Type.fromString(e.getKey());
if (resources.size() == 1 && resources.get(0).equals("*")) {
builder.includeAll(type);
} else {
builder.addResources(type, resources);
}
}
return builder.build();
}
private static RestResponse handleDelete(InvocationHelper invocationHelper, RestRequest request, BackupManager.Status s, Throwable t) {
if (t != null) {
throw Util.unchecked(t);
}
switch (s) {
case NOT_FOUND:
return invocationHelper.newResponse(request, NOT_FOUND);
case IN_PROGRESS:
return invocationHelper.newResponse(request, ACCEPTED);
case COMPLETE:
return invocationHelper.newResponse(request, NO_CONTENT);
default:
throw Log.REST.backupDeleteFailed();
}
}
}
| 11,538
| 45.528226
| 178
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/MetricsResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.OPTIONS;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import org.infinispan.commons.util.Util;
import org.infinispan.metrics.impl.MetricsCollector;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.framework.impl.RestResponseBuilder;
import io.micrometer.prometheus.PrometheusMeterRegistry;
import io.prometheus.client.exporter.common.TextFormat;
/**
* Micrometer metrics resource.
*
* @author anistor@redhat.com
* @since 10.0
*/
public final class MetricsResource implements ResourceHandler {
private static final String METRICS_PATH = "/metrics";
private final boolean auth;
private final Executor blockingExecutor;
private final MetricsCollector metricsCollector;
private final InvocationHelper invocationHelper;
public MetricsResource(boolean auth, InvocationHelper invocationHelper) {
this.auth = auth;
this.blockingExecutor = invocationHelper.getExecutor();
this.metricsCollector = invocationHelper.getMetricsCollector();
this.invocationHelper = invocationHelper;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(GET, OPTIONS).path(METRICS_PATH).anonymous(!auth).handleWith(this::metrics)
.invocation().methods(GET, OPTIONS).path(METRICS_PATH + "/*").anonymous(!auth).handleWith(this::metrics)
.create();
}
private CompletionStage<RestResponse> metrics(RestRequest request) {
return CompletableFuture.supplyAsync(() -> {
RestResponseBuilder<NettyRestResponse.Builder> builder = invocationHelper.newResponse(request);
try {
PrometheusMeterRegistry registry = metricsCollector.registry();
if (registry == null) {
return builder.status(NOT_FOUND.code()).build();
}
String contentType = TextFormat.chooseContentType(request.getAcceptHeader());
builder.header("Content-Type", contentType);
builder.entity(registry.scrape(contentType));
return builder.build();
} catch (Exception e) {
throw Util.unchecked(e);
}
}, blockingExecutor);
}
}
| 2,753
| 36.216216
| 116
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/XSiteResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_MODIFIED;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static java.util.concurrent.CompletableFuture.supplyAsync;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.framework.Method.PUT;
import static org.infinispan.rest.resources.ResourceUtil.addEntityAsJson;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.concurrent.CompletionStage;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.commons.dataconversion.internal.JsonUtils;
import org.infinispan.configuration.cache.TakeOfflineConfiguration;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.xsite.GlobalXSiteAdminOperations;
import org.infinispan.xsite.XSiteAdminOperations;
import org.infinispan.xsite.status.AbstractMixedSiteStatus;
import org.infinispan.xsite.status.ContainerMixedSiteStatus;
import org.infinispan.xsite.status.OfflineSiteStatus;
import org.infinispan.xsite.status.OnlineSiteStatus;
import org.infinispan.xsite.status.SiteStatus;
/**
* Handles REST calls for cache and cache manager level X-Site operations
*
* @since 10.0
*/
public class XSiteResource implements ResourceHandler {
public static final String AFTER_FAILURES_FIELD = "after_failures";
public static final String MIN_WAIT_FIELD = "min_wait";
private static final BiFunction<XSiteAdminOperations, String, String> TAKE_OFFLINE = XSiteAdminOperations::takeSiteOffline;
private static final BiFunction<XSiteAdminOperations, String, String> BRING_ONLINE = XSiteAdminOperations::bringSiteOnline;
private static final BiFunction<XSiteAdminOperations, String, String> PUSH_STATE = XSiteAdminOperations::pushState;
private static final BiFunction<XSiteAdminOperations, String, String> CANCEL_PUSH_STATE = XSiteAdminOperations::cancelPushState;
private static final BiFunction<XSiteAdminOperations, String, String> CANCEL_RECEIVE_STATE = XSiteAdminOperations::cancelReceiveState;
private static final Function<XSiteAdminOperations, Map<String, GlobalStatus>> SITES_STATUS =
xSiteAdminOperations -> xSiteAdminOperations.clusterStatus().entrySet().stream()
.collect(Collectors.toMap(Entry::getKey, GlobalStatus::fromSiteStatus));
private static final Function<XSiteAdminOperations, Map<String, String>> PUSH_STATE_STATUS = XSiteAdminOperations::getPushStateStatus;
private static final Function<XSiteAdminOperations, String> CLEAR_PUSH_STATUS = XSiteAdminOperations::clearPushStateStatus;
private static final BiFunction<GlobalXSiteAdminOperations, String, Map<String, String>> BRING_ALL_CACHES_ONLINE = GlobalXSiteAdminOperations::bringAllCachesOnline;
private static final BiFunction<GlobalXSiteAdminOperations, String, Map<String, String>> TAKE_ALL_CACHES_OFFLINE = GlobalXSiteAdminOperations::takeAllCachesOffline;
private static final BiFunction<GlobalXSiteAdminOperations, String, Map<String, String>> START_PUSH_ALL_CACHES = GlobalXSiteAdminOperations::pushStateAllCaches;
private static final BiFunction<GlobalXSiteAdminOperations, String, Map<String, String>> CANCEL_PUSH_ALL_CACHES = GlobalXSiteAdminOperations::cancelPushStateAllCaches;
private final InvocationHelper invocationHelper;
public XSiteResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(POST).path("/v2/caches/{cacheName}/x-site/local/").withAction("clear-push-state-status")
.permission(AuthorizationPermission.ADMIN).name("XSITE PUSH STATE STATUS CLEAR").auditContext(AuditContext.CACHE)
.handleWith(this::clearPushStateStatus)
.invocation().methods(GET).path("/v2/caches/{cacheName}/x-site/backups/")
.permission(AuthorizationPermission.ADMIN).name("XSITE BACKUP STATUS").auditContext(AuditContext.CACHE)
.handleWith(this::backupStatus)
.invocation().methods(GET).path("/v2/caches/{cacheName}/x-site/backups/").withAction("push-state-status")
.permission(AuthorizationPermission.ADMIN).name("XSITE PUSH STATE STATUS").auditContext(AuditContext.CACHE)
.handleWith(this::pushStateStatus)
.invocation().methods(GET).path("/v2/caches/{cacheName}/x-site/backups/{site}")
.permission(AuthorizationPermission.ADMIN).name("XSITE BACKUPS SITE STATUS").auditContext(AuditContext.CACHE)
.handleWith(this::siteStatus)
.invocation().methods(POST).path("/v2/caches/{cacheName}/x-site/backups/{site}").withAction("take-offline")
.permission(AuthorizationPermission.ADMIN).name("XSITE TAKE OFFLINE").auditContext(AuditContext.CACHE)
.handleWith(this::takeSiteOffline)
.invocation().methods(POST).path("/v2/caches/{cacheName}/x-site/backups/{site}").withAction("bring-online")
.permission(AuthorizationPermission.ADMIN).name("XSITE BRING ONLINE").auditContext(AuditContext.CACHE)
.handleWith(this::bringSiteOnline)
.invocation().methods(POST).path("/v2/caches/{cacheName}/x-site/backups/{site}").withAction("start-push-state")
.permission(AuthorizationPermission.ADMIN).name("XSITE START PUSH STATE").auditContext(AuditContext.CACHE)
.handleWith(this::startStatePush)
.invocation().methods(POST).path("/v2/caches/{cacheName}/x-site/backups/{site}").withAction("cancel-push-state")
.permission(AuthorizationPermission.ADMIN).name("XSITE CANCEL PUSH STATE").auditContext(AuditContext.CACHE)
.handleWith(this::cancelPushState)
.invocation().methods(GET).path("/v2/caches/{cacheName}/x-site/backups/{site}/take-offline-config")
.permission(AuthorizationPermission.ADMIN).name("XSITE TAKE OFFLINE CONFIG").auditContext(AuditContext.CACHE)
.handleWith(this::getXSiteTakeOffline)
.invocation().methods(PUT).path("/v2/caches/{cacheName}/x-site/backups/{site}/take-offline-config")
.permission(AuthorizationPermission.ADMIN).name("XSITE TAKE OFFLINE CONFIG UPDATE").auditContext(AuditContext.CACHE)
.handleWith(this::updateTakeOffline)
.invocation().methods(POST).path("/v2/caches/{cacheName}/x-site/backups/{site}").withAction("cancel-receive-state")
.permission(AuthorizationPermission.ADMIN).name("XSITE CANCEL RECEIVE STATE").auditContext(AuditContext.CACHE)
.handleWith(this::cancelReceiveState)
.invocation().methods(GET).path("/v2/caches/{cacheName}/x-site/backups/{site}/state-transfer-mode")
.permission(AuthorizationPermission.ADMIN).name("XSITE GET STATE TRANSFER MODE").auditContext(AuditContext.CACHE)
.handleWith(this::getStateTransferMode)
.invocation().methods(POST).path("/v2/caches/{cacheName}/x-site/backups/{site}/state-transfer-mode").withAction("set")
.permission(AuthorizationPermission.ADMIN).name("XSITE SET STATE TRANSFER MODE").auditContext(AuditContext.CACHE)
.handleWith(this::setStateTransferMode)
.invocation().methods(GET).path("/v2/cache-managers/{name}/x-site/backups/")
.permission(AuthorizationPermission.ADMIN).name("XSITE GLOBAL STATUS").auditContext(AuditContext.CACHEMANAGER)
.handleWith(this::globalStatus)
.invocation().methods(GET).path("/v2/cache-managers/{name}/x-site/backups/{site}")
.permission(AuthorizationPermission.ADMIN).name("XSITE GLOBAL SITE STATUS").auditContext(AuditContext.CACHEMANAGER)
.handleWith(this::globalStatus)
.invocation().methods(POST).path("/v2/cache-managers/{name}/x-site/backups/{site}").withAction("bring-online")
.permission(AuthorizationPermission.ADMIN).name("XSITE BRING ALL ONLINE").auditContext(AuditContext.CACHEMANAGER)
.handleWith(this::bringAllOnline)
.invocation().methods(POST).path("/v2/cache-managers/{name}/x-site/backups/{site}").withAction("take-offline")
.permission(AuthorizationPermission.ADMIN).name("XSITE TAKE ALL OFFLINE").auditContext(AuditContext.CACHEMANAGER)
.handleWith(this::takeAllOffline)
.invocation().methods(POST).path("/v2/cache-managers/{name}/x-site/backups/{site}").withAction("start-push-state")
.permission(AuthorizationPermission.ADMIN).name("XSITE START PUSH ALL").auditContext(AuditContext.CACHEMANAGER)
.handleWith(this::startPushAll)
.invocation().methods(POST).path("/v2/cache-managers/{name}/x-site/backups/{site}").withAction("cancel-push-state")
.permission(AuthorizationPermission.ADMIN).name("XSITE CANCEL PUSH ALL").auditContext(AuditContext.CACHEMANAGER)
.handleWith(this::cancelPushAll)
.create();
}
private CompletionStage<RestResponse> bringAllOnline(RestRequest request) {
return executeCacheManagerXSiteOp(request, BRING_ALL_CACHES_ONLINE);
}
private CompletionStage<RestResponse> takeAllOffline(RestRequest request) {
return executeCacheManagerXSiteOp(request, TAKE_ALL_CACHES_OFFLINE);
}
private CompletionStage<RestResponse> startPushAll(RestRequest request) {
return executeCacheManagerXSiteOp(request, START_PUSH_ALL_CACHES);
}
private CompletionStage<RestResponse> cancelPushAll(RestRequest request) {
return executeCacheManagerXSiteOp(request, CANCEL_PUSH_ALL_CACHES);
}
private CompletionStage<RestResponse> globalStatus(RestRequest request) {
GlobalXSiteAdminOperations globalXSiteAdmin = getGlobalXSiteAdmin(request);
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
if (globalXSiteAdmin == null) return completedFuture(responseBuilder.status(NOT_FOUND).build());
return supplyAsync(() -> {
Map<String, SiteStatus> globalStatus = Security.doAs(request.getSubject(), globalXSiteAdmin::globalStatus);
Map<String, GlobalStatus> collect = globalStatus.entrySet().stream().collect(Collectors.toMap(Entry::getKey, GlobalStatus::fromSiteStatus));
String site = request.variables().get("site");
if (site != null) {
GlobalStatus siteStatus = collect.get(site);
return siteStatus == null ?
responseBuilder.status(NOT_FOUND).build() :
addEntityAsJson(Json.make(siteStatus), responseBuilder, isPretty(request)).build();
}
return addEntityAsJson(Json.make(collect), responseBuilder, isPretty(request)).build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> pushStateStatus(RestRequest request) {
return statusOperation(request, PUSH_STATE_STATUS);
}
private CompletionStage<RestResponse> backupStatus(RestRequest request) {
return statusOperation(request, SITES_STATUS);
}
private CompletionStage<RestResponse> clearPushStateStatus(RestRequest restRequest) {
return statusOperation(restRequest, CLEAR_PUSH_STATUS);
}
private CompletionStage<RestResponse> cancelReceiveState(RestRequest restRequest) {
return executeXSiteCacheOp(restRequest, CANCEL_RECEIVE_STATE);
}
private CompletionStage<RestResponse> cancelPushState(RestRequest restRequest) {
return executeXSiteCacheOp(restRequest, CANCEL_PUSH_STATE);
}
private CompletionStage<RestResponse> startStatePush(RestRequest restRequest) {
return executeXSiteCacheOp(restRequest, PUSH_STATE);
}
private CompletionStage<RestResponse> takeSiteOffline(RestRequest request) {
return executeXSiteCacheOp(request, TAKE_OFFLINE);
}
private CompletionStage<RestResponse> bringSiteOnline(RestRequest request) {
return executeXSiteCacheOp(request, BRING_ONLINE);
}
private CompletionStage<RestResponse> updateTakeOffline(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request).status(NO_CONTENT);
String site = request.variables().get("site");
Optional<XSiteAdminOperations> xsiteAdminOpt = getXSiteAdminAndCheckSite(request, responseBuilder);
if (!xsiteAdminOpt.isPresent()) {
return completedFuture(responseBuilder.build());
}
XSiteAdminOperations xsiteAdmin = xsiteAdminOpt.get();
TakeOfflineConfiguration current = xsiteAdmin.getTakeOfflineConfiguration(site);
assert current != null;
String content = request.contents().asString();
if (content == null || content.isEmpty()) {
throw Log.REST.missingContent();
}
int afterFailures, minWait;
Json json = Json.read(content);
Json minWaitValue = json.at(MIN_WAIT_FIELD);
Json afterFailuresValue = json.at(AFTER_FAILURES_FIELD);
if (minWaitValue == null || afterFailuresValue == null) {
throw Log.REST.missingArguments(MIN_WAIT_FIELD, AFTER_FAILURES_FIELD);
}
minWait = minWaitValue.asInteger();
afterFailures = afterFailuresValue.asInteger();
if (afterFailures == current.afterFailures() && minWait == current.minTimeToWait()) {
return completedFuture(responseBuilder.status(NOT_MODIFIED).build());
}
return supplyAsync(() -> {
String status = Security.doAs(request.getSubject(), () -> xsiteAdmin.amendTakeOffline(site, afterFailures, minWait));
if (!status.equals(XSiteAdminOperations.SUCCESS)) {
throw Log.REST.siteOperationFailed(site, status);
}
return responseBuilder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getXSiteTakeOffline(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String site = request.variables().get("site");
Optional<XSiteAdminOperations> xsiteAdminOpt = getXSiteAdminAndCheckSite(request, responseBuilder);
xsiteAdminOpt.ifPresent(ops -> {
TakeOfflineConfiguration config = ops.getTakeOfflineConfiguration(site);
assert config != null;
addEntityAsJson(new TakeOffline(config), responseBuilder);
});
return completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> siteStatus(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String site = request.variables().get("site");
Optional<XSiteAdminOperations> xsiteAdminOpt = getXSiteAdminAndCheckSite(request, responseBuilder);
return xsiteAdminOpt.<CompletionStage<RestResponse>>map(ops -> supplyAsync(
() -> addEntityAsJson(Json.make(Security.doAs(request.getSubject(), () -> ops.nodeStatus(site))), responseBuilder, isPretty(request)).build(),
invocationHelper.getExecutor()))
.orElseGet(() -> completedFuture(responseBuilder.build()));
}
private <T> CompletionStage<RestResponse> statusOperation(RestRequest request, Function<XSiteAdminOperations, T> op) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
Optional<XSiteAdminOperations> xsiteAdmin = getXSiteAdmin(request, responseBuilder);
return xsiteAdmin.<CompletionStage<RestResponse>>map(ops -> supplyAsync(
() -> {
T result = Security.doAs(request.getSubject(), () -> op.apply(ops));
return addEntityAsJson(Json.make(result), responseBuilder, isPretty(request)).build();
},
invocationHelper.getExecutor()))
.orElseGet(() -> completedFuture(responseBuilder.build()));
}
private CompletionStage<RestResponse> getStateTransferMode(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
//check if site exists
final String site = request.variables().get("site");
Optional<XSiteAdminOperations> xsiteAdminOpt = getXSiteAdminAndCheckSite(request, responseBuilder);
return xsiteAdminOpt.<CompletionStage<RestResponse>>map(ops ->
ops.asyncGetStateTransferMode(site).thenApply(s -> addEntityAsJson(Json.make(s), responseBuilder, isPretty(request)).build()))
.orElseGet(() -> completedFuture(responseBuilder.build()));
}
private CompletionStage<RestResponse> setStateTransferMode(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
//parse content
String mode = request.getParameter("mode");
if (mode == null) {
throw Log.REST.missingArgument("mode");
}
//check if site exists
final String site = request.variables().get("site");
Optional<XSiteAdminOperations> xsiteAdminOpt = getXSiteAdminAndCheckSite(request, responseBuilder);
return xsiteAdminOpt.<CompletionStage<RestResponse>>map(ops ->
ops.asyncSetStateTransferMode(site, mode)
.thenApply(ok -> responseBuilder.status(ok ? OK : NOT_MODIFIED).build()))
.orElseGet(() -> completedFuture(responseBuilder.build()));
}
private Optional<XSiteAdminOperations> getXSiteAdmin(RestRequest request, NettyRestResponse.Builder responseBuilder) {
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
XSiteAdminOperations ops = SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache()).getComponent(XSiteAdminOperations.class);
if (ops == null) {
noBackupsForCache(responseBuilder, cacheName);
return Optional.empty();
}
return Optional.of(ops);
}
private Optional<XSiteAdminOperations> getXSiteAdminAndCheckSite(RestRequest request, NettyRestResponse.Builder responseBuilder) {
String cacheName = request.variables().get("cacheName");
String site = request.variables().get("site");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
XSiteAdminOperations ops = SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache()).getComponent(XSiteAdminOperations.class);
if (ops == null) {
noBackupsForCache(responseBuilder, cacheName);
return Optional.empty();
}
if (!ops.checkSite(site)) {
siteNotFound(responseBuilder, cacheName, site);
return Optional.empty();
}
return Optional.of(ops);
}
private GlobalXSiteAdminOperations getGlobalXSiteAdmin(RestRequest request) {
String cacheManager = request.variables().get("name");
EmbeddedCacheManager cm = invocationHelper.getRestCacheManager().getInstance();
if (!cacheManager.equals(cm.getCacheManagerInfo().getName())) return null;
return SecurityActions.getGlobalComponentRegistry(cm).getComponent(GlobalXSiteAdminOperations.class);
}
private CompletionStage<RestResponse> executeCacheManagerXSiteOp(RestRequest request,
BiFunction<GlobalXSiteAdminOperations, String, Map<String, String>> operation) {
GlobalXSiteAdminOperations globalXSiteAdmin = getGlobalXSiteAdmin(request);
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String site = request.variables().get("site");
if (globalXSiteAdmin == null) return completedFuture(responseBuilder.status(NOT_FOUND).build());
return supplyAsync(
() -> {
Map<String, String> result = Security.doAs(request.getSubject(), operation, globalXSiteAdmin, site);
return addEntityAsJson(Json.make(result), responseBuilder, isPretty(request)).build();
},
invocationHelper.getExecutor()
);
}
private CompletionStage<RestResponse> executeXSiteCacheOp(RestRequest request, BiFunction<XSiteAdminOperations, String, String> xsiteOp) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String site = request.variables().get("site");
Optional<XSiteAdminOperations> xsiteAdminOpt = getXSiteAdminAndCheckSite(request, responseBuilder);
return xsiteAdminOpt.<CompletionStage<RestResponse>>map(ops ->
supplyAsync(() -> {
String result = Security.doAs(request.getSubject(), () -> xsiteOp.apply(ops, site));
if (!result.equals(XSiteAdminOperations.SUCCESS)) {
throw Log.REST.siteOperationFailed(site, result);
}
return responseBuilder.build();
}, invocationHelper.getExecutor()))
.orElseGet(() -> completedFuture(responseBuilder.build()));
}
private static void noBackupsForCache(NettyRestResponse.Builder builder, String cacheName) {
builder.status(NOT_FOUND).contentType(MediaType.TEXT_PLAIN).entity(String.format("Cache '%s' does not have backup sites.", cacheName));
}
private static void siteNotFound(NettyRestResponse.Builder builder, String cacheName, String site) {
builder.status(NOT_FOUND).contentType(MediaType.TEXT_PLAIN).entity(String.format("Cache '%s' does not backup to site '%s'", cacheName, site));
}
private static class GlobalStatus implements JsonSerialization {
static final GlobalStatus OFFLINE = new GlobalStatus("offline", null, null, null);
static final GlobalStatus ONLINE = new GlobalStatus("online", null, null, null);
static final GlobalStatus UNKNOWN = new GlobalStatus("unknown", null, null, null);
private final String status;
private final Json online;
private final Json offline;
private final Json mixed;
GlobalStatus(String status, Json online, Json offline, Json mixed) {
this.status = status;
this.online = online;
this.offline = offline;
this.mixed = mixed;
}
static GlobalStatus mixed(Json online, Json offline, Json mixed) {
return new GlobalStatus("mixed", online, offline, mixed);
}
static GlobalStatus fromSiteStatus(Map.Entry<String, SiteStatus> entry) {
SiteStatus status = entry.getValue();
if (status instanceof OnlineSiteStatus) return GlobalStatus.ONLINE;
if (status instanceof OfflineSiteStatus) return GlobalStatus.OFFLINE;
Json mixed = null;
if (status instanceof ContainerMixedSiteStatus) {
mixed = JsonUtils.createJsonArray(((ContainerMixedSiteStatus) status).getMixedCaches());
}
if (status instanceof AbstractMixedSiteStatus<?>) {
Json online = JsonUtils.createJsonArray(((AbstractMixedSiteStatus<?>) status).getOnline().stream().map(String::valueOf));
Json offline =JsonUtils.createJsonArray(((AbstractMixedSiteStatus<?>) status).getOffline().stream().map(String::valueOf));
return GlobalStatus.mixed(online, offline, mixed);
}
return GlobalStatus.UNKNOWN;
}
@Override
public Json toJson() {
Json json = Json.object().set("status", this.status);
if (online != null) {
json.set("online", online);
}
if (offline != null) {
json.set("offline", offline);
}
if (mixed != null) {
json.set("mixed", mixed);
}
return json;
}
}
private static class TakeOffline implements JsonSerialization {
private final int afterFailures;
private final long minWait;
TakeOffline(TakeOfflineConfiguration config) {
this.afterFailures = config.afterFailures();
this.minWait = config.minTimeToWait();
}
@Override
public Json toJson() {
return Json.object()
.set(AFTER_FAILURES_FIELD, afterFailures)
.set(MIN_WAIT_FIELD, minWait);
}
}
}
| 25,325
| 53.581897
| 170
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/CacheResourceQueryAction.java
|
package org.infinispan.rest.resources;
import static java.util.Collections.emptyMap;
import static org.infinispan.query.remote.json.JSONConstants.HIT_COUNT_ACCURACY;
import static org.infinispan.query.remote.json.JSONConstants.MAX_RESULTS;
import static org.infinispan.query.remote.json.JSONConstants.OFFSET;
import static org.infinispan.query.remote.json.JSONConstants.QUERY_STRING;
import static org.wildfly.security.http.HttpConstants.BAD_REQUEST;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.cache.QueryConfiguration;
import org.infinispan.objectfilter.ParsingException;
import org.infinispan.query.remote.impl.RemoteQueryManager;
import org.infinispan.query.remote.json.JsonQueryErrorResult;
import org.infinispan.query.remote.json.JsonQueryRequest;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ContentSource;
import org.infinispan.rest.framework.Method;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.security.actions.SecurityActions;
/**
* Helper for handling the 'search' action of the {@link BaseCacheResource}.
*
* @since 10.0
*/
class CacheResourceQueryAction {
private final InvocationHelper invocationHelper;
CacheResourceQueryAction(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
}
public CompletionStage<RestResponse> search(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
JsonQueryRequest query = null;
if (request.method() == Method.GET) {
query = getQueryFromString(request);
}
if (request.method() == Method.POST || request.method() == Method.PUT) {
try {
query = getQueryFromJSON(request);
} catch (IOException e) {
return CompletableFuture.completedFuture(queryError(request, "Invalid search request", e.getMessage()));
}
}
if (query == null || query.getQuery() == null || query.getQuery().isEmpty()) {
return CompletableFuture.completedFuture(queryError(request, "Invalid search request, missing 'query' parameter", null));
}
String cacheName = request.variables().get("cacheName");
boolean isLocal = Boolean.parseBoolean(request.getParameter("local"));
MediaType keyContentType = request.keyContentType();
AdvancedCache<Object, Object> cache = invocationHelper.getRestCacheManager().getCache(cacheName, keyContentType, MediaType.APPLICATION_JSON, request);
QueryConfiguration queryConfiguration = SecurityActions.getCacheConfiguration(cache).query();
query.setDefaultHitCountAccuracy(queryConfiguration.hitCountAccuracy());
String queryString = query.getQuery();
RemoteQueryManager remoteQueryManager = SecurityActions.getCacheComponentRegistry(cache).getComponent(RemoteQueryManager.class);
JsonQueryRequest finalQuery = query;
return CompletableFuture.supplyAsync(() -> {
try {
byte[] queryResultBytes = remoteQueryManager.executeQuery(queryString, emptyMap(), finalQuery.getStartOffset(),
finalQuery.getMaxResults(), finalQuery.getHitCountAccuracy(), cache, MediaType.APPLICATION_JSON, isLocal);
responseBuilder.entity(queryResultBytes);
return responseBuilder.build();
} catch (IllegalArgumentException | ParsingException | IllegalStateException | CacheException e) {
return queryError(request, "Error executing search", e.getMessage());
}
}, invocationHelper.getExecutor());
}
private JsonQueryRequest getQueryFromString(RestRequest request) {
String queryString = getParameterValue(request, QUERY_STRING);
String strOffset = getParameterValue(request, OFFSET);
String strMaxResults = getParameterValue(request, MAX_RESULTS);
String strHitCountAccuracy = getParameterValue(request, HIT_COUNT_ACCURACY);
Integer offset = strOffset != null ? Integer.valueOf(strOffset) : null;
Integer maxResults = strMaxResults != null ? Integer.valueOf(strMaxResults) : null;
Integer hitCountAccuracy = strHitCountAccuracy != null ? Integer.valueOf(strHitCountAccuracy) : null;
return new JsonQueryRequest(queryString, offset, maxResults, hitCountAccuracy);
}
private JsonQueryRequest getQueryFromJSON(RestRequest request) throws IOException {
ContentSource contents = request.contents();
byte[] byteContent = contents.rawContent();
if (byteContent == null || byteContent.length == 0) throw new IOException();
return JsonQueryRequest.fromJson(new String(byteContent, StandardCharsets.UTF_8));
}
private String getParameterValue(RestRequest request, String name) {
List<String> values = request.parameters().get(name);
return values == null ? null : values.iterator().next();
}
private RestResponse queryError(RestRequest request, String message, String cause) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request).status(BAD_REQUEST);
builder.entity(new JsonQueryErrorResult(message, cause).asBytes());
return builder.build();
}
}
| 5,573
| 46.237288
| 156
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/CacheResourceV2.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.BAD_REQUEST;
import static io.netty.handler.codec.http.HttpResponseStatus.CONFLICT;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON_TYPE;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OCTET_STREAM;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_XML;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_YAML;
import static org.infinispan.commons.dataconversion.MediaType.MATCH_ALL;
import static org.infinispan.commons.dataconversion.MediaType.TEXT_EVENT_STREAM;
import static org.infinispan.commons.dataconversion.MediaType.TEXT_PLAIN;
import static org.infinispan.commons.util.EnumUtil.EMPTY_BIT_SET;
import static org.infinispan.commons.util.Util.unwrapExceptionMessage;
import static org.infinispan.rest.RestRequestHandler.filterCause;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.HEAD;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.framework.Method.PUT;
import static org.infinispan.rest.resources.MediaTypeUtils.negotiateMediaType;
import static org.infinispan.rest.resources.ResourceUtil.addEntityAsJson;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponse;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.EnumSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.cache.impl.EncoderEntryMapper;
import org.infinispan.cache.impl.EncoderKeyMapper;
import org.infinispan.commons.api.CacheContainerAdmin.AdminFlag;
import org.infinispan.commons.configuration.AbstractTypedPropertiesConfiguration;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.commons.configuration.io.ConfigurationResourceResolvers;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.configuration.io.NamingStrategy;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.commons.io.StringBuilderWriter;
import org.infinispan.commons.util.ProcessorInfo;
import org.infinispan.commons.util.Util;
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.container.entries.CacheEntry;
import org.infinispan.container.impl.InternalEntryFactory;
import org.infinispan.distribution.DistributionManager;
import org.infinispan.factories.ComponentRegistry;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.health.impl.CacheHealthImpl;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.manager.EmbeddedCacheManagerAdmin;
import org.infinispan.marshall.core.EncoderRegistry;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryExpired;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryModified;
import org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved;
import org.infinispan.notifications.cachelistener.event.CacheEntryEvent;
import org.infinispan.partitionhandling.AvailabilityMode;
import org.infinispan.persistence.manager.PersistenceManager;
import org.infinispan.persistence.remote.RemoteStore;
import org.infinispan.persistence.remote.configuration.RemoteStoreConfiguration;
import org.infinispan.persistence.remote.upgrade.SerializationUtils;
import org.infinispan.query.core.stats.impl.SearchStatsRetriever;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.reactive.publisher.PublisherTransformers;
import org.infinispan.reactive.publisher.impl.ClusterPublisherManager;
import org.infinispan.reactive.publisher.impl.DeliveryGuarantee;
import org.infinispan.reactive.publisher.impl.SegmentPublisherSupplier;
import org.infinispan.registry.InternalCacheRegistry;
import org.infinispan.rest.EventStream;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestRequest;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.ResponseHeader;
import org.infinispan.rest.RestResponseException;
import org.infinispan.rest.ServerSentEvent;
import org.infinispan.rest.cachemanager.RestCacheManager;
import org.infinispan.rest.distribution.CacheDistributionInfo;
import org.infinispan.rest.framework.ContentSource;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.rest.stream.CacheChunkedStream;
import org.infinispan.rest.stream.CacheEntryStreamProcessor;
import org.infinispan.rest.stream.CacheKeyStreamProcessor;
import org.infinispan.rest.tracing.RestTelemetryService;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.stats.Stats;
import org.infinispan.topology.ClusterTopologyManager;
import org.infinispan.topology.LocalTopologyManager;
import org.infinispan.upgrade.RollingUpgradeManager;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.multipart.DefaultHttpDataFactory;
import io.netty.handler.codec.http.multipart.HttpPostMultipartRequestDecoder;
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
import io.netty.handler.codec.http.multipart.MemoryAttribute;
import io.reactivex.rxjava3.core.Flowable;
/**
* REST resource to manage the caches.
*
* @since 10.0
*/
public class CacheResourceV2 extends BaseCacheResource implements ResourceHandler {
private static final int STREAM_BATCH_SIZE = 1000;
private static final String MIGRATOR_NAME = "hotrod";
private final ParserRegistry parserRegistry = new ParserRegistry();
private final InternalCacheRegistry internalCacheRegistry;
public CacheResourceV2(InvocationHelper invocationHelper, RestTelemetryService telemetryService) {
super(invocationHelper, telemetryService);
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
GlobalComponentRegistry globalComponentRegistry = SecurityActions.getGlobalComponentRegistry(cacheManager);
this.internalCacheRegistry = globalComponentRegistry.getComponent(InternalCacheRegistry.class);
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
// Key related operations
.invocation().methods(PUT, POST).path("/v2/caches/{cacheName}/{cacheKey}").handleWith(this::putValueToCache)
.invocation().methods(GET, HEAD).path("/v2/caches/{cacheName}/{cacheKey}").handleWith(this::getCacheValue)
.invocation().method(GET).path("/v2/caches/{cacheName}/{cacheKey}").withAction("distribution").handleWith(this::getKeyDistribution)
.invocation().method(DELETE).path("/v2/caches/{cacheName}/{cacheKey}").handleWith(this::deleteCacheValue)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("keys").handleWith(this::streamKeys)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("entries").handleWith(this::streamEntries)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("listen").handleWith(this::cacheListen)
// Config and statistics
.invocation().methods(GET, HEAD).path("/v2/caches/{cacheName}").withAction("config").handleWith(this::getCacheConfig)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("stats").handleWith(this::getCacheStats)
.invocation().methods(POST).path("/v2/caches/{cacheName}").withAction("stats-reset").permission(AuthorizationPermission.ADMIN).handleWith(this::resetCacheStats)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("distribution").handleWith(this::getCacheDistribution)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("get-mutable-attributes").permission(AuthorizationPermission.ADMIN).handleWith(this::getCacheConfigMutableAttributes)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("get-mutable-attribute").permission(AuthorizationPermission.ADMIN).handleWith(this::getCacheConfigMutableAttribute)
.invocation().methods(POST).path("/v2/caches/{cacheName}").withAction("set-mutable-attribute").permission(AuthorizationPermission.ADMIN).handleWith(this::setCacheConfigMutableAttribute)
// List
.invocation().methods(GET).path("/v2/caches/").handleWith(this::getCacheNames)
// Health
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("health").handleWith(this::getCacheHealth)
// Cache lifecycle
.invocation().methods(POST, PUT).path("/v2/caches/{cacheName}").handleWith(this::createOrUpdate)
.invocation().method(DELETE).path("/v2/caches/{cacheName}").handleWith(this::removeCache)
.invocation().method(HEAD).path("/v2/caches/{cacheName}").handleWith(this::cacheExists)
.invocation().method(GET).path("/v2/caches/{cacheName}").withAction("get-availability").permission(AuthorizationPermission.ADMIN).handleWith(this::getCacheAvailability)
.invocation().method(POST).path("/v2/caches/{cacheName}").withAction("set-availability").permission(AuthorizationPermission.ADMIN).handleWith(this::setCacheAvailability)
// Operations
.invocation().methods(POST).path("/v2/caches/{cacheName}").withAction("clear").handleWith(this::clearEntireCache)
.invocation().methods(GET).path("/v2/caches/{cacheName}").withAction("size").handleWith(this::getSize)
// Rolling Upgrade methods
.invocation().methods(POST).path("/v2/caches/{cacheName}").withAction("sync-data").handleWith(this::syncData)
.invocation().methods(POST).path("/v2/caches/{cacheName}").deprecated().withAction("disconnect-source").handleWith(this::deleteSourceConnection)
.invocation().methods(POST).path("/v2/caches/{cacheName}/rolling-upgrade/source-connection").handleWith(this::addSourceConnection)
.invocation().methods(DELETE).path("/v2/caches/{cacheName}/rolling-upgrade/source-connection").handleWith(this::deleteSourceConnection)
.invocation().methods(HEAD).path("/v2/caches/{cacheName}/rolling-upgrade/source-connection").handleWith(this::hasSourceConnections)
.invocation().methods(GET).path("/v2/caches/{cacheName}/rolling-upgrade/source-connection").handleWith(this::getSourceConnection)
// Search
.invocation().methods(GET, POST).path("/v2/caches/{cacheName}").withAction("search")
.permission(AuthorizationPermission.BULK_READ)
.handleWith(queryAction::search)
// Misc
.invocation().methods(POST).path("/v2/caches").withAction("toJSON").deprecated().handleWith(this::convertToJson)
.invocation().methods(POST).path("/v2/caches").withAction("convert").handleWith(this::convert)
.invocation().methods(POST).path("/v2/caches").withAction("compare").handleWith(this::compare)
// All details
.invocation().methods(GET).path("/v2/caches/{cacheName}").handleWith(this::getAllDetails)
// Enable Rebalance
.invocation().methods(POST).path("/v2/caches/{cacheName}").withAction("enable-rebalancing")
.permission(AuthorizationPermission.ADMIN).name("ENABLE REBALANCE").auditContext(AuditContext.CACHE)
.handleWith(r -> setRebalancing(true, r))
// Disable Rebalance
.invocation().methods(POST).path("/v2/caches/{cacheName}").withAction("disable-rebalancing")
.permission(AuthorizationPermission.ADMIN).name("DISABLE REBALANCE").auditContext(AuditContext.CACHE)
.handleWith(r -> setRebalancing(false, r))
// Restore after a shutdown
.invocation().method(POST).path("/v2/caches/{cacheName}").withAction("initialize")
.permission(AuthorizationPermission.ADMIN).name("Initialize cache").auditContext(AuditContext.CACHE)
.handleWith(this::reinitializeCache)
.create();
}
@SuppressWarnings("rawtypes")
private CompletionStage<RestResponse> getSourceConnection(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
PersistenceManager persistenceManager =
SecurityActions.getPersistenceManager(invocationHelper.getRestCacheManager().getInstance(), cache.getName());
List<RemoteStore> remoteStores = new ArrayList<>(persistenceManager.getStores(RemoteStore.class));
if (remoteStores.isEmpty()) {
builder.status(NOT_FOUND);
return completedFuture(builder.build());
}
if (remoteStores.size() != 1) {
throw Log.REST.multipleRemoteStores();
}
RemoteStoreConfiguration storeConfiguration = remoteStores.get(0).getConfiguration();
builder.entity(SerializationUtils.toJson(storeConfiguration));
return completedFuture(builder.build());
}
private CompletionStage<RestResponse> hasSourceConnections(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
RollingUpgradeManager upgradeManager = cache.getAdvancedCache().getComponentRegistry().getComponent(RollingUpgradeManager.class);
return CompletableFuture.supplyAsync(() -> {
if (!upgradeManager.isConnected(MIGRATOR_NAME)) {
builder.status(NOT_FOUND);
}
return builder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> deleteSourceConnection(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
builder.status(NO_CONTENT);
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
RollingUpgradeManager upgradeManager = cache.getAdvancedCache().getComponentRegistry().getComponent(RollingUpgradeManager.class);
if (upgradeManager.isConnected(MIGRATOR_NAME)) {
upgradeManager.disconnectSource(MIGRATOR_NAME);
} else {
builder.status(HttpResponseStatus.NOT_MODIFIED);
}
return completedFuture(builder.build());
}
private CompletionStage<RestResponse> addSourceConnection(RestRequest request) {
final NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
builder.status(NO_CONTENT);
String cacheName = request.variables().get("cacheName");
ContentSource contents = request.contents();
byte[] config = contents.rawContent();
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null) {
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
}
if (config == null || config.length == 0) {
return invocationHelper.newResponse(request, BAD_REQUEST, "A remote-store config must be provided").toFuture();
}
String storeConfig = new String(config, UTF_8);
Json read = Json.read(storeConfig);
if (!read.isObject() || read.at("remote-store") == null || read.asMap().size() != 1) {
return invocationHelper.newResponse(request, BAD_REQUEST, "Invalid remote-store JSON description: a single remote-store element must be provided").toFuture();
}
return CompletableFuture.supplyAsync(() -> {
RollingUpgradeManager upgradeManager = cache.getAdvancedCache().getComponentRegistry().getComponent(RollingUpgradeManager.class);
try {
RemoteStoreConfiguration storeConfiguration = SerializationUtils.fromJson(read.toString());
if (!upgradeManager.isConnected(MIGRATOR_NAME)) {
upgradeManager.connectSource(MIGRATOR_NAME, storeConfiguration);
} else {
builder.status(HttpResponseStatus.NOT_MODIFIED);
}
return builder.build();
} catch (IOException e) {
throw new RuntimeException(e);
}
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> syncData(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
String readBatchReq = request.getParameter("read-batch");
String threadsReq = request.getParameter("threads");
int readBatch = readBatchReq == null ? 10_000 : Integer.parseInt(readBatchReq);
if (readBatch < 1) {
throw Log.REST.illegalArgument("read-batch", readBatch);
}
int threads = request.getParameter("threads") == null ? ProcessorInfo.availableProcessors() : Integer.parseInt(threadsReq);
if (threads < 1) {
throw Log.REST.illegalArgument("threads", threads);
}
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
RollingUpgradeManager upgradeManager = cache.getAdvancedCache().getComponentRegistry().getComponent(RollingUpgradeManager.class);
return CompletableFuture.supplyAsync(() -> {
long hotrod = upgradeManager.synchronizeData(MIGRATOR_NAME, readBatch, threads);
builder.entity(Log.REST.synchronizedEntries(hotrod));
return builder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> convert(RestRequest request, MediaType toType) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
boolean pretty = Boolean.parseBoolean(request.getParameter("pretty"));
String contents = request.contents().asString();
if (contents == null || contents.isEmpty()) {
throw Log.REST.missingContent();
}
return CompletableFuture.supplyAsync(() -> {
ParserRegistry parserRegistry = invocationHelper.getParserRegistry();
Properties properties = new Properties();
ConfigurationReader reader = ConfigurationReader.from(contents)
.withResolver(ConfigurationResourceResolvers.DEFAULT)
.withType(request.contentType())
.withProperties(properties)
.withNamingStrategy(NamingStrategy.KEBAB_CASE).build();
ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder();
parserRegistry.parse(reader, holder);
Map.Entry<String, ConfigurationBuilder> entry = holder.getNamedConfigurationBuilders().entrySet().iterator().next();
Configuration configuration = entry.getValue().build();
StringBuilderWriter out = new StringBuilderWriter();
try (ConfigurationWriter writer = ConfigurationWriter.to(out).withType(toType).clearTextSecrets(true).prettyPrint(pretty).build()) {
parserRegistry.serialize(writer, entry.getKey(), configuration);
}
return responseBuilder.contentType(toType).entity(out.toString()).build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> convertToJson(RestRequest request) {
return convert(request, APPLICATION_JSON);
}
private CompletionStage<RestResponse> convert(RestRequest request) {
return convert(request, negotiateMediaType(request, APPLICATION_JSON, APPLICATION_XML, APPLICATION_YAML));
}
private CompletionStage<RestResponse> compare(RestRequest request) {
boolean ignoreMutable = Boolean.parseBoolean(request.getParameter("ignoreMutable"));
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
MediaType contentType = request.contentType();
if (!contentType.match(MediaType.MULTIPART_FORM_DATA)) {
throw Log.REST.wrongMediaType(MediaType.MULTIPART_FORM_DATA_TYPE, contentType.toString());
}
FullHttpRequest nettyRequest = ((NettyRestRequest) request).getFullHttpRequest();
DefaultHttpDataFactory factory = new DefaultHttpDataFactory(false);
HttpPostMultipartRequestDecoder decoder = new HttpPostMultipartRequestDecoder(factory, nettyRequest);
List<InterfaceHttpData> datas = decoder.getBodyHttpDatas();
if (datas.size() != 2) {
throw Log.REST.cacheCompareWrongContent();
}
MemoryAttribute one = (MemoryAttribute) datas.get(0);
MemoryAttribute two = (MemoryAttribute) datas.get(1);
String s1 = one.content().toString(UTF_8);
String s2 = two.content().toString(UTF_8);
ParserRegistry parserRegistry = invocationHelper.getParserRegistry();
Map<String, ConfigurationBuilder> b1 = parserRegistry.parse(s1, null).getNamedConfigurationBuilders();
Map<String, ConfigurationBuilder> b2 = parserRegistry.parse(s2, null).getNamedConfigurationBuilders();
if (b1.size() != 1 || b2.size() != 1) {
throw Log.REST.cacheCompareWrongContent();
}
Configuration c1 = b1.values().iterator().next().build();
Configuration c2 = b2.values().iterator().next().build();
boolean result;
if (ignoreMutable) {
try {
c1.validateUpdate(null, c2);
result = true;
} catch (Throwable t) {
result = false;
responseBuilder.entity(unwrapExceptionMessage(filterCause(t)));
}
} else {
result = c1.equals(c2);
}
return CompletableFuture.completedFuture(responseBuilder.status(result ? NO_CONTENT : CONFLICT).build());
}
private CompletionStage<RestResponse> streamKeys(RestRequest request) {
String cacheName = request.variables().get("cacheName");
String batchParam = request.getParameter("batch");
String limitParam = request.getParameter("limit");
int batch = batchParam == null || batchParam.isEmpty() ? STREAM_BATCH_SIZE : Integer.parseInt(batchParam);
int limit = limitParam == null || limitParam.isEmpty() ? -1 : Integer.parseInt(limitParam);
AdvancedCache<Object, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, TEXT_PLAIN, MATCH_ALL, request);
if (cache == null)
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
ComponentRegistry registry = SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache());
ClusterPublisherManager<Object, ?> cpm = registry.getClusterPublisherManager().wired();
EncoderKeyMapper<Object> mapper = new EncoderKeyMapper<>(cache.getKeyDataConversion());
mapper.injectDependencies(registry);
SegmentPublisherSupplier<Object> sps = cpm.keyPublisher(null, null, null, EMPTY_BIT_SET, DeliveryGuarantee.EXACTLY_ONCE,
batch, PublisherTransformers.identity());
Flowable<byte[]> flowable = Flowable.fromPublisher(sps.publisherWithoutSegments())
.map(e -> CacheChunkedStream.readContentAsBytes(mapper.apply(e)));
if (limit > -1) {
flowable = flowable.take(limit);
}
responseBuilder.entity(new CacheKeyStreamProcessor(flowable));
responseBuilder.contentType(APPLICATION_JSON_TYPE);
return CompletableFuture.completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> streamEntries(RestRequest request) {
String cacheName = request.variables().get("cacheName");
String limitParam = request.getParameter("limit");
String metadataParam = request.getParameter("metadata");
String batchParam = request.getParameter("batch");
String negotiateMediaType = request.getParameter("content-negotiation");
int limit = limitParam == null ? -1 : Integer.parseInt(limitParam);
boolean metadata = Boolean.parseBoolean(metadataParam);
int batch = batchParam == null ? STREAM_BATCH_SIZE : Integer.parseInt(batchParam);
boolean negotiate = Boolean.parseBoolean(negotiateMediaType);
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request).getAdvancedCache();
if (cache == null) return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
final MediaType keyMediaType = getMediaType(negotiate, cache, true);
final MediaType valueMediaType = getMediaType(negotiate, cache, false);
AdvancedCache<?, ?> typedCache = invocationHelper.getRestCacheManager().getCache(cacheName, keyMediaType, valueMediaType, request);
ComponentRegistry registry = SecurityActions.getCacheComponentRegistry(typedCache);
ClusterPublisherManager<Object, Object> cpm = registry.getClusterPublisherManager().wired();
InternalEntryFactory ief = registry.getInternalEntryFactory().running();
EncoderEntryMapper<Object, Object, CacheEntry<Object, Object>> mapper = EncoderEntryMapper.newCacheEntryMapper(typedCache.getKeyDataConversion(), typedCache.getValueDataConversion(), ief);
mapper.injectDependencies(registry);
SegmentPublisherSupplier<CacheEntry<Object, Object>> sps = cpm.entryPublisher(null, null, null, EMPTY_BIT_SET, DeliveryGuarantee.EXACTLY_ONCE,
batch, PublisherTransformers.identity());
Flowable<CacheEntry<?, ?>> flowable = Flowable.fromPublisher(sps.publisherWithoutSegments())
.map(mapper::apply);
if (limit > -1) {
flowable = flowable.take(limit);
}
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.entity(new CacheEntryStreamProcessor(flowable, keyMediaType.match(APPLICATION_JSON),
valueMediaType.match(APPLICATION_JSON), metadata));
responseBuilder.contentType(APPLICATION_JSON_TYPE);
responseBuilder.header(ResponseHeader.KEY_CONTENT_TYPE_HEADER.getValue(), keyMediaType.toString());
responseBuilder.header(ResponseHeader.VALUE_CONTENT_TYPE_HEADER.getValue(), valueMediaType.toString());
return CompletableFuture.completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> cacheListen(RestRequest request) {
MediaType accept = negotiateMediaType(request, APPLICATION_JSON, TEXT_PLAIN);
String cacheName = request.variables().get("cacheName");
boolean includeCurrentState = Boolean.parseBoolean(request.getParameter("includeCurrentState"));
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
if (!restCacheManager.cacheExists(cacheName))
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
Cache<?, ?> cache = restCacheManager.getCache(cacheName, accept, accept, request);
BaseCacheListener listener = includeCurrentState ? new StatefulCacheListener(cache) : new StatelessCacheListener(cache);
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.contentType(TEXT_EVENT_STREAM).entity(listener.getEventStream());
return cache.addListenerAsync(listener).thenApply(v -> responseBuilder.build());
}
private MediaType getMediaType(boolean negotiate, AdvancedCache<?, ?> cache, boolean forKey) {
MediaType storageMediaType = (forKey) ?
cache.getKeyDataConversion().getStorageMediaType() :
cache.getValueDataConversion().getStorageMediaType();
boolean protoStreamEncoding = MediaType.APPLICATION_PROTOSTREAM.equals(storageMediaType);
if (negotiate) {
return negotiateEntryMediaType(storageMediaType, protoStreamEncoding);
}
return (protoStreamEncoding) ? APPLICATION_JSON : TEXT_PLAIN;
}
private MediaType negotiateEntryMediaType(MediaType storage, boolean protoStreamEncoding) {
EncoderRegistry encoderRegistry = invocationHelper.getEncoderRegistry();
boolean encodingDefined = !MediaType.APPLICATION_UNKNOWN.equals(storage);
boolean jsonSupported = encodingDefined && encoderRegistry.isConversionSupported(storage, APPLICATION_JSON);
boolean textSupported = encodingDefined && encoderRegistry.isConversionSupported(storage, TEXT_PLAIN);
if (protoStreamEncoding) {
if (jsonSupported) return APPLICATION_JSON;
if (textSupported) return TEXT_PLAIN;
} else {
if (textSupported) return TEXT_PLAIN;
if (jsonSupported) return APPLICATION_JSON;
}
if (encodingDefined) return storage.withEncoding("hex");
return APPLICATION_OCTET_STREAM.withEncoding("hex");
}
private CompletionStage<RestResponse> removeCache(RestRequest request) {
String cacheName = request.variables().get("cacheName");
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
if (!restCacheManager.cacheExists(cacheName))
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
return CompletableFuture.supplyAsync(() -> {
restCacheManager.getCacheManagerAdmin(request).removeCache(cacheName);
return invocationHelper.newResponse(request)
.status(OK)
.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> cacheExists(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
if (!invocationHelper.getRestCacheManager().getInstance().getCacheConfigurationNames().contains(cacheName)) {
responseBuilder.status(NOT_FOUND);
} else {
responseBuilder.status(NO_CONTENT);
}
return CompletableFuture.completedFuture(responseBuilder.build());
}
private CompletableFuture<RestResponse> createOrUpdate(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
List<String> template = request.parameters().get("template");
String cacheName = request.variables().get("cacheName");
EnumSet<AdminFlag> adminFlags = request.getAdminFlags();
if (request.method() == PUT) {
if (adminFlags == null) {
adminFlags = EnumSet.of(AdminFlag.UPDATE);
} else {
adminFlags.add(AdminFlag.UPDATE);
}
}
EmbeddedCacheManagerAdmin initialAdmin = invocationHelper.getRestCacheManager().getCacheManagerAdmin(request);
EmbeddedCacheManagerAdmin administration = adminFlags == null ? initialAdmin : initialAdmin.withFlags(adminFlags);
if (template != null && !template.isEmpty()) {
if (request.method() == PUT) {
throw Log.REST.wrongMethod(request.method().toString());
}
String templateName = template.iterator().next();
return CompletableFuture.supplyAsync(() -> {
administration.createCache(cacheName, templateName);
responseBuilder.status(OK);
return responseBuilder.build();
}, invocationHelper.getExecutor());
}
ContentSource contents = request.contents();
byte[] bytes = contents.rawContent();
if (bytes == null || bytes.length == 0) {
if (request.method() == PUT) {
throw Log.REST.wrongMethod(request.method().toString());
}
return CompletableFuture.supplyAsync(() -> {
administration.createCache(cacheName, (String) null);
responseBuilder.status(OK);
return responseBuilder.build();
}, invocationHelper.getExecutor());
}
MediaType sourceType = request.contentType() == null ? APPLICATION_JSON : request.contentType();
if (!sourceType.match(APPLICATION_JSON) && !sourceType.match(APPLICATION_XML) && !sourceType.match(APPLICATION_YAML)) {
responseBuilder.status(HttpResponseStatus.UNSUPPORTED_MEDIA_TYPE);
return CompletableFuture.completedFuture(responseBuilder.build());
}
GlobalConfiguration globalConfiguration = SecurityActions.getCacheManagerConfiguration(invocationHelper.getRestCacheManager().getInstance());
return CompletableFuture.supplyAsync(() -> {
ConfigurationBuilderHolder holder = invocationHelper.getParserRegistry().parse(new String(bytes, UTF_8), sourceType);
ConfigurationBuilder cfgBuilder = holder.getCurrentConfigurationBuilder() != null ? holder.getCurrentConfigurationBuilder() : new ConfigurationBuilder();
if (request.method() == PUT) {
administration.getOrCreateCache(cacheName, cfgBuilder.build(globalConfiguration));
} else {
administration.createCache(cacheName, cfgBuilder.build(globalConfiguration));
}
responseBuilder.status(OK);
return responseBuilder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getCacheStats(RestRequest request) {
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
return CompletableFuture.supplyAsync(() ->
asJsonResponse(invocationHelper.newResponse(request), cache.getAdvancedCache().getStats().toJson(), isPretty(request)), invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> resetCacheStats(RestRequest request) {
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
return CompletableFuture.supplyAsync(() -> {
cache.getAdvancedCache().getStats().reset();
return invocationHelper.newResponse(request, NO_CONTENT);
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getCacheDistribution(RestRequest request) {
String cacheName = request.variables().get("cacheName");
RestCacheManager<?> cache = invocationHelper.getRestCacheManager();
boolean pretty = isPretty(request);
return CompletableFuture.supplyAsync(() -> cache.cacheDistribution(cacheName, request), invocationHelper.getExecutor())
.thenCompose(Function.identity())
.thenApply(distributions -> asJsonResponse(invocationHelper.newResponse(request), Json.array(distributions.stream().map(CacheDistributionInfo::toJson).toArray()), pretty));
}
private CompletionStage<RestResponse> getKeyDistribution(RestRequest request) {
boolean pretty = isPretty(request);
return keyDistribution(request)
.thenApply(distribution -> asJsonResponse(invocationHelper.newResponse(request), distribution.toJson(), pretty));
}
private CompletionStage<RestResponse> getAllDetails(RestRequest request) {
String cacheName = request.variables().get("cacheName");
boolean pretty = isPretty(request);
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null)
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
return CompletableFuture.supplyAsync(() -> getDetailResponse(request, cache, pretty), invocationHelper.getExecutor());
}
private RestResponse getDetailResponse(RestRequest request, Cache<?, ?> cache, boolean pretty) {
Configuration configuration = SecurityActions.getCacheConfiguration(cache.getAdvancedCache());
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
GlobalConfiguration globalConfiguration = SecurityActions.getCacheManagerConfiguration(cacheManager);
PersistenceManager persistenceManager = SecurityActions.getPersistenceManager(cacheManager, cache.getName());
Stats stats = null;
Boolean rehashInProgress = null;
Boolean indexingInProgress = null;
Boolean queryable = null;
try {
// TODO Shouldn't we return the clustered stats, like Hot Rod does?
stats = cache.getAdvancedCache().getStats();
DistributionManager distributionManager = cache.getAdvancedCache().getDistributionManager();
rehashInProgress = distributionManager != null && distributionManager.isRehashInProgress();
} catch (SecurityException ex) {
// Admin is needed
}
Boolean rebalancingEnabled = null;
try {
LocalTopologyManager localTopologyManager = SecurityActions.getCacheComponentRegistry(cache.getAdvancedCache())
.getComponent(LocalTopologyManager.class);
if (localTopologyManager != null) {
rebalancingEnabled = localTopologyManager.isCacheRebalancingEnabled(cache.getName());
}
} catch (Exception ex) {
// Getting rebalancing status might raise an exception
}
Integer size = null;
if (globalConfiguration.metrics().accurateSize()) {
try {
size = cache.size();
} catch (SecurityException ex) {
// Bulk Read is needed
}
}
indexingInProgress = reindexingInProgress(cache);
queryable = invocationHelper.getRestCacheManager().isCacheQueryable(cache);
boolean statistics = configuration.statistics().enabled();
boolean indexed = configuration.indexing().enabled();
CacheFullDetail fullDetail = new CacheFullDetail();
fullDetail.stats = stats;
StringBuilderWriter sw = new StringBuilderWriter();
try (ConfigurationWriter w = ConfigurationWriter.to(sw).withType(APPLICATION_JSON).prettyPrint(pretty).build()) {
invocationHelper.getParserRegistry().serialize(w, cache.getName(), configuration);
}
fullDetail.configuration = sw.toString();
fullDetail.size = size;
fullDetail.rehashInProgress = rehashInProgress;
fullDetail.indexingInProgress = indexingInProgress;
fullDetail.persistent = persistenceManager.isEnabled();
fullDetail.bounded = configuration.memory().whenFull().isEnabled();
fullDetail.indexed = indexed;
fullDetail.hasRemoteBackup = configuration.sites().hasBackups();
fullDetail.secured = configuration.security().authorization().enabled();
fullDetail.transactional = configuration.transaction().transactionMode().isTransactional();
fullDetail.statistics = statistics;
fullDetail.queryable = queryable;
fullDetail.rebalancingEnabled = rebalancingEnabled;
fullDetail.keyStorage = cache.getAdvancedCache().getKeyDataConversion().getStorageMediaType();
fullDetail.valueStorage = cache.getAdvancedCache().getValueDataConversion().getStorageMediaType();
return addEntityAsJson(fullDetail.toJson(), invocationHelper.newResponse(request), pretty).build();
}
private boolean reindexingInProgress(Cache<?,?> cache) {
SearchStatsRetriever searchStatsRetriever = ComponentRegistryUtils.getSearchStatsRetriever(cache);
if (searchStatsRetriever != null || !internalCacheRegistry.isInternalCache(cache.getName())) {
return searchStatsRetriever.getSearchStatistics().getIndexStatistics().reindexing();
}
// safely returning false in case of internal cache
return false;
}
private CompletionStage<RestResponse> getCacheConfig(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
boolean pretty = Boolean.parseBoolean(request.getParameter("pretty"));
MediaType accept = negotiateMediaType(request, APPLICATION_JSON, APPLICATION_XML, APPLICATION_YAML);
responseBuilder.contentType(accept);
if (!invocationHelper.getRestCacheManager().getInstance().getCacheConfigurationNames().contains(cacheName)) {
responseBuilder.status(NOT_FOUND).build();
}
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null)
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(cache.getAdvancedCache());
ByteArrayOutputStream entity = new ByteArrayOutputStream();
try (ConfigurationWriter writer = ConfigurationWriter.to(entity).withType(accept).prettyPrint(pretty).build()) {
parserRegistry.serialize(writer, cacheName, cacheConfiguration);
} catch (Exception e) {
throw Util.unchecked(e);
}
responseBuilder.entity(entity);
return CompletableFuture.completedFuture(responseBuilder.status(OK).build());
}
private CompletionStage<RestResponse> getCacheAvailability(RestRequest request) {
String cacheName = request.variables().get("cacheName");
// Use EmbeddedCacheManager directly to allow internal caches to be updated
if (!invocationHelper.getRestCacheManager().getInstance().isRunning(cacheName))
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getInstance().getCache(cacheName).getAdvancedCache();
if (cache == null) {
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
}
AvailabilityMode availability = cache.getAvailability();
return CompletableFuture.completedFuture(
invocationHelper.newResponse(request)
.entity(availability)
.contentType(TEXT_PLAIN)
.status(OK)
.build()
);
}
private CompletionStage<RestResponse> setCacheAvailability(RestRequest request) {
String cacheName = request.variables().get("cacheName");
String availability = request.getParameter("availability");
// Use EmbeddedCacheManager directly to allow internal caches to be updated
if (!invocationHelper.getRestCacheManager().getInstance().isRunning(cacheName))
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getInstance().getCache(cacheName).getAdvancedCache();
if (cache == null) {
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
}
try {
AvailabilityMode availabilityMode = AvailabilityMode.valueOf(availability.toUpperCase());
cache.setAvailability(availabilityMode);
return CompletableFuture.completedFuture(invocationHelper.newResponse(request).status(NO_CONTENT).build());
} catch (IllegalArgumentException e) {
return invocationHelper.newResponse(request, BAD_REQUEST, String.format("Unknown AvailabilityMode '%s'", availability)).toFuture();
}
}
private CompletionStage<RestResponse> getCacheConfigMutableAttributes(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
boolean full = Boolean.parseBoolean(request.getParameter("full"));
responseBuilder.contentType(APPLICATION_JSON);
if (!invocationHelper.getRestCacheManager().getInstance().getCacheConfigurationNames().contains(cacheName)) {
responseBuilder.status(NOT_FOUND).build();
}
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null)
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(cache.getAdvancedCache());
Map<String, Attribute> attributes = new LinkedHashMap<>();
mutableAttributes(cacheConfiguration, attributes, null);
if (full) {
Json all = Json.object();
for (Map.Entry<String, Attribute> entry : attributes.entrySet()) {
Attribute attribute = entry.getValue();
Class<?> type = attribute.getAttributeDefinition().getType();
Json object = Json.object("value", attribute.get(), "type", type.getSimpleName().toLowerCase());
if (type.isEnum()) {
object.set("universe", Arrays.stream(type.getEnumConstants()).map(Object::toString).collect(Collectors.toList()));
}
all.set(entry.getKey(), object);
}
return asJsonResponseFuture(invocationHelper.newResponse(request), all, isPretty(request));
} else {
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(attributes.keySet()), isPretty(request));
}
}
private static void mutableAttributes(ConfigurationElement<?> element, Map<String, Attribute> attributes, String prefix) {
if (prefix == null) {
prefix = "";
} else if (prefix.isEmpty()) {
prefix = element.elementName();
} else {
prefix = prefix + '.' + element.elementName();
}
for (Attribute<?> attribute : element.attributes().attributes()) {
if (!attribute.isImmutable()) {
AttributeDefinition<?> definition = attribute.getAttributeDefinition();
// even if mutable, we don't want expose this attribute to the user
if (AbstractTypedPropertiesConfiguration.PROPERTIES.equals(definition)) {
continue;
}
attributes.put(prefix + '.' + definition.name(), attribute);
}
}
for (ConfigurationElement<?> child : element.children()) {
mutableAttributes(child, attributes, prefix);
}
}
private CompletionStage<RestResponse> getCacheConfigMutableAttribute(RestRequest request) {
String attributeName = request.getParameter("attribute-name");
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null) {
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
}
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(cache.getAdvancedCache());
Attribute<?> attribute = cacheConfiguration.findAttribute(attributeName);
if (attribute.isImmutable()) {
throw Log.REST.immutableAttribute(attributeName);
} else {
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(String.valueOf(attribute.get())), isPretty(request));
}
}
private CompletionStage<RestResponse> setCacheConfigMutableAttribute(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String attributeName = request.getParameter("attribute-name");
String attributeValue = request.getParameter("attribute-value");
String cacheName = request.variables().get("cacheName");
Cache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null) {
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
}
Configuration configuration = new ConfigurationBuilder().read(SecurityActions.getCacheConfiguration(cache.getAdvancedCache())).build();
Attribute<?> attribute = configuration.findAttribute(attributeName);
invocationHelper.getRestCacheManager().getCacheManagerAdmin(request);
EmbeddedCacheManagerAdmin administration = invocationHelper.getRestCacheManager().getCacheManagerAdmin(request).withFlags(AdminFlag.UPDATE);
return CompletableFuture.supplyAsync(() -> {
attribute.fromString(attributeValue);
administration.getOrCreateCache(cacheName, configuration);
responseBuilder.status(OK);
return responseBuilder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getSize(RestRequest request) {
String cacheName = request.variables().get("cacheName");
AdvancedCache<Object, Object> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
boolean pretty = isPretty(request);
return cache.sizeAsync().thenApply(size -> asJsonResponse(invocationHelper.newResponse(request), Json.make(size), pretty));
}
private CompletionStage<RestResponse> getCacheNames(RestRequest request) throws RestResponseException {
Collection<String> cacheNames = invocationHelper.getRestCacheManager().getAccessibleCacheNames();
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(cacheNames), isPretty(request));
}
private CompletionStage<RestResponse> getCacheHealth(RestRequest request) throws RestResponseException {
String cacheName = request.variables().get("cacheName");
RestCacheManager<?> restCacheManager = invocationHelper.getRestCacheManager();
if (!restCacheManager.cacheExists(cacheName))
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
AdvancedCache<?, ?> cache = restCacheManager.getCache(cacheName, request);
ComponentRegistry cr = SecurityActions.getCacheComponentRegistry(cache);
return completedFuture(
invocationHelper.newResponse(request)
.contentType(TEXT_PLAIN)
.entity(new CacheHealthImpl(cr).getStatus().toString())
.status(OK)
.build()
);
}
private CompletionStage<RestResponse> setRebalancing(boolean enable, RestRequest request) {
String cacheName = request.variables().get("cacheName");
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
if (!restCacheManager.cacheExists(cacheName))
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
return CompletableFuture.supplyAsync(() -> {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
LocalTopologyManager ltm = SecurityActions.getGlobalComponentRegistry(restCacheManager.getInstance()).getLocalTopologyManager();
try {
ltm.setCacheRebalancingEnabled(cacheName, enable);
builder.status(NO_CONTENT);
} catch (Exception e) {
throw Util.unchecked(e);
}
return builder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> reinitializeCache(RestRequest request) {
boolean force = Boolean.parseBoolean(request.getParameter("force"));
NettyRestResponse.Builder builder = new NettyRestResponse.Builder();
EmbeddedCacheManager ecm = invocationHelper.getProtocolServer().getCacheManager();
if (!ecm.isCoordinator()) {
builder.status(BAD_REQUEST);
builder.entity(Json.make("Node not coordinator, request at " + ecm.getCoordinator()));
return CompletableFuture.completedFuture(builder.build());
}
GlobalComponentRegistry gcr = SecurityActions.getGlobalComponentRegistry(ecm);
ClusterTopologyManager ctm = gcr.getClusterTopologyManager();
LocalTopologyManager ltm = gcr.getLocalTopologyManager();
if (ctm == null || ltm == null) {
builder.status(BAD_REQUEST);
return CompletableFuture.completedFuture(builder.build());
}
builder.status(NO_CONTENT);
String cache = request.variables().get("cacheName");
InternalCacheRegistry internalRegistry = gcr.getComponent(InternalCacheRegistry.class);
if (ecm.isRunning(cache)) return CompletableFuture.completedFuture(builder.build());
if (internalRegistry.isInternalCache(cache)) return CompletableFuture.completedFuture(builder.build());
return CompletableFuture.supplyAsync(() -> {
if (!ctm.useCurrentTopologyAsStable(cache, force))
return CompletableFuture.completedFuture(builder.build());
// We wait for the topology to be installed.
return ltm.stableTopologyCompletion(cache)
.thenApply(ignore -> builder.build());
}, invocationHelper.getExecutor())
.thenCompose(Function.identity())
.thenApply(Function.identity());
}
private static class CacheFullDetail implements JsonSerialization {
public Stats stats;
public Integer size;
public String configuration;
public Boolean rehashInProgress;
public boolean bounded;
public boolean indexed;
public boolean persistent;
public boolean transactional;
public boolean secured;
public boolean hasRemoteBackup;
public Boolean indexingInProgress;
public boolean statistics;
public Boolean queryable;
public Boolean rebalancingEnabled;
public MediaType keyStorage;
public MediaType valueStorage;
@Override
public Json toJson() {
Json json = Json.object();
if (stats != null) {
json.set("stats", stats.toJson());
}
if (size != null) {
json.set("size", size);
}
if (rehashInProgress != null) {
json.set("rehash_in_progress", rehashInProgress);
}
if (indexingInProgress != null) {
json.set("indexing_in_progress", indexingInProgress);
}
if (queryable != null) {
json.set("queryable", queryable);
}
if (rebalancingEnabled != null) {
json.set("rebalancing_enabled", rebalancingEnabled);
}
return json
.set("configuration", Json.factory().raw(configuration))
.set("bounded", bounded)
.set("indexed", indexed)
.set("persistent", persistent)
.set("transactional", transactional)
.set("secured", secured)
.set("has_remote_backup", hasRemoteBackup)
.set("statistics", statistics)
.set("key_storage", keyStorage)
.set("value_storage", valueStorage);
}
}
public static abstract class BaseCacheListener {
protected final Cache<?, ?> cache;
protected final EventStream eventStream;
protected BaseCacheListener(Cache<?, ?> cache) {
this.cache = cache;
this.eventStream = new EventStream(null, () -> cache.removeListenerAsync(this));
}
public EventStream getEventStream() {
return eventStream;
}
@CacheEntryCreated
@CacheEntryModified
@CacheEntryRemoved
@CacheEntryExpired
public CompletionStage<Void> onCacheEvent(CacheEntryEvent<?, ?> event) {
ServerSentEvent sse = new ServerSentEvent(event.getType().name().toLowerCase().replace('_', '-'), new String((byte[]) event.getKey()));
return eventStream.sendEvent(sse);
}
}
@Listener(clustered = true, includeCurrentState = true)
public static class StatefulCacheListener extends BaseCacheListener {
public StatefulCacheListener(Cache<?, ?> cache) {
super(cache);
}
}
@Listener(clustered = true)
public static class StatelessCacheListener extends BaseCacheListener {
public StatelessCacheListener(Cache<?, ?> cache) {
super(cache);
}
}
}
| 57,320
| 51.157416
| 198
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/ClusterResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.HEAD;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponse;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.ConcurrentHashMap;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.util.Immutables;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.distribution.NodeDistributionInfo;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.BackupManager;
/**
* @since 10.0
*/
public class ClusterResource implements ResourceHandler {
private final InvocationHelper invocationHelper;
private final BackupManager backupManager;
public ClusterResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
this.backupManager = invocationHelper.getServer().getBackupManager();
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(POST).path("/v2/cluster").withAction("stop")
.permission(AuthorizationPermission.LIFECYCLE).name("CLUSTER STOP").auditContext(AuditContext.SERVER)
.handleWith(this::stop)
.invocation().method(GET).path("/v2/cluster").withAction("distribution")
.permission(AuthorizationPermission.MONITOR).name("CLUSTER DISTRIBUTION").auditContext(AuditContext.SERVER)
.handleWith(this::distribution)
.invocation().methods(GET, HEAD).path("/v2/cluster/backups")
.permission(AuthorizationPermission.ADMIN).name("BACKUP NAMES").auditContext(AuditContext.SERVER)
.handleWith(this::getAllBackupNames)
.invocation().methods(DELETE, GET, HEAD, POST).path("/v2/cluster/backups/{backupName}")
.permission(AuthorizationPermission.ADMIN).name("BACKUP").auditContext(AuditContext.SERVER)
.handleWith(this::backup)
.invocation().methods(GET).path("/v2/cluster/restores")
.permission(AuthorizationPermission.ADMIN).name("RESTORE NAMES").auditContext(AuditContext.SERVER)
.handleWith(this::getAllRestoreNames)
.invocation().methods(DELETE, HEAD, POST).path("/v2/cluster/restores/{restoreName}")
.permission(AuthorizationPermission.ADMIN).name("RESTORE").auditContext(AuditContext.SERVER)
.handleWith(this::restore)
.create();
}
private CompletionStage<RestResponse> stop(RestRequest request) {
return CompletableFuture.supplyAsync(() -> {
List<String> servers = request.parameters().get("server");
if (servers != null && !servers.isEmpty()) {
Security.doAs(request.getSubject(), () -> invocationHelper.getServer().serverStop(servers));
} else {
Security.doAs(request.getSubject(), () -> invocationHelper.getServer().clusterStop());
}
return invocationHelper.newResponse(request).status(NO_CONTENT).build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getAllBackupNames(RestRequest request) {
BackupManager backupManager = invocationHelper.getServer().getBackupManager();
Set<String> names = Security.doAs(request.getSubject(), backupManager::getBackupNames);
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(names), isPretty(request));
}
private CompletionStage<RestResponse> backup(RestRequest request) {
return BackupManagerResource.handleBackupRequest(invocationHelper, request, backupManager,
(name, workingDir, json) -> backupManager.create(name, workingDir));
}
private CompletionStage<RestResponse> getAllRestoreNames(RestRequest request) {
BackupManager backupManager = invocationHelper.getServer().getBackupManager();
Set<String> names = Security.doAs(request.getSubject(), backupManager::getRestoreNames);
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(names), isPretty(request));
}
private CompletionStage<RestResponse> restore(RestRequest request) {
return BackupManagerResource.handleRestoreRequest(invocationHelper, request, backupManager, (name, path, json) -> backupManager.restore(name, path));
}
private CompletionStage<RestResponse> distribution(RestRequest request) {
boolean pretty = isPretty(request);
return clusterDistribution()
.thenApply(distributions -> asJsonResponse(invocationHelper.newResponse(request), Json.array(distributions.stream()
.map(NodeDistributionInfo::toJson).toArray()), pretty));
}
private CompletionStage<List<NodeDistributionInfo>> clusterDistribution() {
EmbeddedCacheManager cacheManager = invocationHelper.getProtocolServer().getCacheManager();
List<Address> members = cacheManager.getMembers();
if (members == null) {
NodeDistributionInfo info = NodeDistributionInfo
.resolve(cacheManager.getCacheManagerInfo(), SecurityActions.getGlobalComponentRegistry(cacheManager));
return CompletableFuture.completedFuture(Collections.singletonList(info));
}
Map<Address, NodeDistributionInfo> distributions = new ConcurrentHashMap<>(members.size());
return SecurityActions.getClusterExecutor(cacheManager)
.submitConsumer(
ecm -> NodeDistributionInfo.resolve(ecm.getCacheManagerInfo(), SecurityActions.getGlobalComponentRegistry(ecm)),
(address, info, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
}
distributions.putIfAbsent(address, info);
})
.thenApply(ignore -> {
Collection<NodeDistributionInfo> collection = distributions.values();
return Immutables.immutableListWrap(collection.toArray(new NodeDistributionInfo[0]));
});
}
}
| 7,197
| 50.049645
| 155
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/ResourceUtil.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON;
import java.util.concurrent.CompletableFuture;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
/**
* Util class for REST resources.
*
* @author Ryan Emerson
* @since 11.0
*/
class ResourceUtil {
static NettyRestResponse.Builder addEntityAsJson(Json json, NettyRestResponse.Builder responseBuilder, boolean pretty) {
responseBuilder.contentType(APPLICATION_JSON);
return responseBuilder.entity(json.toString()).status(OK);
}
static RestResponse asJsonResponse(NettyRestResponse.Builder builder, Json json, boolean pretty) {
return addEntityAsJson(json, builder, pretty).build();
}
static CompletableFuture<RestResponse> asJsonResponseFuture(NettyRestResponse.Builder builder, Json json, boolean pretty) {
RestResponse response = addEntityAsJson(json, builder, pretty).build();
return completedFuture(response);
}
static NettyRestResponse.Builder addEntityAsJson(JsonSerialization o, NettyRestResponse.Builder responseBuilder) {
responseBuilder.contentType(APPLICATION_JSON);
return responseBuilder.entity(o.toJson().toString()).status(OK);
}
static boolean isPretty(RestRequest request) {
return Boolean.parseBoolean(request.getParameter("pretty"));
}
}
| 1,731
| 36.652174
| 126
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/MediaTypeUtils.java
|
package org.infinispan.rest.resources;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON;
import static org.infinispan.commons.dataconversion.MediaType.TEXT_PLAIN;
import java.util.Arrays;
import java.util.Optional;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.EncodingException;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.marshall.core.EncoderRegistry;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.logging.Log;
import org.infinispan.rest.operations.exceptions.UnacceptableDataFormatException;
/**
* since 10.0
*/
final class MediaTypeUtils {
private MediaTypeUtils() {
}
/**
* Negotiates the {@link MediaType} to be used during the request execution, restricting to some allowed types.
*
* @param restRequest the {@link RestRequest} with headers
* @param accepted the accepted MediaTypes
* @return one of the accepted MediaTypes if present in the 'Accept' header, or the first provided otherwise
*/
static MediaType negotiateMediaType(RestRequest restRequest, MediaType... accepted) {
String acceptHeader = restRequest.getAcceptHeader();
if (accepted.length == 0) throw new IllegalArgumentException("Accepted should be provided");
if (acceptHeader.equals(MediaType.MATCH_ALL_TYPE)) return accepted[0];
Optional<MediaType> found = MediaType.parseList(acceptHeader).filter(c -> Arrays.stream(accepted).anyMatch(m -> m.match(c))).findFirst();
return found.orElseThrow(() -> Log.REST.unsupportedDataFormat(acceptHeader));
}
/**
* Negotiates the {@link MediaType} to be used during the request execution
*
* @param cache the {@link AdvancedCache} associated with the request
* @param restRequest the {@link RestRequest} with the headers
* @return The negotiated MediaType
* @throws UnacceptableDataFormatException if no suitable {@link MediaType} could be found.
*/
static MediaType negotiateMediaType(AdvancedCache<?, ?> cache, EncoderRegistry registry, RestRequest restRequest) throws UnacceptableDataFormatException {
try {
String accept = restRequest.getAcceptHeader();
MediaType storageMedia = cache.getValueDataConversion().getStorageMediaType();
Optional<MediaType> negotiated = MediaType.parseList(accept)
.filter(media -> registry.isConversionSupported(storageMedia, media))
.findFirst();
return negotiated.map(m -> {
if (!m.matchesAll()) return m;
MediaType storageMediaType = cache.getValueDataConversion().getStorageMediaType();
if (storageMediaType == null) return m;
if (storageMediaType.equals(MediaType.APPLICATION_OBJECT)) return TEXT_PLAIN;
if (storageMediaType.match(MediaType.APPLICATION_PROTOSTREAM)) return APPLICATION_JSON;
return m;
}).orElseThrow(() -> Log.REST.unsupportedDataFormat(accept));
} catch (EncodingException e) {
throw new UnacceptableDataFormatException();
}
}
}
| 3,125
| 41.821918
| 157
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/BaseCacheResource.java
|
package org.infinispan.rest.resources;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.infinispan.rest.RequestHeader.EXTENDED_HEADER;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.resources.MediaTypeUtils.negotiateMediaType;
import java.util.Date;
import java.util.List;
import java.util.OptionalInt;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import org.infinispan.AdvancedCache;
import org.infinispan.Cache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.hash.MurmurHash3;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.metadata.Metadata;
import org.infinispan.rest.DateUtils;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.RestResponseException;
import org.infinispan.rest.cachemanager.RestCacheManager;
import org.infinispan.rest.configuration.RestServerConfiguration;
import org.infinispan.rest.distribution.CompleteKeyDistribution;
import org.infinispan.rest.framework.ContentSource;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.operations.CacheOperationsHelper;
import org.infinispan.rest.operations.exceptions.NoDataFoundException;
import org.infinispan.rest.operations.exceptions.NoKeyException;
import org.infinispan.rest.tracing.RestTelemetryService;
import org.infinispan.security.actions.SecurityActions;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* Handle basic cache operations.
*
* @since 10.0
*/
public class BaseCacheResource {
private static final MurmurHash3 hashFunc = MurmurHash3.getInstance();
final CacheResourceQueryAction queryAction;
final InvocationHelper invocationHelper;
private final RestTelemetryService telemetryService;
public BaseCacheResource(InvocationHelper invocationHelper, RestTelemetryService telemetryService) {
this.invocationHelper = invocationHelper;
this.queryAction = new CacheResourceQueryAction(invocationHelper);
this.telemetryService = telemetryService;
}
CompletionStage<RestResponse> deleteCacheValue(RestRequest request) throws RestResponseException {
Object span = telemetryService.requestStart("deleteCacheValue", request);
String cacheName = request.variables().get("cacheName");
Object key = getKey(request);
MediaType keyContentType = request.keyContentType();
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
AdvancedCache<Object, Object> cache = restCacheManager.getCache(cacheName, keyContentType, MediaType.MATCH_ALL, request);
CompletionStage<RestResponse> response = restCacheManager.getPrivilegedInternalEntry(cache, key, true).thenCompose(entry -> {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.status(HttpResponseStatus.NOT_FOUND);
if (entry instanceof InternalCacheEntry) {
InternalCacheEntry<Object, Object> ice = (InternalCacheEntry<Object, Object>) entry;
String etag = calcETAG(ice.getValue());
String clientEtag = request.getEtagIfNoneMatchHeader();
if (clientEtag == null || clientEtag.equals(etag)) {
responseBuilder.status(HttpResponseStatus.NO_CONTENT);
return restCacheManager.remove(cacheName, key, keyContentType, request).thenApply(v -> responseBuilder.build());
} else {
//ETags don't match, so preconditions failed
responseBuilder.status(HttpResponseStatus.PRECONDITION_FAILED);
}
}
return CompletableFuture.completedFuture(responseBuilder.build());
});
// Attach span events
response.whenComplete((result, exception) -> {
if (exception != null) {
telemetryService.recordException(span, exception);
}
telemetryService.requestEnd(span);
});
return response;
}
CompletionStage<RestResponse> putValueToCache(RestRequest request) {
Object span = telemetryService.requestStart("putValueToCache", request);
String cacheName = request.variables().get("cacheName");
MediaType contentType = request.contentType();
MediaType keyContentType = request.keyContentType();
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
AdvancedCache<Object, Object> cache = restCacheManager.getCache(cacheName, keyContentType, contentType, request);
Object key = getKey(request);
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request).status(HttpResponseStatus.NO_CONTENT);
ContentSource contents = request.contents();
if (contents == null) throw new NoDataFoundException();
Long ttl = request.getTimeToLiveSecondsHeader();
Long idle = request.getMaxIdleTimeSecondsHeader();
byte[] data = request.contents().rawContent();
CompletionStage<RestResponse> response = restCacheManager.getPrivilegedInternalEntry(cache, key, true).thenCompose(entry -> {
if (request.method() == POST && entry != null) {
return CompletableFuture.completedFuture(responseBuilder.status(HttpResponseStatus.CONFLICT).entity("An entry already exists").build());
}
if (entry instanceof InternalCacheEntry) {
InternalCacheEntry ice = (InternalCacheEntry) entry;
String etagNoneMatch = request.getEtagIfNoneMatchHeader();
if (etagNoneMatch != null) {
String etag = calcETAG(ice.getValue());
if (etagNoneMatch.equals(etag)) {
//client's and our ETAG match. Nothing to do, an entry is cached on the client side...
responseBuilder.status(HttpResponseStatus.NOT_MODIFIED);
return CompletableFuture.completedFuture(responseBuilder.build());
}
}
}
return putInCache(responseBuilder, cache, key, data, ttl, idle);
});
// Attach span events
response.whenComplete((result, exception) -> {
if (exception != null) {
telemetryService.recordException(span, exception);
}
telemetryService.requestEnd(span);
});
return response;
}
CompletionStage<RestResponse> clearEntireCache(RestRequest request) throws RestResponseException {
Object span = telemetryService.requestStart("clearEntireCache", request);
String cacheName = request.variables().get("cacheName");
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.status(HttpResponseStatus.NO_CONTENT);
Cache<Object, Object> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
CompletableFuture<RestResponse> response = cache.clearAsync().thenApply(v -> responseBuilder.build());
// Attach span events
response.whenComplete((result, exception) -> {
if (exception != null) {
telemetryService.recordException(span, exception);
}
telemetryService.requestEnd(span);
});
return response;
}
CompletionStage<RestResponse> getCacheValue(RestRequest request) throws RestResponseException {
String cacheName = request.variables().get("cacheName");
MediaType keyContentType = request.keyContentType();
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
MediaType requestedMediaType = negotiateMediaType(cache, invocationHelper.getEncoderRegistry(), request);
Object key = getKey(request);
String cacheControl = request.getCacheControlHeader();
boolean returnBody = request.method() == GET;
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
return restCacheManager.getInternalEntry(cacheName, key, keyContentType, requestedMediaType, request).thenApply(entry -> {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.status(HttpResponseStatus.NOT_FOUND);
if (entry instanceof InternalCacheEntry) {
InternalCacheEntry<Object, Object> ice = (InternalCacheEntry<Object, Object>) entry;
Long lastMod = CacheOperationsHelper.lastModified(ice);
Date expires = ice.canExpire() ? new Date(ice.getExpiryTime()) : null;
OptionalInt minFreshSeconds = CacheOperationsHelper.minFresh(cacheControl);
if (CacheOperationsHelper.entryFreshEnough(expires, minFreshSeconds)) {
Metadata meta = ice.getMetadata();
String etag = calcETAG(ice.getValue());
String ifNoneMatch = request.getEtagIfNoneMatchHeader();
String ifMatch = request.getEtagIfMatchHeader();
String ifUnmodifiedSince = request.getIfUnmodifiedSinceHeader();
String ifModifiedSince = request.getIfModifiedSinceHeader();
if (ifNoneMatch != null && ifNoneMatch.equals(etag)) {
return responseBuilder.status(HttpResponseStatus.NOT_MODIFIED).build();
}
if (ifMatch != null && !ifMatch.equals(etag)) {
return responseBuilder.status(HttpResponseStatus.PRECONDITION_FAILED).build();
}
if (DateUtils.ifUnmodifiedIsBeforeModificationDate(ifUnmodifiedSince, lastMod)) {
return responseBuilder.status(HttpResponseStatus.PRECONDITION_FAILED).build();
}
if (DateUtils.isNotModifiedSince(ifModifiedSince, lastMod)) {
return responseBuilder.status(HttpResponseStatus.NOT_MODIFIED).build();
}
Object value = ice.getValue();
MediaType configuredMediaType = restCacheManager.getValueConfiguredFormat(cacheName, request);
writeValue(value, requestedMediaType, configuredMediaType, responseBuilder, returnBody);
responseBuilder.status(HttpResponseStatus.OK)
.lastModified(lastMod)
.eTag(etag)
.cacheControl(CacheOperationsHelper.calcCacheControl(expires))
.expires(expires)
.timeToLive(meta.lifespan())
.maxIdle(meta.maxIdle())
.created(ice.getCreated())
.lastUsed(ice.getLastUsed());
List<String> extended = request.parameters().get(EXTENDED_HEADER.getValue());
RestServerConfiguration restServerConfiguration = invocationHelper.getConfiguration();
if (extended != null && extended.size() > 0 && CacheOperationsHelper.supportsExtendedHeaders(restServerConfiguration, extended.iterator().next())) {
responseBuilder.clusterPrimaryOwner(restCacheManager.getPrimaryOwner(cacheName, key, request))
.clusterBackupOwners(restCacheManager.getBackupOwners(cacheName, key, request))
.clusterNodeName(restCacheManager.getNodeName())
.clusterServerAddress(restCacheManager.getServerAddress());
}
}
}
return responseBuilder.build();
});
}
protected CompletionStage<CompleteKeyDistribution> keyDistribution(RestRequest request) {
String cacheName = request.variables().get("cacheName");
Object key = getKey(request);
RestCacheManager<Object> restCacheManager = invocationHelper.getRestCacheManager();
return restCacheManager.getKeyDistribution(cacheName, key, request);
}
private Object getKey(RestRequest request) {
Object keyRequest = request.variables().get("cacheKey");
if (keyRequest == null) throw new NoKeyException();
return keyRequest.toString().getBytes(UTF_8);
}
private void writeValue(Object value, MediaType requested, MediaType configuredMediaType, NettyRestResponse.Builder
responseBuilder, boolean returnBody) {
MediaType responseContentType;
if (!requested.matchesAll()) {
responseContentType = requested;
} else {
if (configuredMediaType == null) {
responseContentType = value instanceof byte[] ? MediaType.APPLICATION_OCTET_STREAM : MediaType.TEXT_PLAIN;
} else {
responseContentType = configuredMediaType;
}
}
responseBuilder.contentType(responseContentType);
if (returnBody) responseBuilder.entity(value);
}
private <V> String calcETAG(V value) {
return String.valueOf(hashFunc.hash(value));
}
private CompletionStage<RestResponse> putInCache(NettyRestResponse.Builder responseBuilder,
AdvancedCache<Object, Object> cache, Object key, byte[] data, Long ttl,
Long idleTime) {
Configuration config = SecurityActions.getCacheConfiguration(cache);
final Metadata metadata = CacheOperationsHelper.createMetadata(config, ttl, idleTime);
responseBuilder.header("etag", calcETAG(data));
CompletionStage<Object> stage;
// Indexing is still blocking - can be removed when https://issues.redhat.com/browse/ISPN-11731 is complete
if (config.indexing().enabled()) {
stage = CompletableFuture.supplyAsync(() -> cache.putAsync(key, data, metadata), invocationHelper.getExecutor())
.thenCompose(Function.identity());
} else {
stage = cache.putAsync(key, data, metadata);
}
return stage.thenApply(o -> responseBuilder.build());
}
}
| 14,030
| 45.614618
| 163
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/LoggingResource.java
|
package org.infinispan.rest.resources;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.PUT;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.concurrent.CompletionStage;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.tasks.TaskContext;
import org.infinispan.tasks.TaskManager;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* Logging configuration resource. This resource is log4j 2.x-specific
*
* @author tristan@infinispan.org
* @since 11.0
*/
public final class LoggingResource implements ResourceHandler {
private final InvocationHelper invocationHelper;
public LoggingResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(GET).path("/v2/logging/loggers").handleWith(this::listLoggers)
.invocation().methods(GET).path("/v2/logging/appenders").handleWith(this::listAppenders)
.invocation().methods(DELETE).path("/v2/logging/loggers/{loggerName}").handleWith(this::deleteLogger)
.invocation().methods(PUT).path("/v2/logging/loggers/{loggerName}").handleWith(this::setLogger)
.invocation().methods(PUT).path("/v2/logging/loggers").handleWith(this::setLogger)
.create();
}
private CompletionStage<RestResponse> setLogger(RestRequest request) {
TaskManager taskManager = invocationHelper.getServer().getTaskManager();
String loggerName = request.variables().get("loggerName");
String level = request.getParameter("level");
List<String> appenders = request.parameters().get("appender");
if (level == null && appenders == null) {
throw Log.REST.missingArguments("level", "appender");
}
return taskManager.runTask("@@logging@set",
new TaskContext()
.addOptionalParameter("loggerName", loggerName)
.addOptionalParameter("level", level)
.addOptionalParameter("appenders", appenders)
.subject(request.getSubject())
).handle((o, t) -> handle(request, t));
}
private CompletionStage<RestResponse> deleteLogger(RestRequest request) {
TaskManager taskManager = invocationHelper.getServer().getTaskManager();
String loggerName = request.variables().get("loggerName");
return taskManager.runTask("@@logging@remove",
new TaskContext()
.addParameter("loggerName", loggerName)
.subject(request.getSubject())
).handle((o, t) -> handle(request, t));
}
private CompletionStage<RestResponse> listLoggers(RestRequest request) {
// We only return loggers declared in the configuration
LoggerContext logContext = (LoggerContext) LogManager.getContext(false);
Json loggerConfigs = jsonLoggerConfigs(logContext.getConfiguration().getLoggers().values());
return asJsonResponseFuture(invocationHelper.newResponse(request), loggerConfigs, isPretty(request));
}
private Json jsonLoggerConfigs(Collection<LoggerConfig> loggerConfigs) {
Json array = Json.array();
for (LoggerConfig loggerConfig : loggerConfigs) {
Json jsonLoggerConfig = Json.object();
jsonLoggerConfig.set("name", loggerConfig.getName());
jsonLoggerConfig.set("level", loggerConfig.getLevel().toString());
jsonLoggerConfig.set("appenders", Json.make(loggerConfig.getAppenders().keySet()));
array.add(jsonLoggerConfig);
}
return array;
}
private CompletionStage<RestResponse> listAppenders(RestRequest request) {
LoggerContext logContext = (LoggerContext) LogManager.getContext(false);
Map<String, Appender> appendersMap = logContext.getConfiguration().getAppenders();
Json jsonMap = Json.object();
appendersMap.forEach((key, value) -> jsonMap.set(key, Json.object().set("name", value.getName())));
return asJsonResponseFuture(invocationHelper.newResponse(request), jsonMap, isPretty(request));
}
private NettyRestResponse handle(RestRequest request, Throwable t) {
NettyRestResponse.Builder response = invocationHelper.newResponse(request);
if (t == null) {
response.status(HttpResponseStatus.NO_CONTENT);
} else {
while (t.getCause() != null) {
t = t.getCause();
}
if (t instanceof IllegalStateException) {
response.status(HttpResponseStatus.CONFLICT).entity(t.getMessage());
} else if (t instanceof IllegalArgumentException) {
response.status(HttpResponseStatus.BAD_REQUEST).entity(t.getMessage());
} else if (t instanceof NoSuchElementException) {
response.status(HttpResponseStatus.NOT_FOUND).entity(t.getMessage());
} else if (t instanceof SecurityException) {
response.status(HttpResponseStatus.FORBIDDEN).entity(t.getMessage());
} else {
response.status(HttpResponseStatus.INTERNAL_SERVER_ERROR).entity(t.getMessage());
}
}
return response.build();
}
}
| 6,046
| 44.466165
| 113
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/SearchAdminResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.MULTIPLE_CHOICES;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponse;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.query.Indexer;
import org.infinispan.query.Search;
import org.infinispan.query.core.stats.SearchStatistics;
import org.infinispan.query.core.stats.SearchStatisticsSnapshot;
import org.infinispan.query.impl.ComponentRegistryUtils;
import org.infinispan.query.impl.InfinispanQueryStatisticsInfo;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.search.mapper.mapping.SearchMapping;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.util.logging.LogFactory;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* @since 10.1
*/
public class SearchAdminResource implements ResourceHandler {
private final static Log LOG = LogFactory.getLog(SearchAdminResource.class, Log.class);
private final InvocationHelper invocationHelper;
public SearchAdminResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(POST).path("/v2/caches/{cacheName}/search/indexes").deprecated().withAction("mass-index").handleWith(this::reindex)
.invocation().methods(POST).path("/v2/caches/{cacheName}/search/indexes").withAction("reindex").handleWith(this::reindex)
.invocation().methods(POST).path("/v2/caches/{cacheName}/search/indexes").withAction("updateSchema").handleWith(this::updateSchema)
.invocation().methods(POST).path("/v2/caches/{cacheName}/search/indexes").withAction("clear").handleWith(this::clearIndexes)
.invocation().methods(GET).path("/v2/caches/{cacheName}/search/indexes/metamodel").handleWith(this::indexMetamodel)
.invocation().methods(GET).path("/v2/caches/{cacheName}/search/indexes/stats").deprecated().handleWith(this::indexStats)
.invocation().methods(GET).path("/v2/caches/{cacheName}/search/query/stats").deprecated().handleWith(this::queryStats)
.invocation().methods(POST).path("/v2/caches/{cacheName}/search/query/stats").deprecated().withAction("clear").handleWith(this::clearStats)
.invocation().methods(GET).path("/v2/caches/{cacheName}/search/stats").handleWith(this::searchStats)
.invocation().methods(POST).path("/v2/caches/{cacheName}/search/stats").withAction("clear").handleWith(this::clearSearchStats)
.create();
}
private CompletionStage<RestResponse> searchStats(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null) {
responseBuilder.status(HttpResponseStatus.NOT_FOUND);
return null;
}
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(cache);
if (!cacheConfiguration.statistics().enabled()) {
responseBuilder.status(NOT_FOUND).build();
}
String scopeParam = request.getParameter("scope");
boolean pretty = isPretty(request);
if (scopeParam != null && scopeParam.equalsIgnoreCase("cluster")) {
CompletionStage<SearchStatisticsSnapshot> stats = Search.getClusteredSearchStatistics(cache);
return stats.thenApply(s -> asJsonResponse(invocationHelper.newResponse(request), s.toJson(), pretty));
} else {
return Search.getSearchStatistics(cache).computeSnapshot().thenApply(s -> asJsonResponse(invocationHelper.newResponse(request), s.toJson(), pretty));
}
}
private CompletionStage<RestResponse> clearSearchStats(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String cacheName = request.variables().get("cacheName");
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null) {
responseBuilder.status(HttpResponseStatus.NOT_FOUND);
return null;
}
Configuration cacheConfiguration = cache.getCacheConfiguration();
if (!cacheConfiguration.statistics().enabled()) {
return completedFuture(responseBuilder.status(NOT_FOUND.code()).build());
}
String scopeParam = request.getParameter("scope");
//TODO: cluster clear
if (scopeParam != null && scopeParam.equalsIgnoreCase("cluster")) {
throw new CacheException("NotImplemented");
} else {
SearchStatistics searchStatistics = Search.getSearchStatistics(cache);
Security.doAs(request.getSubject(), () -> searchStatistics.getQueryStatistics().clear());
return completedFuture(responseBuilder.build());
}
}
private CompletionStage<RestResponse> reindex(RestRequest request) {
boolean local = Boolean.parseBoolean(request.getParameter("local"));
return runIndexer(request, s -> local ? s.runLocal() : s.run(), true);
}
private CompletionStage<RestResponse> clearIndexes(RestRequest request) {
return runIndexer(request, Indexer::remove, false);
}
private CompletionStage<RestResponse> updateSchema(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
AdvancedCache<?, ?> cache = lookupIndexedCache(request, responseBuilder);
int status = responseBuilder.getStatus();
if (status < OK.code() || status >= MULTIPLE_CHOICES.code()) {
return completedFuture(responseBuilder.build());
}
responseBuilder.status(NO_CONTENT);
try {
SearchMapping searchMapping = ComponentRegistryUtils.getSearchMapping(cache);
searchMapping.restart();
} catch (Exception e) {
throw Util.unchecked(e);
}
return CompletableFuture.completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> indexMetamodel(RestRequest request) {
NettyRestResponse.Builder responseBuilder = new NettyRestResponse.Builder();
AdvancedCache<?, ?> cache = lookupIndexedCache(request, responseBuilder);
int status = responseBuilder.getStatus();
if (status < OK.code() || status >= MULTIPLE_CHOICES.code()) {
return completedFuture(responseBuilder.build());
}
SearchMapping searchMapping = ComponentRegistryUtils.getSearchMapping(cache);
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(searchMapping.metamodel().values()), isPretty(request));
}
private CompletionStage<RestResponse> indexStats(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
boolean pretty = isPretty(request);
InfinispanQueryStatisticsInfo searchStats = lookupQueryStatistics(request, responseBuilder);
if (searchStats == null) return completedFuture(responseBuilder.build());
return searchStats.computeLegacyIndexStatistics().thenApply(json -> asJsonResponse(responseBuilder, json, pretty));
}
private CompletionStage<RestResponse> queryStats(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
InfinispanQueryStatisticsInfo searchStats = lookupQueryStatistics(request, responseBuilder);
if (searchStats == null) return completedFuture(responseBuilder.build());
return asJsonResponseFuture(invocationHelper.newResponse(request), searchStats.getLegacyQueryStatistics(), isPretty(request));
}
private CompletionStage<RestResponse> clearStats(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
InfinispanQueryStatisticsInfo queryStatistics = lookupQueryStatistics(request, responseBuilder);
if (queryStatistics == null) return completedFuture(responseBuilder.build());
responseBuilder.status(NO_CONTENT);
queryStatistics.clear();
return completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> runIndexer(RestRequest request,
Function<Indexer, CompletionStage<Void>> op,
boolean supportAsync) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
List<String> mode = request.parameters().get("mode");
boolean asyncParams = mode != null && !mode.isEmpty() && mode.iterator().next().equalsIgnoreCase("async");
boolean async = asyncParams && supportAsync;
AdvancedCache<?, ?> cache = lookupIndexedCache(request, responseBuilder);
int status = responseBuilder.getStatus();
if (status < OK.code() || status >= MULTIPLE_CHOICES.code()) {
return completedFuture(responseBuilder.build());
}
responseBuilder.status(NO_CONTENT);
Indexer indexer = ComponentRegistryUtils.getIndexer(cache);
if (async) {
try {
LOG.asyncMassIndexerStarted();
op.apply(indexer).whenComplete((v, e) -> {
if (e == null) {
LOG.asyncMassIndexerSuccess();
} else {
LOG.errorExecutingMassIndexer(e.getCause());
}
});
} catch (Exception e) {
Util.unchecked(e);
}
return CompletableFuture.completedFuture(responseBuilder.build());
}
return op.apply(indexer).thenApply(v -> responseBuilder.build());
}
private AdvancedCache<?, ?> lookupIndexedCache(RestRequest request, NettyRestResponse.Builder builder) {
String cacheName = request.variables().get("cacheName");
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(cacheName, request);
if (cache == null) {
builder.status(HttpResponseStatus.NOT_FOUND);
return null;
}
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(cache);
if (!cacheConfiguration.indexing().enabled()) {
throw Log.REST.cacheNotIndexed(cacheName);
}
return cache;
}
private AdvancedCache<?, ?> lookupCacheWithStats(RestRequest request, NettyRestResponse.Builder builder) {
AdvancedCache<?, ?> cache = lookupIndexedCache(request, builder);
if (cache != null) {
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(cache);
if (!cacheConfiguration.statistics().enabled()) {
throw Log.REST.statisticsNotEnabled(cache.getName());
}
}
return cache;
}
private InfinispanQueryStatisticsInfo lookupQueryStatistics(RestRequest request, NettyRestResponse.Builder builder) {
AdvancedCache<?, ?> cache = lookupCacheWithStats(request, builder);
if (builder.getStatus() != HttpResponseStatus.OK.code()) {
return null;
}
return ComponentRegistryUtils.getQueryStatistics(cache);
}
}
| 12,488
| 45.600746
| 158
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/ServerResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.CONFLICT;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static io.netty.handler.codec.http.HttpResponseStatus.SERVICE_UNAVAILABLE;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_XML;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_YAML;
import static org.infinispan.commons.dataconversion.MediaType.TEXT_PLAIN;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.resources.MediaTypeUtils.negotiateMediaType;
import static org.infinispan.rest.resources.ResourceUtil.addEntityAsJson;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponse;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Connection;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.Map;
import java.util.LinkedHashMap;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.Executor;
import javax.sql.DataSource;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.configuration.attributes.Attribute;
import org.infinispan.commons.configuration.attributes.AttributeDefinition;
import org.infinispan.commons.configuration.attributes.ConfigurationElement;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
import org.infinispan.commons.io.StringBuilderWriter;
import org.infinispan.commons.util.ByRef;
import org.infinispan.commons.util.JVMMemoryInfoInfo;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.Version;
import org.infinispan.commons.util.concurrent.CompletableFutures;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.factories.GlobalComponentRegistry;
import org.infinispan.factories.impl.BasicComponentRegistry;
import org.infinispan.manager.CacheManagerInfo;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.remoting.transport.Address;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.rest.logging.Messages;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.server.core.ProtocolServer;
import org.infinispan.server.core.ServerManagement;
import org.infinispan.server.core.ServerStateManager;
import org.infinispan.server.core.transport.IpSubnetFilterRule;
import org.infinispan.server.core.transport.Transport;
import io.netty.handler.ipfilter.IpFilterRuleType;
/**
* @since 10.0
*/
public class ServerResource implements ResourceHandler {
private final InvocationHelper invocationHelper;
private static final ServerInfo SERVER_INFO = new ServerInfo();
private final Executor blockingExecutor;
public ServerResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
this.blockingExecutor = invocationHelper.getExecutor();
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(GET).path("/v2/server/")
.handleWith(this::info)
.invocation().methods(GET).path("/v2/server/config")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::config)
.invocation().methods(GET).path("/v2/server/env")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::env)
.invocation().methods(GET).path("/v2/server/memory")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::memory)
.invocation().methods(POST).path("/v2/server/memory").withAction("heap-dump")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::heapDump)
.invocation().methods(POST).path("/v2/server/").withAction("stop")
.permission(AuthorizationPermission.ADMIN)
.handleWith(this::stop)
.invocation().methods(GET).path("/v2/server/threads")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::threads)
.invocation().methods(GET).path("/v2/server/report")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER)
.handleWith(this::report)
.invocation().methods(GET).path("/v2/server/report/{nodeName}")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER)
.handleWith(this::nodeReport)
.invocation().methods(GET).path("/v2/server/cache-managers")
.handleWith(this::cacheManagers)
.invocation().methods(GET).path("/v2/server/ignored-caches/{cache-manager}")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER).handleWith(this::listIgnored)
.invocation().methods(POST, DELETE).path("/v2/server/ignored-caches/{cache-manager}/{cache}")
.permission(AuthorizationPermission.ADMIN).auditContext(AuditContext.SERVER)
.handleWith(this::doIgnoreOp)
.invocation().methods(GET).path("/v2/server/connections")
.permission(AuthorizationPermission.ADMIN).name("CONNECTION LIST").auditContext(AuditContext.SERVER)
.handleWith(this::listConnections)
.invocation().methods(GET).path("/v2/server/connectors")
.permission(AuthorizationPermission.ADMIN).name("CONNECTOR LIST").auditContext(AuditContext.SERVER)
.handleWith(this::listConnectors)
.invocation().methods(GET).path("/v2/server/connectors/{connector}")
.permission(AuthorizationPermission.ADMIN).name("CONNECTOR GET").auditContext(AuditContext.SERVER)
.handleWith(this::connectorStatus)
.invocation().methods(POST).path("/v2/server/connectors/{connector}").withAction("start")
.permission(AuthorizationPermission.ADMIN).name("CONNECTOR START").auditContext(AuditContext.SERVER)
.handleWith(this::connectorStartStop)
.invocation().methods(POST).path("/v2/server/connectors/{connector}").withAction("stop")
.permission(AuthorizationPermission.ADMIN).name("CONNECTOR STOP").auditContext(AuditContext.SERVER)
.handleWith(this::connectorStartStop)
.invocation().methods(GET).path("/v2/server/connectors/{connector}/ip-filter")
.permission(AuthorizationPermission.ADMIN).name("CONNECTOR FILTER GET").auditContext(AuditContext.SERVER)
.handleWith(this::connectorIpFilterList)
.invocation().methods(POST).path("/v2/server/connectors/{connector}/ip-filter")
.permission(AuthorizationPermission.ADMIN).name("CONNECTOR FILTER SET").auditContext(AuditContext.SERVER)
.handleWith(this::connectorIpFilterSet)
.invocation().methods(DELETE).path("/v2/server/connectors/{connector}/ip-filter")
.permission(AuthorizationPermission.ADMIN).name("CONNECTOR FILTER DELETE").auditContext(AuditContext.SERVER)
.handleWith(this::connectorIpFilterClear)
.invocation().methods(GET).path("/v2/server/datasources")
.permission(AuthorizationPermission.ADMIN).name("DATASOURCE LIST").auditContext(AuditContext.SERVER)
.handleWith(this::dataSourceList)
.invocation().methods(POST).path("/v2/server/datasources/{datasource}").withAction("test")
.permission(AuthorizationPermission.ADMIN).name("DATASOURCE TEST").auditContext(AuditContext.SERVER)
.handleWith(this::dataSourceTest)
.invocation().methods(GET).path("/v2/server/caches/defaults").handleWith(this::getCacheConfigDefaultAttributes)
.create();
}
private CompletionStage<RestResponse> doIgnoreOp(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request).status(NO_CONTENT);
boolean add = request.method().equals(POST);
String cacheManagerName = request.variables().get("cache-manager");
DefaultCacheManager cacheManager = invocationHelper.getServer().getCacheManager(cacheManagerName);
if (cacheManager == null) return completedFuture(builder.status(NOT_FOUND).build());
String cacheName = request.variables().get("cache");
if (!cacheManager.getCacheNames().contains(cacheName)) {
return completedFuture(builder.status(NOT_FOUND).build());
}
ServerManagement server = invocationHelper.getServer();
ServerStateManager ignoreManager = server.getServerStateManager();
return Security.doAs(request.getSubject(), () -> add ? ignoreManager.ignoreCache(cacheName) : ignoreManager.unignoreCache(cacheName))
.thenApply(r -> builder.build());
}
private CompletionStage<RestResponse> listIgnored(RestRequest request) {
String cacheManagerName = request.variables().get("cache-manager");
DefaultCacheManager cacheManager = invocationHelper.getServer().getCacheManager(cacheManagerName);
if (cacheManager == null) return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
ServerStateManager serverStateManager = invocationHelper.getServer().getServerStateManager();
Set<String> ignored = serverStateManager.getIgnoredCaches();
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(ignored), isPretty(request));
}
private CompletionStage<RestResponse> cacheManagers(RestRequest request) {
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(invocationHelper.getServer().cacheManagerNames()), isPretty(request));
}
private CompletionStage<RestResponse> connectorStartStop(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request).status(NO_CONTENT);
String connectorName = request.variables().get("connector");
ProtocolServer<?> connector = invocationHelper.getServer().getProtocolServers().get(connectorName);
if (connector == null) return completedFuture(builder.status(NOT_FOUND).build());
ServerStateManager serverStateManager = invocationHelper.getServer().getServerStateManager();
switch (request.getAction()) {
case "start":
return Security.doAs(request.getSubject(), () ->
serverStateManager.connectorStart(connectorName).thenApply(r -> builder.build()));
case "stop":
if (connector.equals(invocationHelper.getProtocolServer()) || connector.equals(invocationHelper.getProtocolServer().getEnclosingProtocolServer())) {
return completedFuture(builder.status(CONFLICT).entity(Messages.MSG.connectorMatchesRequest(connectorName)).build());
} else {
return Security.doAs(request.getSubject(), () ->
serverStateManager.connectorStop(connectorName).thenApply(r -> builder.build()));
}
}
throw Log.REST.unknownAction(request.getAction());
}
private CompletionStage<RestResponse> connectorStatus(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
String connectorName = request.variables().get("connector");
ProtocolServer<?> connector = getProtocolServer(request);
if (connector == null) return completedFuture(builder.status(NOT_FOUND).build());
ServerStateManager serverStateManager = invocationHelper.getServer().getServerStateManager();
Json info = Json.object()
.set("name", connectorName)
.set("ip-filter-rules", ipFilterRulesAsJson(connector))
.set("default-cache", connector.getConfiguration().defaultCacheName());
Transport transport = connector.getTransport();
CompletableFuture<Integer> globalConnections;
if (transport != null) {
info.set("host", transport.getHostName())
.set("port", transport.getPort())
.set("local-connections", transport.getNumberOfLocalConnections())
.set("io-threads", transport.getNumberIOThreads())
.set("pending-tasks", transport.getPendingTasks())
.set("total-bytes-read", transport.getTotalBytesRead())
.set("total-bytes-written", transport.getTotalBytesWritten())
.set("send-buffer-size", transport.getSendBufferSize())
.set("receive-buffer-size", transport.getReceiveBufferSize());
globalConnections = CompletableFuture.supplyAsync(transport::getNumberOfGlobalConnections, invocationHelper.getExecutor());
} else {
globalConnections = CompletableFutures.completedNull();
}
CompletableFuture<Boolean> connectorStatus = Security.doAs(request.getSubject(), () -> serverStateManager.connectorStatus(connectorName));
return connectorStatus.thenCombine(globalConnections, (cs, gc) -> {
info.set("enabled", cs);
if (gc != null) {
info.set("global-connections", gc);
}
return builder.contentType(APPLICATION_JSON).entity(info).build();
});
}
private CompletionStage<RestResponse> connectorIpFilterList(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
ProtocolServer<?> connector = getProtocolServer(request);
if (connector == null) return completedFuture(builder.status(NOT_FOUND).build());
return completedFuture(addEntityAsJson(ipFilterRulesAsJson(connector), builder, isPretty(request)).build());
}
private Json ipFilterRulesAsJson(ProtocolServer<?> connector) {
Collection<IpSubnetFilterRule> rules = connector.getConfiguration().ipFilter().rules();
Json array = Json.array();
for (IpSubnetFilterRule rule : rules) {
array.add(Json.object().set("type", rule.ruleType().name().toLowerCase()).set("from", rule.cidr()));
}
return array;
}
private ProtocolServer<?> getProtocolServer(RestRequest restRequest) {
String connectorName = restRequest.variables().get("connector");
return invocationHelper.getServer().getProtocolServers().get(connectorName);
}
private CompletionStage<RestResponse> listConnections(RestRequest request) {
boolean global = Boolean.parseBoolean(request.getParameter("global"));
if (global) {
List<Json> results = Collections.synchronizedList(new ArrayList<>());
return SecurityActions.getClusterExecutor(invocationHelper.getProtocolServer().getCacheManager())
.submitConsumer(
ecm -> {
GlobalComponentRegistry gcr = SecurityActions.getGlobalComponentRegistry(ecm);
BasicComponentRegistry bcr = gcr.getComponent(BasicComponentRegistry.class);
ServerStateManager ssm = bcr.getComponent(ServerStateManager.class).wired();
return CompletableFutures.uncheckedAwait(ssm.listConnections()).toString();
}, (ignore, s, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
} else {
results.add(Json.read(s));
}
})
.thenApply(ignore -> {
Json all = Json.array();
for (Json result : results) {
for (Json c : result.asJsonList()) {
all.add(c);
}
}
return asJsonResponse(invocationHelper.newResponse(request), all, isPretty(request));
});
} else {
ServerStateManager serverStateManager = invocationHelper.getServer().getServerStateManager();
return serverStateManager.listConnections().thenApply(j -> asJsonResponse(invocationHelper.newResponse(request), j, isPretty(request)));
}
}
private CompletionStage<RestResponse> connectorIpFilterClear(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request).status(NO_CONTENT);
String connectorName = request.variables().get("connector");
ProtocolServer<?> connector = invocationHelper.getServer().getProtocolServers().get(connectorName);
if (connector == null) return completedFuture(builder.status(NOT_FOUND).build());
ServerStateManager serverStateManager = invocationHelper.getServer().getServerStateManager();
return Security.doAs(request.getSubject(), () -> serverStateManager.clearConnectorIpFilterRules(connectorName).thenApply(r -> builder.build()));
}
private CompletionStage<RestResponse> listConnectors(RestRequest request) {
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(invocationHelper.getServer().getProtocolServers().keySet()), isPretty(request));
}
private CompletionStage<RestResponse> connectorIpFilterSet(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request).status(NO_CONTENT);
String connectorName = request.variables().get("connector");
ProtocolServer<?> connector = invocationHelper.getServer().getProtocolServers().get(connectorName);
if (connector == null) return completedFuture(builder.status(NOT_FOUND).build());
Json json = Json.read(request.contents().asString());
if (!json.isArray()) {
throw Log.REST.invalidContent();
}
List<Json> list = json.asJsonList();
List<IpSubnetFilterRule> rules = new ArrayList<>(list.size());
for (Json o : list) {
if (!o.has("type") || !o.has("cidr")) {
throw Log.REST.missingArguments("type", "cidr");
} else {
rules.add(new IpSubnetFilterRule(o.at("cidr").asString(), IpFilterRuleType.valueOf(o.at("type").asString())));
}
}
// Verify that none of the REJECT rules match the address from which the request was made
if (connector.equals(invocationHelper.getProtocolServer()) || connector.equals(invocationHelper.getProtocolServer().getEnclosingProtocolServer())) {
InetSocketAddress remoteAddress = request.getRemoteAddress();
for (IpSubnetFilterRule rule : rules) {
if (rule.ruleType() == IpFilterRuleType.REJECT && rule.matches(remoteAddress)) {
return completedFuture(builder.status(CONFLICT).entity(Messages.MSG.rejectRuleMatchesRequestAddress(rule, remoteAddress)).build());
}
}
}
ServerStateManager serverStateManager = invocationHelper.getServer().getServerStateManager();
return Security.doAs(request.getSubject(), () -> serverStateManager.setConnectorIpFilterRule(connectorName, rules).thenApply(r -> builder.build()));
}
private CompletionStage<RestResponse> memory(RestRequest request) {
return asJsonResponseFuture(invocationHelper.newResponse(request), new JVMMemoryInfoInfo().toJson(), isPretty(request));
}
private CompletionStage<RestResponse> heapDump(RestRequest request) {
boolean live = Boolean.parseBoolean(request.getParameter("live"));
boolean pretty = isPretty(request);
ServerManagement server = invocationHelper.getServer();
return CompletableFuture.supplyAsync(() -> {
try {
Path dumpFile = Files.createTempFile(server.getServerDataPath(), "dump", ".hprof");
Files.delete(dumpFile);
new JVMMemoryInfoInfo().heapDump(dumpFile, live);
return asJsonResponse(invocationHelper.newResponse(request), Json.object().set("filename", dumpFile.getFileName().toString()), pretty);
} catch (IOException e) {
throw Log.REST.heapDumpFailed(e);
}
}, blockingExecutor);
}
private CompletionStage<RestResponse> env(RestRequest request) {
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(System.getProperties()), isPretty(request));
}
private CompletionStage<RestResponse> info(RestRequest request) {
return asJsonResponseFuture(invocationHelper.newResponse(request), SERVER_INFO.toJson(), isPretty(request));
}
private CompletionStage<RestResponse> threads(RestRequest request) {
return completedFuture(invocationHelper.newResponse(request)
.contentType(TEXT_PLAIN).entity(Util.threadDump())
.build());
}
private CompletionStage<RestResponse> report(RestRequest request) {
ServerManagement server = invocationHelper.getServer();
return Security.doAs(request.getSubject(), () -> server.getServerReport().handle((path, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
}
return createReportResponse(request, path.toFile(), invocationHelper.getRestCacheManager().getNodeName());
})
);
}
private RestResponse createReportResponse(RestRequest request, Object report, String filename) {
return invocationHelper.newResponse(request)
.contentType(MediaType.fromString("application/gzip"))
.header("Content-Disposition",
String.format("attachment; filename=\"%s-%s-%3$tY%3$tm%3$td%3$tH%3$tM%3$tS-report.tar.gz\"",
Version.getBrandName().toLowerCase().replaceAll("\\s", "-"),
filename,
Calendar.getInstance())
)
.entity(report)
.build();
}
private CompletionStage<RestResponse> nodeReport(RestRequest request) {
String targetName = request.variables().get("nodeName");
EmbeddedCacheManager cacheManager = invocationHelper.getProtocolServer().getCacheManager();
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
List<Address> members = cacheManager.getMembers();
if (invocationHelper.getRestCacheManager().getNodeName().equals(targetName)) {
return report(request);
}
if (members == null) {
return CompletableFuture.completedFuture(responseBuilder.status(NOT_FOUND).build());
}
ByRef<byte[]> response = new ByRef<>(null);
return SecurityActions.getClusterExecutor(cacheManager)
.submitConsumer(ecm -> {
CacheManagerInfo cmi = ecm.getCacheManagerInfo();
if (!cmi.getNodeName().equals(targetName)) return null;
GlobalComponentRegistry gcr = SecurityActions.getGlobalComponentRegistry(ecm);
BasicComponentRegistry bcr = gcr.getComponent(BasicComponentRegistry.class);
ServerStateManager ssm = bcr.getComponent(ServerStateManager.class).wired();
Path reportPath = CompletableFutures.uncheckedAwait(ssm.managedServer().getServerReport().toCompletableFuture());
try {
return Files.readAllBytes(reportPath);
} catch (IOException e) {
throw new CacheException(String.format("Failed reading '%s' at node '%s'", reportPath, targetName), e);
}
}, (ignore, info, t) -> {
if (t != null) {
throw CompletableFutures.asCompletionException(t);
}
if (info != null) {
response.set(info);
}
})
.thenApply(ignore -> {
byte[] report = response.get();
if (report == null) {
return responseBuilder.status(NOT_FOUND).build();
}
return createReportResponse(request, report, targetName);
});
}
private CompletionStage<RestResponse> stop(RestRequest request) {
return CompletableFuture.supplyAsync(() -> {
Security.doAs(request.getSubject(), () -> invocationHelper.getServer().serverStop(Collections.emptyList()));
return invocationHelper.newResponse(request)
.status(NO_CONTENT).build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> config(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
MediaType accept = negotiateMediaType(request, APPLICATION_JSON, APPLICATION_XML, APPLICATION_YAML);
responseBuilder.contentType(accept);
boolean pretty = Boolean.parseBoolean(request.getParameter("pretty"));
StringBuilderWriter sw = new StringBuilderWriter();
try (ConfigurationWriter w = ConfigurationWriter.to(sw).withType(accept).prettyPrint(pretty).build()) {
invocationHelper.getServer().serializeConfiguration(w);
}
responseBuilder.entity(sw.toString());
return CompletableFuture.completedFuture(responseBuilder.build());
}
private CompletionStage<RestResponse> dataSourceList(RestRequest request) {
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(invocationHelper.getServer().getDataSources().keySet()), isPretty(request));
}
private CompletionStage<RestResponse> dataSourceTest(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
String name = request.variables().get("datasource");
DataSource dataSource = invocationHelper.getServer().getDataSources().get(name);
if (dataSource == null) return completedFuture(builder.status(NOT_FOUND).build());
return CompletableFuture.supplyAsync(() -> {
try (Connection connection = dataSource.getConnection()) {
if (connection.isValid(0)) {
builder.status(OK).entity(Messages.MSG.dataSourceTestOk(name));
} else {
builder.status(SERVICE_UNAVAILABLE).entity(Messages.MSG.dataSourceTestFail(name));
}
} catch (Exception e) {
throw Util.unchecked(e);
}
return builder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> getCacheConfigDefaultAttributes(RestRequest request) {
Configuration configuration = new ConfigurationBuilder().build();
Map<String, Object> attributes = new LinkedHashMap<>();
allAttributes(configuration, attributes, configuration.elementName());
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(attributes), isPretty(request));
}
private static void allAttributes(ConfigurationElement<?> element, Map<String, Object> attributes, String prefix) {
Map<String, Object> attributeMap = new LinkedHashMap<>();
for (Attribute<?> attribute : element.attributes().attributes()) {
AttributeDefinition<?> definition = attribute.getAttributeDefinition();
String value;
if (attribute.getInitialValue() == null) {
value = null;
} else {
value = attribute.getInitialValue().toString();
}
attributeMap.put(definition.name(), value);
}
Map<String, Object> relative = attributes;
String[] path = prefix.split("\\.");
for (int i = 0; i < path.length - 1; i++) {
String key = path[i];
relative = (Map<String, Object>) relative.computeIfAbsent(key, ignore -> new LinkedHashMap<>());
}
relative.put(path[path.length - 1], attributeMap);
for (ConfigurationElement<?> child : element.children()) {
allAttributes(child, attributes, prefix + "." + child.elementName());
}
}
static class ServerInfo implements JsonSerialization {
private static final Json json = Json.object("version", Version.printVersion());
@Override
public Json toJson() {
return json;
}
}
}
| 29,372
| 51.924324
| 163
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/CounterResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpHeaderNames.CACHE_CONTROL;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_MODIFIED;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JSON;
import static org.infinispan.commons.util.concurrent.CompletableFutures.extractException;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponse;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.function.Function;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.commons.configuration.io.ConfigurationWriter;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.io.StringBuilderWriter;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.counter.api.CounterConfiguration;
import org.infinispan.counter.api.StrongCounter;
import org.infinispan.counter.api.WeakCounter;
import org.infinispan.counter.configuration.AbstractCounterConfiguration;
import org.infinispan.counter.configuration.ConvertUtil;
import org.infinispan.counter.configuration.CounterConfigurationSerializer;
import org.infinispan.counter.configuration.CounterManagerConfiguration;
import org.infinispan.counter.configuration.CounterManagerConfigurationBuilder;
import org.infinispan.counter.exception.CounterNotFoundException;
import org.infinispan.counter.impl.manager.EmbeddedCounterManager;
import org.infinispan.counter.impl.manager.InternalCounterAdmin;
import org.infinispan.rest.CacheControl;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.RestResponseException;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.util.concurrent.CompletionStages;
/**
* Handler for the counter resource.
*
* @since 10.0
*/
public class CounterResource implements ResourceHandler {
private final InvocationHelper invocationHelper;
public CounterResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
// Lifecycle
.invocation().methods(POST).path("/v2/counters/{counterName}").handleWith(this::createCounter)
.invocation().methods(DELETE).path("/v2/counters/{counterName}").handleWith(this::deleteCounter)
// Config
.invocation().methods(GET).path("/v2/counters/{counterName}/config").handleWith(this::getConfig)
// List
.invocation().methods(GET).path("/v2/counters/").handleWith(this::getCounterNames)
// Common counter ops
.invocation().methods(GET).path("/v2/counters/{counterName}").handleWith(this::getCounter)
.invocation().methods(POST).path("/v2/counters/{counterName}").withAction("reset").handleWith(this::resetCounter)
.invocation().methods(POST).path("/v2/counters/{counterName}").withAction("increment").handleWith(this::incrementCounter)
.invocation().methods(POST).path("/v2/counters/{counterName}").withAction("decrement").handleWith(this::decrementCounter)
.invocation().methods(POST).path("/v2/counters/{counterName}").withAction("add").handleWith(this::addValue)
// Strong counter ops
.invocation().methods(POST).path("/v2/counters/{counterName}").withAction("compareAndSet").handleWith(this::compareSet)
.invocation().methods(POST).path("/v2/counters/{counterName}").withAction("compareAndSwap").handleWith(this::compareSwap)
.invocation().methods(POST).path("/v2/counters/{counterName}").withAction("getAndSet").handleWith(this::getAndSet)
.create();
}
private CompletionStage<RestResponse> createCounter(RestRequest request) throws RestResponseException {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String counterName = request.variables().get("counterName");
String contents = request.contents().asString();
if (contents == null || contents.isEmpty()) {
throw Log.REST.missingContent();
}
CounterConfiguration configuration = createCounterConfiguration(contents);
if (configuration == null) {
throw Log.REST.invalidContent();
}
return invocationHelper.getCounterManager()
.defineCounterAsync(counterName, configuration)
.thenApply(created -> created ?
responseBuilder.build() :
responseBuilder.status(NOT_MODIFIED)
.entity("Unable to create counter: " + counterName)
.build());
}
private CompletionStage<RestResponse> deleteCounter(RestRequest request) {
String counterName = request.variables().get("counterName");
EmbeddedCounterManager counterManager = invocationHelper.getCounterManager();
return counterManager.getConfigurationAsync(counterName).thenCompose(configuration -> {
if (configuration == null) return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
return counterManager.removeAsync(counterName, false)
.thenApply(ignore -> invocationHelper.newResponse(request).status(NO_CONTENT).build());
});
}
private CompletionStage<RestResponse> getConfig(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String counterName = request.variables().get("counterName");
boolean pretty = Boolean.parseBoolean(request.getParameter("pretty"));
return invocationHelper.getCounterManager().getConfigurationAsync(counterName).thenApply(cfg -> {
if (cfg == null) return responseBuilder.status(NOT_FOUND).build();
AbstractCounterConfiguration parsedConfig = ConvertUtil.configToParsedConfig(counterName, cfg);
CounterConfigurationSerializer ccs = new CounterConfigurationSerializer();
StringBuilderWriter sw = new StringBuilderWriter();
try (ConfigurationWriter w = ConfigurationWriter.to(sw).withType(APPLICATION_JSON).prettyPrint(pretty).build()) {
ccs.serializeConfiguration(w, parsedConfig);
}
return responseBuilder.entity(sw.toString()).contentType(APPLICATION_JSON).build();
});
}
private CompletionStage<RestResponse> getCounter(RestRequest request) throws RestResponseException {
String counterName = request.variables().get("counterName");
String accept = request.getAcceptHeader();
MediaType contentType = accept == null ? MediaType.TEXT_PLAIN : negotiateMediaType(accept);
EmbeddedCounterManager counterManager = invocationHelper.getCounterManager();
CompletionStage<InternalCounterAdmin> stage = counterManager.getOrCreateAsync(counterName);
return CompletionStages.handleAndCompose(stage, (counter, throwable) -> {
if (throwable != null) {
return handleThrowable(request, throwable);
}
return counter.value().thenApply(v -> invocationHelper.newResponse(request)
.contentType(contentType)
.header(CACHE_CONTROL.toString(), CacheControl.noCache())
.entity(Long.toString(v)).build());
});
}
private CompletionStage<RestResponse> resetCounter(RestRequest request) throws RestResponseException {
String counterName = request.variables().get("counterName");
EmbeddedCounterManager counterManager = invocationHelper.getCounterManager();
CompletionStage<InternalCounterAdmin> stage = counterManager.getOrCreateAsync(counterName);
return CompletionStages.handleAndCompose(stage, (counter, throwable) -> {
if (throwable != null) {
return handleThrowable(request, throwable);
} else {
return counter.reset().thenCompose(unused -> invocationHelper.newResponse(request, NO_CONTENT).toFuture());
}
});
}
private CompletionStage<RestResponse> getCounterNames(RestRequest request) throws RestResponseException {
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(invocationHelper.getCounterManager().getCounterNames()), isPretty(request));
}
private CompletionStage<RestResponse> incrementCounter(RestRequest request) {
return executeCommonCounterOp(request, WeakCounter::increment, StrongCounter::incrementAndGet);
}
private CompletionStage<RestResponse> decrementCounter(RestRequest request) {
return executeCommonCounterOp(request, WeakCounter::decrement, StrongCounter::decrementAndGet);
}
private CompletionStage<RestResponse> addValue(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
Long delta = checkForNumericParam("delta", request, responseBuilder);
if (delta == null) return completedFuture(responseBuilder.build());
return executeCommonCounterOp(request, weakCounter -> weakCounter.add(delta), strongCounter -> strongCounter.addAndGet(delta));
}
private CompletionStage<RestResponse> compareSet(RestRequest request) {
return executeCounterCAS(request, StrongCounter::compareAndSet);
}
private CompletionStage<RestResponse> compareSwap(RestRequest request) {
return executeCounterCAS(request, StrongCounter::compareAndSwap);
}
private CompletionStage<RestResponse> getAndSet(RestRequest request) {
NettyRestResponse.Builder responseBuilder = new NettyRestResponse.Builder();
String counterName = request.variables().get("counterName");
Long value = checkForNumericParam("value", request, responseBuilder);
if (value == null) return completedFuture(responseBuilder.build());
CompletionStage<StrongCounter> stage = invocationHelper.getCounterManager().getStrongCounterAsync(counterName);
return CompletionStages.handleAndCompose(stage, (counter, throwable) -> {
if (throwable != null) {
return handleThrowable(request, throwable);
}
return counter.getAndSet(value).thenApply(v -> new NettyRestResponse.Builder().status(OK).entity(String.valueOf(v)).build());
});
}
private CounterConfiguration createCounterConfiguration(String json) {
try (ConfigurationReader reader = ConfigurationReader.from(json).withType(APPLICATION_JSON).build()) {
ConfigurationBuilderHolder holder = invocationHelper.getParserRegistry().parse(reader, new ConfigurationBuilderHolder());
CounterManagerConfigurationBuilder counterModule = holder.getGlobalConfigurationBuilder().module(CounterManagerConfigurationBuilder.class);
CounterManagerConfiguration configuration = counterModule.create();
return ConvertUtil.parsedConfigToConfig(configuration.counters().values().iterator().next());
}
}
private CompletionStage<RestResponse> executeCommonCounterOp(RestRequest request,
Function<WeakCounter, CompletionStage<Void>> weakOp,
Function<StrongCounter, CompletableFuture<Long>> strongOp) {
String counterName = request.variables().get("counterName");
boolean pretty = isPretty(request);
CompletionStage<InternalCounterAdmin> stage = invocationHelper.getCounterManager().getOrCreateAsync(counterName);
return CompletionStages.handleAndCompose(stage, (counter, throwable) -> {
if (throwable != null) {
return handleThrowable(request, throwable);
}
CompletableFuture<RestResponse> rsp = new CompletableFuture<>();
if (counter.isWeakCounter()) {
weakOp.apply(counter.asWeakCounter()).whenComplete((___, t) -> {
if (t != null) {
rsp.completeExceptionally(t);
} else {
rsp.complete(invocationHelper.newResponse(request, NO_CONTENT));
}
});
} else {
strongOp.apply(counter.asStrongCounter()).whenComplete((rv, t) -> {
if (t != null) {
rsp.completeExceptionally(t);
} else {
rsp.complete(asJsonResponse(invocationHelper.newResponse(request), Json.make(rv), pretty));
}
});
}
return rsp;
});
}
private <T> CompletionStage<RestResponse> executeCounterCAS(RestRequest request, CASInvocation<StrongCounter, Long, Long, CompletableFuture<T>> invocation) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
String counterName = request.variables().get("counterName");
boolean pretty = isPretty(request);
Long expect = checkForNumericParam("expect", request, responseBuilder);
if (expect == null) return completedFuture(responseBuilder.build());
Long update = checkForNumericParam("update", request, responseBuilder);
if (update == null) return completedFuture(responseBuilder.build());
CompletionStage<StrongCounter> stage = invocationHelper.getCounterManager().getStrongCounterAsync(counterName);
return CompletionStages.handleAndCompose(stage, (counter, throwable) -> {
if (throwable != null) {
return handleThrowable(request, throwable);
}
return invocation.apply(counter, expect, update).thenCompose(value -> asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(value), pretty));
});
}
@FunctionalInterface
interface CASInvocation<C, A, B, R> {
R apply(C t, A u, B v);
}
private Long checkForNumericParam(String name, RestRequest request, NettyRestResponse.Builder builder) {
List<String> params = request.parameters().get(name);
if (params == null || params.size() != 1) {
throw Log.REST.missingArgument(name);
} else {
String value = params.iterator().next();
try {
return Long.valueOf(value);
} catch (NumberFormatException e) {
throw Log.REST.illegalArgument(name, value);
}
}
}
private MediaType negotiateMediaType(String accept) {
return MediaType.parseList(accept).filter(t ->
t.match(MediaType.TEXT_PLAIN) // TODO: add more types in ISPN-10211
).findFirst().orElseThrow(() -> Log.REST.unsupportedDataFormat(accept));
}
private CompletionStage<RestResponse> handleThrowable(RestRequest request, Throwable throwable) {
Throwable cause = extractException(throwable);
if (cause instanceof CounterNotFoundException) {
return invocationHelper.newResponse(request, NOT_FOUND).toFuture();
}
return CompletableFuture.failedFuture(cause);
}
}
| 15,815
| 49.692308
| 166
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/TasksResource.java
|
package org.infinispan.rest.resources;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_JAVASCRIPT;
import static org.infinispan.commons.dataconversion.MediaType.TEXT_PLAIN_TYPE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.framework.Method.PUT;
import static org.infinispan.rest.resources.ResourceUtil.addEntityAsJson;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponse;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.dataconversion.StandardConversions;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ContentSource;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.scripting.ScriptingManager;
import org.infinispan.security.Security;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.tasks.TaskContext;
import org.infinispan.tasks.TaskManager;
/**
* @since 10.1
*/
public class TasksResource implements ResourceHandler {
private final InvocationHelper invocationHelper;
public TasksResource(InvocationHelper invocationHelper) {
this.invocationHelper = invocationHelper;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(GET).path("/v2/tasks/").handleWith(this::listTasks)
.invocation().methods(PUT, POST).path("/v2/tasks/{taskName}").handleWith(this::createScriptTask)
.invocation().methods(POST).path("/v2/tasks/{taskName}").withAction("exec").handleWith(this::runTask)
.invocation().methods(GET).path("/v2/tasks/{taskName}").withAction("script").handleWith(this::getScript)
.create();
}
private CompletionStage<RestResponse> getScript(RestRequest request) {
String taskName = request.variables().get("taskName");
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance().withSubject(request.getSubject());
ScriptingManager scriptingManager = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(ScriptingManager.class);
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
if (!scriptingManager.getScriptNames().contains(taskName)) {
throw Log.REST.noSuchScript(taskName);
}
return CompletableFuture.supplyAsync(() -> {
String script = Security.doAs(request.getSubject(), () -> scriptingManager.getScript(taskName));
return builder.entity(script).contentType(TEXT_PLAIN_TYPE).build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> listTasks(RestRequest request) {
String type = request.getParameter("type");
boolean userOnly = type != null && type.equalsIgnoreCase("user");
boolean pretty = isPretty(request);
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
TaskManager taskManager = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(TaskManager.class);
return (userOnly ? taskManager.getUserTasksAsync() : taskManager.getTasksAsync())
.thenApply(tasks -> asJsonResponse(invocationHelper.newResponse(request), Json.make(tasks), pretty));
}
private CompletionStage<RestResponse> createScriptTask(RestRequest request) {
String taskName = request.variables().get("taskName");
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance().withSubject(request.getSubject());
ScriptingManager scriptingManager = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(ScriptingManager.class);
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
ContentSource contents = request.contents();
byte[] bytes = contents.rawContent();
MediaType sourceType = request.contentType() == null ? APPLICATION_JAVASCRIPT : request.contentType();
String script = StandardConversions.convertTextToObject(bytes, sourceType);
return CompletableFuture.supplyAsync(() -> {
Security.doAs(request.getSubject(), () -> scriptingManager.addScript(taskName, script));
return builder.build();
}, invocationHelper.getExecutor());
}
private CompletionStage<RestResponse> runTask(RestRequest request) {
String taskName = request.variables().get("taskName");
boolean pretty = isPretty(request);
EmbeddedCacheManager cacheManager = invocationHelper.getRestCacheManager().getInstance();
TaskManager taskManager = SecurityActions.getGlobalComponentRegistry(cacheManager).getComponent(TaskManager.class);
TaskContext taskContext = new TaskContext();
request.parameters().forEach((k, v) -> {
if ("cache".equals(k)) {
AdvancedCache<?, ?> cache = invocationHelper.getRestCacheManager().getCache(v.get(0), request);
taskContext.cache(cache);
} else if (k.startsWith("param.")) {
taskContext.addParameter(k.substring(6), v.get(0));
}
});
CompletionStage<Object> runResult = Security.doAs(request.getSubject(), () -> taskManager.runTask(taskName, taskContext));
return runResult.thenApply(result -> {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
if (result instanceof byte[]) {
builder.contentType(TEXT_PLAIN_TYPE).entity(result);
} else {
addEntityAsJson(Json.make(result), builder, pretty);
}
return builder.build();
});
}
}
| 6,244
| 49.362903
| 136
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/StaticContentResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.MOVED_PERMANENTLY;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_MODIFIED;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_OCTET_STREAM_TYPE;
import static org.infinispan.rest.framework.Method.GET;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Date;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.TimeUnit;
import org.infinispan.commons.dataconversion.MediaTypeResolver;
import org.infinispan.rest.DateUtils;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* REST resource to serve static content.
*
* @since 10.0
*/
public class StaticContentResource implements ResourceHandler {
private final Path dir;
private final String urlPath;
private static final int CACHE_MAX_AGE_SECONDS = 60 * 60 * 24 * 31; // 1 Month
public static final String DEFAULT_RESOURCE = "index.html";
private final String noFileUri;
private final ResourceResolver customResourceResolver;
private final String rootUri;
private final InvocationHelper invocationHelper;
public interface ResourceResolver {
/**
* Resolves a path to a resource name
*
* @param path The requested URL path
* @param resource the {@link StaticContentResource} instance
* @return The resource name
*/
String rewrite(String path, StaticContentResource resource);
}
/**
* @param dir The path to serve files from
* @param urlPath The url path to serve the file.
* @param resourceResolver a {@link ResourceResolver} to resolve requests into resources
*/
public StaticContentResource(InvocationHelper invocationHelper, Path dir, String urlPath, ResourceResolver resourceResolver) {
this.invocationHelper = invocationHelper;
this.dir = dir.toAbsolutePath();
this.urlPath = urlPath;
this.noFileUri = "/" + urlPath;
this.customResourceResolver = resourceResolver;
this.rootUri = noFileUri + "/";
}
public StaticContentResource(InvocationHelper invocationHelper, Path dir, String urlPath) {
this(invocationHelper, dir, urlPath, null);
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(GET).anonymous(true).path(urlPath + "/").path(urlPath + "/*").handleWith(this::serveFile)
.create();
}
private File resolve(String resource) {
Path resolved = dir.resolve(resource);
try {
if (!resolved.toFile().getCanonicalPath().startsWith(dir.toFile().getCanonicalPath())) {
return null;
}
} catch (IOException e) {
return null;
}
File file = resolved.toFile();
if (!file.isFile() || !file.exists()) {
return null;
}
return file;
}
private CompletionStage<RestResponse> serveFile(RestRequest restRequest) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(restRequest);
String uri = restRequest.uri();
if (uri.equals(noFileUri)) {
return completedFuture(responseBuilder.location(rootUri).status(MOVED_PERMANENTLY).build());
}
String resource = uri.substring(uri.indexOf(urlPath) + urlPath.length() + 1);
if (customResourceResolver != null) {
resource = customResourceResolver.rewrite(resource, this);
} else {
if (uri.equals(rootUri)) resource = DEFAULT_RESOURCE;
}
File file = resolve(resource);
if (file == null) {
return completedFuture(responseBuilder.status(HttpResponseStatus.NOT_FOUND).build());
}
String ifModifiedSince = restRequest.getIfModifiedSinceHeader();
if (ifModifiedSince != null && !ifModifiedSince.isEmpty()) {
boolean isNotModified = DateUtils.isNotModifiedSince(ifModifiedSince, file.lastModified());
if (isNotModified) {
responseBuilder.status(NOT_MODIFIED);
return completedFuture(responseBuilder.build());
}
}
responseBuilder.lastModified(file.lastModified());
responseBuilder.header("Cache-control", "private, max-age=" + CACHE_MAX_AGE_SECONDS);
Date now = new Date();
responseBuilder.addProcessedDate(now);
responseBuilder.header("Expires", DateUtils.toRFC1123(now.getTime() + TimeUnit.SECONDS.toMillis(CACHE_MAX_AGE_SECONDS)));
String resolved = MediaTypeResolver.getMediaType(file.getName());
String mediaType = resolved != null ? resolved : APPLICATION_OCTET_STREAM_TYPE;
responseBuilder.contentLength(file.length())
.contentType(mediaType)
.entity(file);
return completedFuture(responseBuilder.build());
}
}
| 5,224
| 35.538462
| 129
|
java
|
null |
infinispan-main/server/rest/src/main/java/org/infinispan/rest/resources/SecurityResource.java
|
package org.infinispan.rest.resources;
import static io.netty.handler.codec.http.HttpResponseStatus.CONFLICT;
import static io.netty.handler.codec.http.HttpResponseStatus.NOT_FOUND;
import static io.netty.handler.codec.http.HttpResponseStatus.NO_CONTENT;
import static java.util.concurrent.CompletableFuture.completedFuture;
import static org.infinispan.rest.framework.Method.DELETE;
import static org.infinispan.rest.framework.Method.GET;
import static org.infinispan.rest.framework.Method.POST;
import static org.infinispan.rest.framework.Method.PUT;
import static org.infinispan.rest.resources.ResourceUtil.asJsonResponseFuture;
import static org.infinispan.rest.resources.ResourceUtil.isPretty;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionStage;
import java.util.stream.Collectors;
import javax.security.auth.Subject;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.global.GlobalAuthorizationConfiguration;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.rest.InvocationHelper;
import org.infinispan.rest.NettyRestResponse;
import org.infinispan.rest.cachemanager.RestCacheManager;
import org.infinispan.rest.framework.ResourceHandler;
import org.infinispan.rest.framework.RestRequest;
import org.infinispan.rest.framework.RestResponse;
import org.infinispan.rest.framework.impl.Invocations;
import org.infinispan.rest.logging.Log;
import org.infinispan.security.AuditContext;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.security.MutablePrincipalRoleMapper;
import org.infinispan.security.MutableRolePermissionMapper;
import org.infinispan.security.PrincipalRoleMapper;
import org.infinispan.security.Role;
import org.infinispan.security.RolePermissionMapper;
import org.infinispan.security.actions.SecurityActions;
import org.infinispan.security.impl.Authorizer;
import org.infinispan.security.impl.CacheRoleImpl;
import org.infinispan.security.impl.SubjectACL;
import org.infinispan.server.core.ServerManagement;
import io.netty.handler.codec.http.HttpResponseStatus;
/**
* @since 10.1
*/
public class SecurityResource implements ResourceHandler {
private final InvocationHelper invocationHelper;
private final String accessGrantedPath;
private final MutablePrincipalRoleMapper principalRoleMapper;
private final MutableRolePermissionMapper rolePermissionMapper;
public SecurityResource(InvocationHelper invocationHelper, String accessGrantedPath, String accessDeniedPath) {
this.invocationHelper = invocationHelper;
this.accessGrantedPath = accessGrantedPath;
GlobalConfiguration globalConfiguration = SecurityActions.getCacheManagerConfiguration(invocationHelper.getRestCacheManager().getInstance());
PrincipalRoleMapper mapper = globalConfiguration.security().authorization().principalRoleMapper();
this.principalRoleMapper = mapper instanceof MutablePrincipalRoleMapper ? (MutablePrincipalRoleMapper) mapper : null;
RolePermissionMapper permissionMapper = globalConfiguration.security().authorization().rolePermissionMapper();
this.rolePermissionMapper = permissionMapper instanceof MutableRolePermissionMapper ? (MutableRolePermissionMapper) permissionMapper : null;
}
@Override
public Invocations getInvocations() {
return new Invocations.Builder()
.invocation().methods(GET).path("/v2/login").withAction("config")
.anonymous().handleWith(this::loginConfiguration)
.invocation().methods(GET, POST).deprecated().path("/v2/login").withAction("login")
.permission(AuthorizationPermission.NONE).name("USER LOGIN").auditContext(AuditContext.SERVER)
.handleWith(this::login)
.invocation().methods(GET).deprecated().path("/v2/login")
.permission(AuthorizationPermission.NONE).name("USER LOGIN").auditContext(AuditContext.SERVER)
.handleWith(this::login)
.invocation().methods(GET).path("/v2/security/user/acl")
.handleWith(this::acl)
.invocation().method(GET).path("/v2/security/roles")
.permission(AuthorizationPermission.ADMIN).name("ROLES").auditContext(AuditContext.SERVER)
.handleWith(this::listAllRoles)
.invocation().method(GET).path("/v2/security/roles/{principal}")
.permission(AuthorizationPermission.ADMIN).name("ROLES PRINCIPAL").auditContext(AuditContext.SERVER)
.handleWith(this::listPrincipalRoles)
.invocation().method(PUT).path("/v2/security/roles/{principal}").withAction("grant")
.permission(AuthorizationPermission.ADMIN).name("ROLES GRANT").auditContext(AuditContext.SERVER)
.handleWith(this::grant)
.invocation().method(PUT).path("/v2/security/roles/{principal}").withAction("deny")
.permission(AuthorizationPermission.ADMIN).name("ROLES DENY").auditContext(AuditContext.SERVER)
.handleWith(this::deny)
.invocation().methods(GET).path("/v2/security/principals")
.permission(AuthorizationPermission.ADMIN).name("PRINCIPALS LIST").auditContext(AuditContext.SERVER)
.handleWith(this::listPrincipals)
.invocation().methods(POST, PUT).path("/v2/security/permissions/{role}")
.permission(AuthorizationPermission.ADMIN).name("ROLES CREATE").auditContext(AuditContext.SERVER)
.handleWith(this::createRole)
.invocation().methods(GET).path("/v2/security/permissions/{role}")
.permission(AuthorizationPermission.ADMIN).name("ROLES DESCRIBE").auditContext(AuditContext.SERVER)
.handleWith(this::describeRole)
.invocation().method(DELETE).path("/v2/security/permissions/{role}")
.permission(AuthorizationPermission.ADMIN).name("ROLES DELETE").auditContext(AuditContext.SERVER)
.handleWith(this::deleteRole)
.invocation().method(POST).path("/v2/security/cache").withAction("flush")
.permission(AuthorizationPermission.ADMIN).name("ACL CACHE FLUSH").auditContext(AuditContext.SERVER)
.handleWith(this::aclCacheFlush)
.create();
}
private CompletionStage<RestResponse> listPrincipals(RestRequest request) {
Json principals = Json.make(invocationHelper.getServer().getPrincipalList());
return asJsonResponseFuture(invocationHelper.newResponse(request), principals, isPretty(request));
}
private CompletionStage<RestResponse> createRole(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
if (rolePermissionMapper == null) {
return completedFuture(invocationHelper.newResponse(request).status(CONFLICT).entity(Log.REST.rolePermissionMapperNotMutable()).build());
}
String name = request.variables().get("role");
List<String> perms = request.parameters().get("permission");
if (perms == null) {
return completedFuture(builder.status(HttpResponseStatus.BAD_REQUEST).build());
}
Set<AuthorizationPermission> permissions = perms.stream().map(p -> AuthorizationPermission.valueOf(p.toUpperCase())).collect(Collectors.toSet());
Role role = new CacheRoleImpl(name, true, permissions);
return rolePermissionMapper.addRole(role).thenCompose(ignore -> aclCacheFlush(request));
}
private CompletionStage<RestResponse> describeRole(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
if (rolePermissionMapper == null) {
return completedFuture(invocationHelper.newResponse(request).status(CONFLICT).entity(Log.REST.rolePermissionMapperNotMutable()).build());
}
String name = request.variables().get("role");
GlobalAuthorizationConfiguration authorization = invocationHelper.getRestCacheManager().getInstance().getCacheManagerConfiguration().security().authorization();
Role role = authorization.getRole(name);
if (role == null) {
return completedFuture(builder.status(NOT_FOUND).build());
}
Json roles = Json.object();
roles.set("name", name);
Json permissions = Json.array();
for (AuthorizationPermission p : role.getPermissions()) {
permissions.add(p.toString());
}
roles.set("permissions", permissions);
return asJsonResponseFuture(invocationHelper.newResponse(request), roles, isPretty(request));
}
private CompletionStage<RestResponse> deleteRole(RestRequest request) {
if (rolePermissionMapper == null) {
return completedFuture(invocationHelper.newResponse(request).status(CONFLICT).entity(Log.REST.rolePermissionMapperNotMutable()).build());
}
String role = request.variables().get("role");
return rolePermissionMapper.removeRole(role).thenCompose(ignore -> aclCacheFlush(request));
}
private CompletionStage<RestResponse> aclCacheFlush(RestRequest request) {
ServerManagement server = invocationHelper.getServer();
return server.flushSecurityCaches().thenApply(v -> invocationHelper.newResponse(request).status(NO_CONTENT).build());
}
private CompletionStage<RestResponse> deny(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
if (principalRoleMapper == null) {
return completedFuture(invocationHelper.newResponse(request).status(CONFLICT).entity(Log.REST.principalRoleMapperNotMutable()).build());
}
String principal = request.variables().get("principal");
List<String> roles = request.parameters().get("role");
if (roles == null) {
return completedFuture(builder.status(HttpResponseStatus.BAD_REQUEST).build());
}
roles.forEach(r -> principalRoleMapper.deny(r, principal));
return aclCacheFlush(request);
}
private CompletionStage<RestResponse> grant(RestRequest request) {
NettyRestResponse.Builder builder = invocationHelper.newResponse(request);
if (principalRoleMapper == null) {
return completedFuture(invocationHelper.newResponse(request).status(CONFLICT).entity(Log.REST.principalRoleMapperNotMutable()).build());
}
String principal = request.variables().get("principal");
List<String> roles = request.parameters().get("role");
if (roles == null) {
return completedFuture(builder.status(HttpResponseStatus.BAD_REQUEST).build());
}
roles.forEach(r -> principalRoleMapper.grant(r, principal));
return aclCacheFlush(request);
}
private CompletionStage<RestResponse> listAllRoles(RestRequest request) {
GlobalAuthorizationConfiguration authorization = invocationHelper.getRestCacheManager().getInstance().getCacheManagerConfiguration().security().authorization();
if (!authorization.enabled()) {
throw Log.REST.authorizationNotEnabled();
}
Json roles = Json.array();
authorization.roles().entrySet().stream().filter(e -> e.getValue().isInheritable()).forEach(e -> roles.add(e.getKey()));
return asJsonResponseFuture(invocationHelper.newResponse(request), roles, isPretty(request));
}
private CompletionStage<RestResponse> listPrincipalRoles(RestRequest request) {
String principal = request.variables().get("principal");
if (principalRoleMapper == null) {
return completedFuture(invocationHelper.newResponse(request).status(CONFLICT).entity(Log.REST.principalRoleMapperNotMutable()).build());
}
Json roles = Json.array();
principalRoleMapper.list(principal).forEach(roles::add);
return asJsonResponseFuture(invocationHelper.newResponse(request), roles, isPretty(request));
}
private CompletionStage<RestResponse> acl(RestRequest request) {
Subject subject = request.getSubject();
RestCacheManager<Object> rcm = invocationHelper.getRestCacheManager();
Collection<String> cacheNames = rcm.getCacheNames();
Json acl = Json.object();
if (subject == null) {
acl.set("subject", Json.array());
} else {
Json jsonSubjects = Json.array();
subject.getPrincipals().forEach(principal -> {
jsonSubjects.add(Json.object().set("name", principal.getName()).set("type", principal.getClass().getSimpleName()));
});
acl.set("subject", jsonSubjects);
Authorizer authorizer = rcm.getAuthorizer();
SubjectACL globalACL = authorizer.getACL(subject);
acl.set("global", aclToJson(globalACL));
Json caches = Json.object();
acl.set("caches", caches);
for (String cacheName : cacheNames) {
Configuration cacheConfiguration = SecurityActions.getCacheConfiguration(rcm.getInstance(), cacheName);
SubjectACL cacheACL = authorizer.getACL(subject, cacheConfiguration.security().authorization());
caches.set(cacheName, aclToJson(cacheACL));
}
}
return asJsonResponseFuture(invocationHelper.newResponse(request), acl, isPretty(request));
}
private Json aclToJson(SubjectACL acl) {
Json array = Json.array();
for (AuthorizationPermission permission : acl.getPermissions()) {
array.add(permission.name());
}
return array;
}
private CompletionStage<RestResponse> loginConfiguration(RestRequest request) {
Map<String, String> loginConfiguration = invocationHelper.getServer().getLoginConfiguration(invocationHelper.getProtocolServer());
return asJsonResponseFuture(invocationHelper.newResponse(request), Json.make(loginConfiguration), isPretty(request));
}
private CompletionStage<RestResponse> login(RestRequest request) {
NettyRestResponse.Builder responseBuilder = invocationHelper.newResponse(request);
responseBuilder.status(HttpResponseStatus.TEMPORARY_REDIRECT).header("Location", accessGrantedPath);
return CompletableFuture.completedFuture(responseBuilder.build());
}
}
| 14,261
| 53.022727
| 166
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/cli/XSiteCliOperations.java
|
package org.infinispan.server.cli;
import static org.infinispan.server.test.core.InfinispanServerTestConfiguration.LON;
import static org.infinispan.server.test.core.InfinispanServerTestConfiguration.NYC;
import java.io.File;
import java.util.List;
import java.util.Properties;
import java.util.function.Consumer;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.aesh.terminal.utils.Config;
import org.infinispan.cli.commands.CLI;
import org.infinispan.cli.impl.AeshDelegatingShell;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.BackupConfiguration;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.XSiteStateTransferMode;
import org.infinispan.server.functional.XSiteIT;
import org.infinispan.server.test.core.AeshTestConnection;
import org.infinispan.server.test.core.TestServer;
import org.infinispan.server.test.junit5.InfinispanXSiteServerExtension;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* CLI test for 'site' command
*
* @author Pedro Ruivo
* @since 12.1
*/
public class XSiteCliOperations {
@RegisterExtension
public static final InfinispanXSiteServerExtension SERVERS = XSiteIT.SERVERS;
private static File workingDir;
private static Properties properties;
@BeforeAll
public static void setup() {
workingDir = new File(CommonsTestingUtil.tmpDirectory(XSiteCliOperations.class));
Util.recursiveFileRemove(workingDir);
//noinspection ResultOfMethodCallIgnored
workingDir.mkdirs();
properties = new Properties(System.getProperties());
properties.put("cli.dir", workingDir.getAbsolutePath());
}
@AfterAll
public static void teardown() {
Util.recursiveFileRemove(workingDir);
}
@Test
public void testSiteView() {
doWithTerminal(terminal -> {
connect(terminal, LON);
terminal.send("site name");
terminal.assertContains(LON);
terminal.clear();
terminal.send("site view");
terminal.assertContains(LON);
terminal.assertContains(NYC);
terminal.clear();
disconnect(terminal);
connect(terminal, NYC);
terminal.send("site name");
terminal.assertContains(NYC);
terminal.clear();
terminal.send("site view");
terminal.assertContains(LON);
terminal.assertContains(NYC);
terminal.clear();
});
}
@Test
public void testStateTransferModeCli() {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.clustering().cacheMode(CacheMode.DIST_SYNC);
builder.clustering().sites().addBackup()
.site(NYC)
.strategy(BackupConfiguration.BackupStrategy.ASYNC)
.stateTransfer().mode(XSiteStateTransferMode.AUTO);
SERVERS.hotrod(LON).createRemoteCacheManager()
.administration()
.createCache("st-mode", builder.build());
doWithTerminal(terminal -> {
connect(terminal, LON);
terminal.send("site state-transfer-mode");
terminal.assertContains("Usage: site state-transfer-mode [<options>]");
terminal.clear();
//make sure --site is required
terminal.send("site state-transfer-mode get");
terminal.assertContains("Option: --site is required for this command.");
terminal.clear();
//check command invoked in the wrong context
terminal.send("site state-transfer-mode get --site=" + NYC);
terminal.assertContains("Command invoked from the wrong context");
terminal.clear();
//check non xsite cache
terminal.send("cd caches/___script_cache");
terminal.clear();
terminal.send("site state-transfer-mode get --site=" + NYC);
terminal.assertContains("Not Found: Cache '___script_cache' does not have backup sites.");
terminal.clear();
//check if --cache overrides the context
terminal.send("site state-transfer-mode get --cache=st-mode --site=" + NYC);
terminal.assertContains("AUTO");
terminal.clear();
//check if --cache is not required
terminal.send("cd ../st-mode");
terminal.clear();
terminal.send("site state-transfer-mode get --site=" + NYC);
terminal.assertContains("AUTO");
terminal.clear();
//check invalid site
terminal.send("site state-transfer-mode get --site=NOT_A_SITE");
terminal.assertContains("Not Found: Cache 'st-mode' does not backup to site 'NOT_A_SITE'");
terminal.clear();
//check set!
terminal.send("site state-transfer-mode set --mode=MANUAL --site=" + NYC);
terminal.clear();
terminal.send("site state-transfer-mode get --site=" + NYC);
terminal.assertContains("MANUAL");
terminal.clear();
//check invalid mode
terminal.send("site state-transfer-mode set --mode=ABC --site=" + NYC);
terminal.assertContains("No enum constant org.infinispan.configuration.cache.XSiteStateTransferMode.ABC");
terminal.clear();
});
}
@Test
public void testRelayNodeInfo() {
doWithTerminal(terminal -> {
connect(terminal, LON);
terminal.send("site is-relay-node");
terminal.assertContains("true");
terminal.clear();
// max_site_master is 3 so the relay-nodes is the same as cluster_members
// method has side effects, invoke before "site relay-nodes"
List<String> view = extractView(terminal);
terminal.send("site relay-nodes");
view.forEach(terminal::assertContains);
terminal.clear();
});
}
private void connect(AeshTestConnection terminal, String site) {
// connect
terminal.send("connect " + hostAndPort(site));
terminal.assertContains("//containers/default]>");
terminal.clear();
}
private void disconnect(AeshTestConnection terminal) {
// connect
terminal.send("disconnect");
terminal.clear();
}
private String hostAndPort(String site) {
for (TestServer server : SERVERS.getTestServers()) {
if (site.equals(server.getSiteName())) {
String host = server.getDriver().getServerAddress(0).getHostAddress();
int port = server.getDriver().getServerSocket(0, 11222).getPort();
return host + ":" + port;
}
}
throw new IllegalStateException("Site " + site + " not found.");
}
private static List<String> extractView(AeshTestConnection terminal) {
terminal.send("describe");
// make sure the command succeed
terminal.assertContains("//containers/default");
String allOutput = terminal.getOutputBuffer();
Pattern pattern = Pattern.compile("^\\s*\"cluster_members\"\\s*:\\s*\\[\\s+(.*)\\s+],\\s*$");
for (String line : allOutput.split(Config.getLineSeparator())) {
line = line.trim();
Matcher matcher = pattern.matcher(line);
if (matcher.matches()) {
terminal.clear();
return Stream.of(matcher.group(1).split(","))
.map(s -> s.replaceAll("[\\[\\]\"]", ""))
.collect(Collectors.toList());
}
}
terminal.clear();
throw new IllegalStateException("Unable to find 'cluster_members' in:\n" + allOutput);
}
private void doWithTerminal(Consumer<AeshTestConnection> consumer) {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
consumer.accept(terminal);
}
}
}
| 8,050
| 34.157205
| 115
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/cli/CliCertIT.java
|
package org.infinispan.server.cli;
import static org.infinispan.server.test.core.AbstractInfinispanServerDriver.KEY_PASSWORD;
import java.io.File;
import java.util.Properties;
import org.infinispan.cli.commands.CLI;
import org.infinispan.cli.impl.AeshDelegatingShell;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.util.Util;
import org.infinispan.server.test.core.AeshTestConnection;
import org.infinispan.server.test.core.InfinispanServerDriver;
import org.infinispan.server.test.core.ServerRunMode;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 14.0
**/
public class CliCertIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationServerTrustTest.xml")
.runMode(ServerRunMode.CONTAINER)
.build();
private static File workingDir;
private static Properties properties;
@BeforeAll
public static void setup() {
workingDir = new File(CommonsTestingUtil.tmpDirectory(CliCertIT.class));
Util.recursiveFileRemove(workingDir);
workingDir.mkdirs();
properties = new Properties(System.getProperties());
properties.put("cli.dir", workingDir.getAbsolutePath());
}
@AfterAll
public static void teardown() {
Util.recursiveFileRemove(workingDir);
}
@Test
public void cliClientCert() {
InfinispanServerDriver driver = SERVERS.getServerDriver();
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{
"-t",
driver.getCertificateFile("ca.pfx").getAbsolutePath(),
"-s",
KEY_PASSWORD,
"-k",
driver.getCertificateFile("admin.pfx").getAbsolutePath(),
"-w",
KEY_PASSWORD,
"--hostname-verifier",
".*",
"-c",
"https://" + hostAddress() + ":11222"
}, properties);
terminal.assertContains("//containers/default]>");
terminal.clear();
}
}
@Test
public void connectClientCert() {
InfinispanServerDriver driver = SERVERS.getServerDriver();
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
terminal.assertContains("[disconnected]");
terminal.send(String.format("connect -t %s -s %s -k %s -w %s --hostname-verifier=.* https://%s:11222",
driver.getCertificateFile("ca.pfx").getAbsolutePath(),
KEY_PASSWORD,
driver.getCertificateFile("admin.pfx").getAbsolutePath(),
KEY_PASSWORD,
hostAddress()
));
terminal.assertContains("//containers/default]>");
terminal.clear();
}
}
private String hostAddress() {
return SERVERS.getServerDriver().getServerAddress(0).getHostAddress();
}
}
| 3,392
| 33.979381
| 111
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/cli/CliIT.java
|
package org.infinispan.server.cli;
import static org.infinispan.lock.impl.ClusteredLockModuleLifecycle.CLUSTERED_LOCK_CACHE_NAME;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.Properties;
import org.aesh.terminal.utils.Config;
import org.infinispan.cli.commands.CLI;
import org.infinispan.cli.impl.AeshDelegatingShell;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.util.Util;
import org.infinispan.server.test.api.TestUser;
import org.infinispan.server.test.core.AeshTestConnection;
import org.infinispan.server.test.core.AeshTestShell;
import org.infinispan.server.test.core.Common;
import org.infinispan.server.test.core.ServerRunMode;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CliIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthorizationImplicitTest.xml")
.mavenArtifacts(Common.NASHORN_DEPS)
.runMode(ServerRunMode.CONTAINER)
.build();
private static File workingDir;
private static Properties properties;
@BeforeAll
public static void setup() {
workingDir = new File(CommonsTestingUtil.tmpDirectory(CliIT.class));
Util.recursiveFileRemove(workingDir);
workingDir.mkdirs();
properties = new Properties(System.getProperties());
properties.put("cli.dir", workingDir.getAbsolutePath());
}
@AfterAll
public static void teardown() {
Util.recursiveFileRemove(workingDir);
}
@Test
public void testCliInteractive() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
terminal.send("echo Hi");
terminal.assertEquals("[disconnected]> echo Hi" + Config.getLineSeparator() + "Hi" + Config.getLineSeparator() + "[disconnected]> ");
terminal.clear();
connect(terminal);
terminal.send("stats");
terminal.assertContains("required_minimum_number_of_nodes");
terminal.clear();
terminal.send("create cache --template=org.infinispan.DIST_SYNC dcache");
terminal.send("cd caches/dcache");
terminal.assertContains("//containers/default/caches/dcache]>");
terminal.send("put k1 v1");
terminal.clear();
terminal.send("ls");
terminal.assertContains("k1");
terminal.send("get k1");
terminal.assertContains("v1");
terminal.clear();
terminal.send("get -x k1");
terminal.assertContains("cluster-primary-owner");
terminal.send("put --ttl=10 k2 v2");
terminal.clear();
terminal.send("describe k2");
terminal.assertContains("\"timetoliveseconds\" : [ \"10\" ]");
terminal.send("schema upload -f=" + getCliResource("person.proto").getPath() + " person.proto");
terminal.send("create cache --file=" + getCliResource("qcache.xml").getPath() + " qcache");
terminal.clear();
terminal.send("cd /containers/default/schemas");
terminal.send("ls");
terminal.assertContains("person.proto");
terminal.send("cache qcache");
terminal.assertContains("//containers/default/caches/qcache]>");
for (String person : Arrays.asList("jessicajones", "dannyrandy", "lukecage", "matthewmurdock")) {
terminal.send("put --encoding=application/json --file=" + getCliResource(person + ".json").getPath() + " " + person);
}
terminal.clear();
terminal.send("ls");
for (String person : Arrays.asList("jessicajones", "dannyrandy", "lukecage", "matthewmurdock")) {
terminal.assertContains(person);
}
terminal.clear();
terminal.send("query \"from org.infinispan.rest.search.entity.Person p where p.gender = 'MALE'\"");
terminal.assertContains("\"hit_count\":3,");
terminal.clear();
terminal.send("index stats qcache");
terminal.assertContains("\"slowest\" : \"from org.infinispan.rest.search.entity.Person p where p.gender = 'MALE'\"");
terminal.clear();
terminal.send("index clear qcache");
terminal.send("index reindex qcache");
terminal.send("index clear-stats qcache");
terminal.assertNotContains("Error");
terminal.clear();
terminal.send("stats");
terminal.assertContains("required_minimum_number_of_nodes");
// COUNTERS
terminal.send("create counter --type=strong --storage=PERSISTENT --upper-bound=100 cnt1");
terminal.send("cd /containers/default/counters/cnt1");
terminal.send("describe");
terminal.assertContains("\"upper-bound\" : \"100\"");
terminal.clear();
terminal.send("add");
terminal.assertContains("1");
terminal.clear();
terminal.send("reset");
terminal.send("ls");
terminal.assertContains("0");
terminal.clear();
terminal.send("add --delta=100");
terminal.assertContains("100");
// ALTER CACHE
terminal.send("create cache --file=" + getCliResource("xcache.xml").getPath() + " xcache");
terminal.send("describe /containers/default/caches/xcache");
terminal.assertContains("\"lifespan\" : \"60000\"");
terminal.assertContains("\"max-count\" : \"1000\"");
terminal.clear();
terminal.send("alter cache --file=" + getCliResource("xcache-alter.xml").getPath() + " xcache");
terminal.send("describe /containers/default/caches/xcache");
terminal.assertContains("\"lifespan\" : \"30000\"");
terminal.assertContains("\"max-count\" : \"2000\"");
terminal.clear();
terminal.send("alter cache xcache --attribute=memory.max-count --value=5000");
terminal.send("describe /containers/default/caches/xcache");
terminal.assertContains("\"lifespan\" : \"30000\"");
terminal.assertContains("\"max-count\" : \"5000\"");
terminal.clear();
}
}
@Test
public void testCliBatch() {
System.setProperty("serverAddress", hostAddress());
AeshTestShell shell = new AeshTestShell();
CLI.main(shell, new String[]{"-f", getCliResource("batch.cli").getPath()}, properties);
shell.assertContains("Hi CLI running on " + System.getProperty("os.arch"));
shell.assertContains("batch1");
}
@Test
public void testCliBatchError() {
System.setProperty("serverAddress", hostAddress());
AeshTestShell shell = new AeshTestShell();
CLI.main(shell, new String[]{"-f", getCliResource("batch-error.cli").getPath()}, properties);
shell.assertContains("Hi CLI running on " + System.getProperty("os.arch"));
shell.assertContains("batch-error.cli, line 2");
}
@Test
public void testCliBatchPreconnect() {
AeshTestShell shell = new AeshTestShell();
CLI.main(shell, new String[]{"-c", connectionUrl(), "-f", getCliResource("batch-preconnect.cli").getPath()}, properties);
shell.assertContains("Hi CLI");
shell.assertContains("batch2");
}
@Test
public void testCliTasks() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{"-c", connectionUrl()}, properties);
connect(terminal);
terminal.send("cd tasks");
terminal.send("ls");
terminal.assertContains("@@cache@names");
terminal.clear();
terminal.send("task exec @@cache@names");
terminal.assertContains("\"___script_cache\"");
terminal.clear();
File resource = getCliResource("hello.js");
terminal.send("task upload --file=" + resource.getPath() + " hello");
terminal.send("task exec hello -Pgreetee=world");
terminal.assertContains("\"Hello world\"");
}
}
@Test
public void testCliCredentials() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
String keyStore = Paths.get(System.getProperty("build.directory", ""), "key.store").toAbsolutePath().toString();
terminal.send("credentials add --path=" + keyStore + " --password=secret --credential=credential password");
terminal.send("credentials add --path=" + keyStore + " --password=secret --credential=credential another");
terminal.clear();
terminal.send("credentials ls --path=" + keyStore + " --password=secret");
terminal.assertContains("password");
terminal.assertContains("another");
}
}
@Test
public void testCliAuthorization() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
connect(terminal);
terminal.send("user roles ls");
terminal.assertContains("\"admin\"");
terminal.send("user roles create --permissions=ALL_WRITE wizard");
terminal.send("user roles create --permissions=ALL_READ cleric");
terminal.clear();
terminal.send("user roles ls");
terminal.assertContains("\"wizard\"");
terminal.assertContains("\"cleric\"");
terminal.send("user roles grant --roles=wizard,cleric,admin admin");
terminal.clear();
terminal.send("user roles ls admin");
terminal.assertContains("\"wizard\"");
terminal.assertContains("\"cleric\"");
terminal.send("user roles deny --roles=cleric admin");
terminal.clear();
terminal.send("user roles ls admin");
terminal.assertContains("\"wizard\"");
terminal.assertNotContains("\"cleric\"");
terminal.send("user roles remove wizard");
terminal.clear();
terminal.send("user roles ls");
terminal.assertContains("\"cleric\"");
terminal.assertNotContains("\"wizard\"");
}
}
private void connect(AeshTestConnection terminal) {
connect(terminal, TestUser.ADMIN);
}
private void connect(AeshTestConnection terminal, TestUser user) {
// connect
terminal.send("connect -u " + user.getUser() + " -p " + user.getPassword() + " " + hostAddress() + ":11222");
terminal.assertContains("//containers/default]>");
terminal.clear();
}
@Test
public void testCliUploadProtobufSchemas() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
// connect
connect(terminal);
// upload
terminal.send("schema upload --file=" + getCliResource("person.proto").getPath() + " person.proto");
terminal.assertContains("\"error\" : null");
terminal.clear();
terminal.send("cd /containers/default/schemas");
terminal.send("ls");
terminal.assertContains("person.proto");
terminal.clear();
terminal.send("schema ls");
terminal.assertContains("person.proto");
terminal.send("schema get person.proto");
terminal.assertContains("PhoneNumber");
terminal.send("schema remove person.proto");
terminal.clear();
terminal.send("schema ls");
terminal.assertContains("[]");
}
}
@Test
public void testCliHttpBenchmark() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
// no cache
terminal.send("benchmark " + connectionUrl());
terminal.assertContains("java.lang.IllegalArgumentException: Could not find cache");
}
}
@Test
public void testCliConfigPersistence() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
terminal.send("config set autoconnect-url " + connectionUrl());
terminal.clear();
terminal.send("config get autoconnect-url");
terminal.assertContains(connectionUrl());
}
// Close and recreate the CLI so that auto-connection kicks in
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
terminal.assertContains("//containers/default]>");
terminal.send("config set autoconnect-url");
}
}
@Test
public void testCliCacheAvailability() {
try (AeshTestConnection terminal = new AeshTestConnection()) {
CLI.main(new AeshDelegatingShell(terminal), new String[]{}, properties);
connect(terminal);
terminal.send("availability " + CLUSTERED_LOCK_CACHE_NAME);
terminal.assertContains("AVAILABLE");
terminal.send("availability --mode=DEGRADED_MODE " + CLUSTERED_LOCK_CACHE_NAME);
terminal.send("availability " + CLUSTERED_LOCK_CACHE_NAME);
terminal.assertContains("DEGRADED_MODE");
terminal.send("availability --mode=AVAILABILITY " + CLUSTERED_LOCK_CACHE_NAME);
terminal.send("availability " + CLUSTERED_LOCK_CACHE_NAME);
terminal.assertContains("AVAILABLE");
}
}
private String hostAddress() {
return SERVERS.getServerDriver().getServerAddress(0).getHostAddress();
}
private String connectionUrl() {
return connectionUrl(TestUser.ADMIN);
}
private String connectionUrl(TestUser user) {
return String.format("http://%s:%s@%s:11222", user.getUser(), user.getPassword(), hostAddress());
}
private File getCliResource(String resource) {
Path dest = workingDir.toPath().resolve(resource);
File destFile = dest.toFile();
if (destFile.exists())
return destFile;
// Copy jar resources to the local working directory so that the CLI can find the files when the test is executed
// by an external module
try (InputStream is = getClass().getResourceAsStream("/cli/" + resource)) {
Files.copy(is, dest);
return dest.toFile();
} catch (IOException e) {
throw new IllegalStateException(e);
}
}
}
| 14,879
| 40.104972
| 142
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationImplicitIT.java
|
package org.infinispan.server.security;
import static org.infinispan.server.test.core.Common.HTTP_MECHS;
import static org.infinispan.server.test.core.Common.HTTP_PROTOCOLS;
import static org.infinispan.server.test.core.Common.sync;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.exceptions.HotRodClientException;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.RestResponse;
import org.infinispan.client.rest.configuration.Protocol;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.Common;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
@Category(Security.class)
public class AuthenticationImplicitIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationServerImplicitTest.xml")
.addListener(new SecurityRealmServerListener("alternate"))
.build();
static class ArgsProvider implements ArgumentsProvider {
@Override
public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
List<Arguments> args = Common.SASL_MECHS.stream()
.map(mech -> Arguments.of("Hot Rod", mech))
.collect(Collectors.toList());
for (Protocol protocol : HTTP_PROTOCOLS) {
for (String mech : HTTP_MECHS) {
args.add(Arguments.of(protocol.name(), mech));
}
}
return args.stream();
}
}
@ParameterizedTest
@ArgumentsSource(ArgsProvider.class)
public void testProtocol(String protocol, String mechanism) {
if ("Hot Rod".equals(protocol)) {
testHotRod(mechanism);
} else {
testRest(Protocol.valueOf(protocol), mechanism);
}
}
public void testHotRod(String mechanism) {
ConfigurationBuilder builder = new ConfigurationBuilder();
if (!mechanism.isEmpty()) {
builder.security().authentication()
.saslMechanism(mechanism)
.realm("default")
.username("all_user")
.password("all");
}
try {
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
} catch (HotRodClientException e) {
// Rethrow if unexpected
if (!mechanism.isEmpty() && !"PLAIN".equals(mechanism)) throw e;
}
}
public void testRest(Protocol protocol, String mechanism) {
RestClientConfigurationBuilder builder = new RestClientConfigurationBuilder();
if (!mechanism.isEmpty()) {
builder
.protocol(protocol)
.security().authentication()
.mechanism(mechanism)
.realm("default")
.username("all_user")
.password("all");
}
if (mechanism.isEmpty() || "BASIC".equals(mechanism)) {
Exceptions.expectException(SecurityException.class, () -> SERVERS.rest().withClientConfiguration(builder).create());
} else {
RestClient client = SERVERS.rest().withClientConfiguration(builder).create();
try (RestResponse response = sync(client.cache(SERVERS.getMethodName()).post("k1", "v1"))) {
assertEquals(204, response.getStatus());
assertEquals(protocol, response.getProtocol());
}
try (RestResponse response = sync(client.cache(SERVERS.getMethodName()).get("k1"))) {
assertEquals(200, response.getStatus());
assertEquals(protocol, response.getProtocol());
assertEquals("v1", response.getBody());
}
}
}
}
| 4,882
| 39.02459
| 139
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/TLSWithoutAuthenticationIT.java
|
package org.infinispan.server.security;
import static org.infinispan.commons.test.Exceptions.expectException;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.nio.channels.ClosedChannelException;
import javax.net.ssl.SSLHandshakeException;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.exceptions.TransportException;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.Test;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
@Category(Security.class)
public class TLSWithoutAuthenticationIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/TLSWithoutAuthenticationTest.xml")
.build();
@Test
public void testHotRodReadWrite() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
@Test
public void testDisabledProtocol() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
builder.security().ssl().protocol("TLSv1.1");
try {
SERVERS.hotrod().withClientConfiguration(builder)
.withCacheMode(CacheMode.DIST_SYNC)
.create();
} catch (Throwable t) {
assertEquals(TransportException.class, t.getClass());
assertTrue(t.getCause() instanceof SSLHandshakeException || t.getCause() instanceof ClosedChannelException,
"Unexpected exception: " + t.getCause());
}
}
@Test
public void testDisabledCipherSuite() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
builder.security().ssl().ciphers("TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384");
expectException(TransportException.class, ClosedChannelException.class,
() -> SERVERS.hotrod().withClientConfiguration(builder)
.withCacheMode(CacheMode.DIST_SYNC)
.create());
}
@Test
public void testForceTLSv12() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
builder.security().ssl().protocol("TLSv1.2");
SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
}
@Test
public void testForceTLSv13() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
builder.security().ssl().protocol("TLSv1.3");
SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
}
}
| 3,600
| 40.390805
| 136
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationKeyCloakIT.java
|
package org.infinispan.server.security;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import org.infinispan.server.test.core.KeyCloakServerExtension;
import org.infinispan.server.test.core.TestSystemPropertyNames;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class AuthenticationKeyCloakIT extends AbstractAuthenticationKeyCloak {
@RegisterExtension
public static final InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationKeyCloakTest.xml")
.build();
@RegisterExtension
public static KeyCloakServerExtension KEYCLOAK = new KeyCloakServerExtension(System.getProperty(TestSystemPropertyNames.KEYCLOAK_REALM, "keycloak/infinispan-keycloak-realm.json"))
.addBeforeListener(k -> {
Path serverConfPath = SERVERS.getServerDriver().getConfDir().toPath();
Path keyCloakPath = k.getKeycloakDirectory().toPath();
try {
Files.copy(serverConfPath.resolve("ca.pfx.crt"), keyCloakPath.resolve("tls.crt"), StandardCopyOption.REPLACE_EXISTING);
Files.copy(serverConfPath.resolve("ca.pfx.key"), keyCloakPath.resolve("tls.key"), StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
throw new RuntimeException(e);
}
});
public AuthenticationKeyCloakIT() {
super(SERVERS);
}
@Override
protected String getToken() {
return KEYCLOAK.getAccessTokenForCredentials(INFINISPAN_REALM, INFINISPAN_CLIENT_ID, INFINISPAN_CLIENT_SECRET, "admin", "adminPassword", null, null);
}
}
| 1,928
| 40.042553
| 182
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/SecurityRealmServerListener.java
|
package org.infinispan.server.security;
import java.util.Collections;
import org.infinispan.cli.user.UserTool;
import org.infinispan.security.AuthorizationPermission;
import org.infinispan.server.test.api.TestUser;
import org.infinispan.server.test.core.InfinispanServerDriver;
import org.infinispan.server.test.core.InfinispanServerListener;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class SecurityRealmServerListener implements InfinispanServerListener {
private final String realm;
public SecurityRealmServerListener(String realmName) {
this.realm = realmName;
}
@Override
public void before(InfinispanServerDriver driver) {
UserTool userTool = new UserTool(driver.getRootDir().getAbsolutePath(), realm + "-users.properties", realm + "-groups.properties");
// Create users and groups for individual permissions
for (AuthorizationPermission permission : AuthorizationPermission.values()) {
String name = permission.name().toLowerCase();
userTool.createUser(username(name + "_user"), name, realm, UserTool.Encryption.DEFAULT, Collections.singletonList(name), null);
}
// Create users with composite roles
for (TestUser user : TestUser.values()) {
if (user != TestUser.ANONYMOUS) {
userTool.createUser(username(user.getUser()), user.getPassword(), realm, UserTool.Encryption.DEFAULT, user.getRoles(), null);
}
}
}
private String username(String name) {
return realm + "_" + name;
}
}
| 1,564
| 35.395349
| 137
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationKeyCloakSSLIT.java
|
package org.infinispan.server.security;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import org.infinispan.server.test.core.KeyCloakServerExtension;
import org.infinispan.server.test.core.TestSystemPropertyNames;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class AuthenticationKeyCloakSSLIT extends AbstractAuthenticationKeyCloak {
@RegisterExtension
public static final InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationKeyCloakSSLTest.xml")
.build();
@RegisterExtension
public static KeyCloakServerExtension KEYCLOAK = new KeyCloakServerExtension(System.getProperty(TestSystemPropertyNames.KEYCLOAK_REALM, "keycloak/infinispan-keycloak-realm.json"))
.addBeforeListener(k -> {
Path serverConfPath = SERVERS.getServerDriver().getConfDir().toPath();
Path keyCloakPath = k.getKeycloakDirectory().toPath();
try {
Files.copy(serverConfPath.resolve("ca.pfx.crt"), keyCloakPath.resolve("tls.crt"), StandardCopyOption.REPLACE_EXISTING);
Files.copy(serverConfPath.resolve("ca.pfx.key"), keyCloakPath.resolve("tls.key"), StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
throw new RuntimeException(e);
}
});
public AuthenticationKeyCloakSSLIT() {
super(SERVERS);
}
@Override
protected String getToken() {
return KEYCLOAK.getAccessTokenForCredentials(INFINISPAN_REALM, INFINISPAN_CLIENT_ID, INFINISPAN_CLIENT_SECRET, "admin", "adminPassword", SERVERS.getServerDriver().getCertificateFile("ca.pfx").toPath(), "secret");
}
}
| 2,000
| 41.574468
| 218
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationCertIT.java
|
package org.infinispan.server.security;
import static org.infinispan.client.rest.RestResponse.NO_CONTENT;
import static org.infinispan.client.rest.RestResponse.OK;
import static org.infinispan.server.test.core.Common.assertStatus;
import static org.infinispan.server.test.core.Common.assertStatusAndBodyContains;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.exceptions.TransportException;
import org.infinispan.client.rest.RestCacheClient;
import org.infinispan.client.rest.configuration.Protocol;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.Test;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
@Category(Security.class)
public class AuthenticationCertIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationServerTrustTest.xml")
.build();
@Test
public void testTrustedCertificateHotRod() {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.maxRetries(1).connectionPool().maxActive(1);
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
SERVERS.getServerDriver().applyKeyStore(builder, "admin.pfx");
builder.security()
.authentication()
.saslMechanism("EXTERNAL")
.serverName("infinispan")
.realm("default");
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
@Test
public void testUntrustedCertificateHotRod() {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.maxRetries(1).connectionPool().maxActive(1);
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
SERVERS.getServerDriver().applyKeyStore(builder, "untrusted.pfx");
builder.security()
.authentication()
.saslMechanism("EXTERNAL")
.serverName("infinispan")
.realm("default");
Exceptions.expectException(TransportException.class, () -> SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create());
}
@Test
public void testTrustedCertificateREST_HTTP11() {
testTrustedCertificateREST(Protocol.HTTP_11);
}
@Test
public void testTrustedCertificateREST_HTTP20() {
testTrustedCertificateREST(Protocol.HTTP_20);
}
private void testTrustedCertificateREST(Protocol protocol) {
RestClientConfigurationBuilder builder = new RestClientConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
SERVERS.getServerDriver().applyKeyStore(builder, "admin.pfx");
builder
.protocol(protocol)
.security()
.authentication()
.ssl()
.sniHostName("infinispan")
.hostnameVerifier((hostname, session) -> true).connectionTimeout(120_000).socketTimeout(120_000);
RestCacheClient cache = SERVERS.rest().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create().cache(SERVERS.getMethodName());
assertStatus(NO_CONTENT, cache.put("k1", "v1"));
assertStatusAndBodyContains(OK, "1", cache.size());
assertStatusAndBodyContains(OK, "v1", cache.get("k1"));
}
}
| 4,086
| 41.134021
| 160
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/TransportTLSIT.java
|
package org.infinispan.server.security;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.api.TestUser;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.Test;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* Tests transport TLS
*
* @author Pedro Ruivo
* @since 14.0
**/
@Category(Security.class)
public class TransportTLSIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/TransportTLSTest.xml")
.numServers(2)
.build();
@Test
public void testReadWrite() {
ConfigurationBuilder hotRodBuilder = new ConfigurationBuilder();
hotRodBuilder.security().authentication()
.serverName("infinispan")
.realm("default")
.username(TestUser.ADMIN.getUser())
.password(TestUser.ADMIN.getPassword());
RemoteCache<String, String> cache = SERVERS.hotrod()
.withClientConfiguration(hotRodBuilder)
.withCacheMode(CacheMode.DIST_SYNC)
.create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
}
| 1,647
| 33.333333
| 86
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationKerberosIT.java
|
package org.infinispan.server.security;
import static org.infinispan.server.test.core.Common.HTTP_KERBEROS_MECHS;
import static org.infinispan.server.test.core.Common.HTTP_PROTOCOLS;
import static org.infinispan.server.test.core.Common.sync;
import static org.junit.jupiter.api.Assertions.assertEquals;
import java.net.InetSocketAddress;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.exceptions.HotRodClientException;
import org.infinispan.client.hotrod.security.VoidCallbackHandler;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.RestResponse;
import org.infinispan.client.rest.configuration.Protocol;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.Common;
import org.infinispan.server.test.core.Krb5ConfPropertyExtension;
import org.infinispan.server.test.core.LdapServerListener;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.ArgumentsProvider;
import org.junit.jupiter.params.provider.ArgumentsSource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.1
**/
@Category(Security.class)
@ExtendWith(Krb5ConfPropertyExtension.class)
public class AuthenticationKerberosIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationKerberosTest.xml")
.numServers(1)
.property("java.security.krb5.conf", "${infinispan.server.config.path}/krb5.conf")
.addListener(new LdapServerListener(true))
.build();
static class ArgsProvider implements ArgumentsProvider {
@Override
public Stream<? extends Arguments> provideArguments(ExtensionContext context) throws Exception {
List<Arguments> args = Common.SASL_KERBEROS.stream()
.map(k -> Arguments.of("Hot Rod", k))
.collect(Collectors.toList());
for (Protocol protocol : HTTP_PROTOCOLS) {
for (String mech : HTTP_KERBEROS_MECHS) {
args.add(Arguments.of(protocol.name(), mech));
}
}
return args.stream();
}
}
@ParameterizedTest
@ArgumentsSource(ArgsProvider.class)
public void testProtocol(String protocol, String mechanism) {
if ("Hot Rod".equals(protocol)) {
testHotRod(mechanism);
} else {
testRest(Protocol.valueOf(protocol), mechanism);
}
}
public void testHotRod(String mechanism) {
ConfigurationBuilder builder = new ConfigurationBuilder();
if (!mechanism.isEmpty()) {
builder.security().authentication()
.saslMechanism(mechanism)
.serverName("datagrid")
.callbackHandler(new VoidCallbackHandler())
.clientSubject(Common.createSubject("admin", "INFINISPAN.ORG", "strongPassword".toCharArray()));
}
try {
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
} catch (HotRodClientException e) {
// Rethrow if unexpected
if (!mechanism.isEmpty()) throw e;
}
}
public void testRest(Protocol protocol, String mechanism) {
RestClientConfigurationBuilder builder = new RestClientConfigurationBuilder();
if (!mechanism.isEmpty()) {
builder
.protocol(protocol)
.security().authentication()
.mechanism(mechanism)
.clientSubject(Common.createSubject("admin", "INFINISPAN.ORG", "strongPassword".toCharArray()));
// Kerberos is strict about the hostname, so we do this by hand
InetSocketAddress serverAddress = SERVERS.getServerDriver().getServerSocket(0, 11222);
builder.addServer().host(serverAddress.getHostName()).port(serverAddress.getPort());
}
if (mechanism.isEmpty()) {
Exceptions.expectException(SecurityException.class, () -> SERVERS.rest().withClientConfiguration(builder).create());
} else {
RestClient client = SERVERS.rest().withClientConfiguration(builder).create();
try (RestResponse response = sync(client.cache(SERVERS.getMethodName()).post("k1", "v1"))) {
assertEquals(204, response.getStatus());
assertEquals(protocol, response.getProtocol());
}
try (RestResponse response = sync(client.cache(SERVERS.getMethodName()).get("k1"))) {
assertEquals(200, response.getStatus());
assertEquals(protocol, response.getProtocol());
assertEquals("v1", response.getBody());
}
}
}
}
| 5,685
| 43.077519
| 139
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationLDAPIT.java
|
package org.infinispan.server.security;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.exceptions.HotRodClientException;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.api.TestUser;
import org.infinispan.server.test.core.Common;
import org.infinispan.server.test.core.LdapServerListener;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ArgumentsSource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
@Category(Security.class)
public class AuthenticationLDAPIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationLDAPTest.xml")
.addListener(new LdapServerListener())
.build();
@ParameterizedTest
@ArgumentsSource(Common.SaslMechsArgumentProvider.class)
public void testReadWrite(String mechanism) {
ConfigurationBuilder builder = new ConfigurationBuilder();
if (!mechanism.isEmpty()) {
builder.security().authentication()
.saslMechanism(mechanism)
.serverName("infinispan")
.realm("default")
.username(TestUser.ADMIN.getUser())
.password(TestUser.ADMIN.getPassword());
}
try {
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
} catch (HotRodClientException e) {
// Rethrow if unexpected
if (!mechanism.isEmpty()) throw e;
}
}
}
| 2,267
| 38.789474
| 139
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationMultiRealmIT.java
|
package org.infinispan.server.security;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.exceptions.TransportException;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.api.TestUser;
import org.infinispan.server.test.core.LdapServerListener;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.Test;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
@Category(Security.class)
public class AuthenticationMultiRealmIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationMultiRealm.xml")
.addListener(new LdapServerListener())
.build();
public AuthenticationMultiRealmIT() {
}
@Test
public void testLDAP() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
builder.security().authentication()
.saslMechanism("SCRAM-SHA-256")
.serverName("infinispan")
.realm("default")
.username(TestUser.ADMIN.getUser())
.password(TestUser.ADMIN.getPassword());
performOperations(builder);
}
@Test
public void testProps() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
builder.security().authentication()
.saslMechanism("SCRAM-SHA-256")
.serverName("infinispan")
.realm("default")
.username("all_user")
.password("all");
performOperations(builder);
}
@Test
public void testCert() {
ConfigurationBuilder builder = new ConfigurationBuilder();
builder.maxRetries(1).connectionPool().maxActive(1);
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
SERVERS.getServerDriver().applyKeyStore(builder, "admin.pfx");
builder.security()
.authentication()
.saslMechanism("EXTERNAL")
.serverName("infinispan")
.realm("default");
performOperations(builder);
}
@Test
public void testUnknown() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
builder.security().authentication()
.saslMechanism("SCRAM-SHA-256")
.serverName("infinispan")
.realm("default")
.username("unknown")
.password("unknown");
Exceptions.expectException(".*ELY05161.*", () -> performOperations(builder), TransportException.class);
}
private void performOperations(ConfigurationBuilder builder) {
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
}
| 3,517
| 36.031579
| 136
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/CertWithoutAuthenticationIT.java
|
package org.infinispan.server.security;
import static org.junit.jupiter.api.Assertions.assertEquals;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.Test;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
@Category(Security.class)
public class CertWithoutAuthenticationIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/CertWithoutAuthenticationTest.xml")
.build();
@Test
public void testReadWrite() {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
SERVERS.getServerDriver().applyKeyStore(builder, "admin.pfx");
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
}
}
| 1,474
| 36.820513
| 136
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationAggregateRealmIT.java
|
package org.infinispan.server.security;
import static org.infinispan.client.rest.RestResponse.OK;
import static org.infinispan.server.test.core.Common.assertStatus;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.List;
import java.util.stream.Collectors;
import org.infinispan.client.rest.RestClient;
import org.infinispan.client.rest.configuration.RestClientConfigurationBuilder;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.server.test.core.ServerRunMode;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.jupiter.api.Test;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
@Category(Security.class)
public class AuthenticationAggregateRealmIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationAggregateRealm.xml")
.numServers(1)
.runMode(ServerRunMode.CONTAINER)
.build();
@Test
public void testAggregate() {
RestClientConfigurationBuilder builder = new RestClientConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
SERVERS.getServerDriver().applyKeyStore(builder, "admin.pfx");
builder
.security()
.ssl()
.sniHostName("infinispan")
.hostnameVerifier((hostname, session) -> true).connectionTimeout(50_000).socketTimeout(50_000);
RestClient client = SERVERS.rest().withClientConfiguration(builder).get();
Json acl = Json.read(assertStatus(OK, client.raw().get("/rest/v2/security/user/acl")));
Json subject = acl.asJsonMap().get("subject");
List<Object> names = subject.asJsonList().stream().map(j -> j.asMap().get("name")).collect(Collectors.toList());
assertEquals(4, names.size());
assertTrue(names.contains("CN=admin,OU=Infinispan,O=JBoss,L=Red Hat"));
assertTrue(names.contains("___script_manager"));
assertTrue(names.contains("admin"));
assertTrue(names.contains("___schema_manager"));
}
}
| 2,375
| 43.830189
| 118
|
java
|
null |
infinispan-main/server/tests/src/test/java/org/infinispan/server/security/AuthenticationTLSIT.java
|
package org.infinispan.server.security;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.client.hotrod.exceptions.HotRodClientException;
import org.infinispan.client.hotrod.security.BasicCallbackHandler;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.core.Common;
import org.infinispan.server.test.core.category.Security;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.junit.experimental.categories.Category;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ArgumentsSource;
import net.spy.memcached.ConnectionFactoryBuilder;
import net.spy.memcached.MemcachedClient;
import net.spy.memcached.auth.AuthDescriptor;
import net.spy.memcached.internal.OperationFuture;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
@Category(Security.class)
public class AuthenticationTLSIT {
@RegisterExtension
public static InfinispanServerExtension SERVERS =
InfinispanServerExtensionBuilder.config("configuration/AuthenticationServerTLSTest.xml")
.build();
@ParameterizedTest
@ArgumentsSource(Common.SaslMechsArgumentProvider.class)
public void testHotRodReadWrite(String mechanism) {
ConfigurationBuilder builder = new ConfigurationBuilder();
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
if (!mechanism.isEmpty()) {
builder.security().authentication()
.saslMechanism(mechanism)
.serverName("infinispan")
.realm("default")
.username("all_user")
.password("all");
}
try {
RemoteCache<String, String> cache = SERVERS.hotrod().withClientConfiguration(builder).withCacheMode(CacheMode.DIST_SYNC).create();
cache.put("k1", "v1");
assertEquals(1, cache.size());
assertEquals("v1", cache.get("k1"));
} catch (HotRodClientException e) {
// Rethrow if unexpected
if (!mechanism.isEmpty()) throw e;
}
}
@ParameterizedTest
@ArgumentsSource(Common.SaslMechsArgumentProvider.class)
public void testMemcachedReadWrite(String mechanism) throws ExecutionException, InterruptedException, TimeoutException {
ConnectionFactoryBuilder builder = new ConnectionFactoryBuilder();
builder.setProtocol(mechanism.isEmpty() ? ConnectionFactoryBuilder.Protocol.TEXT : ConnectionFactoryBuilder.Protocol.BINARY);
builder.setAuthDescriptor(new AuthDescriptor(new String[]{mechanism}, new BasicCallbackHandler("all_user", "default", "all".toCharArray())));
SERVERS.getServerDriver().applyTrustStore(builder, "ca.pfx");
MemcachedClient client = SERVERS.memcached().withClientConfiguration(builder).get();
OperationFuture<Boolean> f = client.set("k" + mechanism, 0, "v");
assertTrue(f.get(10, TimeUnit.SECONDS));
assertEquals(client.get("k" + mechanism), "v");
}
}
| 3,474
| 42.4375
| 147
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.