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/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/LegacyJBossMarshaller.java
|
package org.infinispan.tools.store.migrator.marshaller;
import org.infinispan.commons.marshall.StreamingMarshaller;
import org.infinispan.jboss.marshalling.commons.AbstractJBossMarshaller;
import org.infinispan.jboss.marshalling.commons.DefaultContextClassResolver;
import org.infinispan.jboss.marshalling.commons.SerializeWithExtFactory;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.jboss.marshalling.ObjectTable;
public class LegacyJBossMarshaller extends AbstractJBossMarshaller implements StreamingMarshaller {
public LegacyJBossMarshaller(ObjectTable objectTable) {
baseCfg.setClassExternalizerFactory(new SerializeWithExtFactory());
baseCfg.setObjectTable(objectTable);
baseCfg.setClassResolver(new DefaultContextClassResolver(GlobalConfigurationBuilder.class.getClassLoader()));
}
}
| 853
| 49.235294
| 115
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/SerializationConfigUtil.java
|
package org.infinispan.tools.store.migrator.marshaller;
import static org.infinispan.commons.util.Util.EMPTY_STRING_ARRAY;
import static org.infinispan.tools.store.migrator.Element.CLASS;
import static org.infinispan.tools.store.migrator.Element.CLASSES;
import static org.infinispan.tools.store.migrator.Element.CONTEXT_INITIALIZERS;
import static org.infinispan.tools.store.migrator.Element.ALLOW_LIST;
import static org.infinispan.tools.store.migrator.Element.EXTERNALIZERS;
import static org.infinispan.tools.store.migrator.Element.MARSHALLER;
import static org.infinispan.tools.store.migrator.Element.REGEXPS;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.infinispan.Cache;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.ClassAllowList;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.global.SerializationConfigurationBuilder;
import org.infinispan.factories.KnownComponentNames;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
import org.infinispan.marshall.persistence.impl.MarshalledEntryFactoryImpl;
import org.infinispan.persistence.spi.MarshallableEntryFactory;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.tools.store.migrator.StoreProperties;
import org.infinispan.tools.store.migrator.marshaller.infinispan10.Infinispan10Marshaller;
import org.infinispan.tools.store.migrator.marshaller.infinispan8.Infinispan8Marshaller;
import org.infinispan.tools.store.migrator.marshaller.infinispan9.Infinispan9Marshaller;
public class SerializationConfigUtil {
public static void configureSerialization(StoreProperties props, SerializationConfigurationBuilder builder) {
Marshaller marshaller = getMarshaller(props);
builder.marshaller(marshaller);
configureAllowList(props, builder);
configureExternalizers(props, builder);
configureSerializationContextInitializers(props, builder);
}
public static MarshallableEntryFactory getEntryFactory(StoreProperties props) {
return getEntryFactory(getMarshaller(props));
}
public static MarshallableEntryFactory getEntryFactory(Marshaller marshaller) {
return new MarshalledEntryFactoryImpl(marshaller);
}
public static Marshaller getMarshaller(StoreProperties props) {
int majorVersion = props.getMajorVersion();
if (props.isTargetStore() && majorVersion != Integer.parseInt(Version.getMajor())) {
throw new CacheConfigurationException(String.format("The marshaller associated with Infinispan %d can only be specified for source stores.", majorVersion));
}
if (majorVersion < 8 || majorVersion > Integer.parseInt(Version.getMajor())) {
throw new IllegalStateException(String.format("Unexpected major version '%d'", majorVersion));
}
Marshaller marshaller;
switch (majorVersion) {
case 8:
case 9:
marshaller = loadMarshallerInstance(props);
if (marshaller != null) {
return marshaller;
}
Map<Integer, AdvancedExternalizer> userExts = getExternalizersFromProps(props);
return majorVersion == 8 ? new Infinispan8Marshaller(userExts) : new Infinispan9Marshaller(userExts);
case 10:
case 11:
marshaller = loadMarshallerInstance(props);
return new Infinispan10Marshaller(marshaller, getSCIClasses(props));
default:
return props.isTargetStore() ? null : createPersistenceMarshaller(props);
}
}
private static PersistenceMarshaller createPersistenceMarshaller(StoreProperties props) {
GlobalConfigurationBuilder globalConfig = new GlobalConfigurationBuilder();
configureAllowList(props, globalConfig.serialization());
configureSerializationContextInitializers(props, globalConfig.serialization());
Marshaller marshaller = loadMarshallerInstance(props);
if (marshaller != null) {
globalConfig.serialization().marshaller(marshaller);
}
EmbeddedCacheManager manager = new DefaultCacheManager(globalConfig.build());
try {
Cache<Object, Object> cache = manager.createCache(props.cacheName(), new ConfigurationBuilder().build());
return cache.getAdvancedCache().getComponentRegistry()
.getComponent(PersistenceMarshaller.class, KnownComponentNames.PERSISTENCE_MARSHALLER);
} finally {
manager.stop();
}
}
private static Marshaller loadMarshallerInstance(StoreProperties props) {
String marshallerClass = props.get(MARSHALLER, CLASS);
if (marshallerClass != null) {
try {
Marshaller marshaller = (Marshaller) Util.loadClass(marshallerClass, SerializationConfigUtil.class.getClassLoader()).newInstance();
ClassAllowList allowList = new ClassAllowList();
allowList.addClasses(allowClasses(props));
allowList.addRegexps(allowRegexps(props));
marshaller.initialize(allowList);
return marshaller;
} catch (IllegalAccessException | InstantiationException e) {
throw new CacheConfigurationException(String.format("Unable to load StreamingMarshaller '%s' for %s store",
marshallerClass, SOURCE), e);
}
}
return null;
}
private static void configureAllowList(StoreProperties props, SerializationConfigurationBuilder builder) {
builder.allowList()
.addClasses(allowClasses(props))
.addRegexps(allowRegexps(props));
}
private static String[] allowClasses(StoreProperties props) {
return propToArray(props.get(MARSHALLER, ALLOW_LIST, CLASSES));
}
private static String[] allowRegexps(StoreProperties props) {
return propToArray(props.get(MARSHALLER, ALLOW_LIST, REGEXPS));
}
private static String[] propToArray(String prop) {
if (prop != null)
return prop.split(",");
return EMPTY_STRING_ARRAY;
}
private static void configureExternalizers(StoreProperties props, SerializationConfigurationBuilder builder) {
Map<Integer, AdvancedExternalizer> externalizerMap = getExternalizersFromProps(props);
if (externalizerMap == null)
return;
for (Map.Entry<Integer, AdvancedExternalizer> entry : externalizerMap.entrySet())
builder.addAdvancedExternalizer(entry.getKey(), entry.getValue());
}
// Expects externalizer string to be a comma-separated list of "<id>:<class>"
private static Map<Integer, AdvancedExternalizer> getExternalizersFromProps(StoreProperties props) {
Map<Integer, AdvancedExternalizer> map = new HashMap<>();
String externalizers = props.get(MARSHALLER, EXTERNALIZERS);
if (externalizers != null) {
for (String ext : externalizers.split(",")) {
String[] extArray = ext.split(":");
String className = extArray.length > 1 ? extArray[1] : extArray[0];
AdvancedExternalizer<?> instance = Util.getInstance(className, SerializationConfigUtil.class.getClassLoader());
int id = extArray.length > 1 ? new Integer(extArray[0]) : instance.getId();
map.put(id, instance);
}
}
return map;
}
private static void configureSerializationContextInitializers(StoreProperties props, SerializationConfigurationBuilder builder) {
getSCIClasses(props).forEach(builder::addContextInitializer);
}
public static List<SerializationContextInitializer> getSCIClasses(StoreProperties props) {
String sciString = props.get(MARSHALLER, CONTEXT_INITIALIZERS);
if (sciString == null)
return new ArrayList<>();
return Arrays.stream(sciString.split(","))
.map(impl -> Util.<SerializationContextInitializer>getInstance(impl, SerializationConfigUtil.class.getClassLoader()))
.collect(Collectors.toList());
}
}
| 8,541
| 44.679144
| 165
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan9/Infinispan9Marshaller.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan9;
import java.io.IOException;
import java.io.ObjectInput;
import java.lang.reflect.Array;
import java.util.List;
import java.util.Map;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.Externalizer;
import org.infinispan.container.entries.InternalCacheValue;
import org.infinispan.tools.store.migrator.marshaller.common.AbstractUnsupportedStreamingMarshaller;
/**
* Legacy marshaller for reading from Infinispan 9.x stores.
*
* @author Ryan Emerson
* @since 10.0
*/
public class Infinispan9Marshaller extends AbstractUnsupportedStreamingMarshaller {
private static final int ID_NULL = 0x00;
private static final int ID_PRIMITIVE = 0x01;
private static final int ID_INTERNAL = 0x02;
private static final int ID_EXTERNAL = 0x03;
private static final int ID_ANNOTATED = 0x04;
private static final int ID_UNKNOWN = 0x05;
private static final int ID_ARRAY = 0x06;
private static final int ID_CLASS = 0x07;
private static final int TYPE_MASK = 0x07;
private static final int ARRAY_SIZE_MASK = 0xC0;
private static final int FLAG_SINGLE_TYPE = 0x08;
private static final int FLAG_COMPONENT_TYPE_MATCH = 0x10;
private static final int FLAG_ALL_NULL = 0x20;
private static final int FLAG_ARRAY_EMPTY = 0x00;
private static final int FLAG_ARRAY_SMALL = 0x40;
private static final int FLAG_ARRAY_MEDIUM = 0x80;
private static final int FLAG_ARRAY_LARGE = 0xC0;
private final ExternalJbossMarshaller external;
private final Map<Integer, AdvancedExternalizer> exts;
public Infinispan9Marshaller(Map<Integer, AdvancedExternalizer> userExts) {
this.exts = ExternalizerTable.getInternalExternalizers(this);
this.exts.putAll(userExts);
this.external = new ExternalJbossMarshaller(this);
}
@Override
public Object objectFromByteBuffer(byte[] buf, int offset, int length) throws IOException, ClassNotFoundException {
return readNullableObject(new BytesObjectInput(buf, offset, this));
}
<T> Externalizer<T> findExternalizerIn(ObjectInput in) throws IOException {
int type = in.readUnsignedByte();
switch (type) {
case ID_INTERNAL:
return exts.get(in.readUnsignedByte());
case ID_EXTERNAL:
return exts.get(in.readInt());
default:
return null;
}
}
Object readNullableObject(BytesObjectInput in) throws IOException, ClassNotFoundException {
int type = in.readUnsignedByte();
if (type == ID_NULL)
return null;
switch (type) {
case ID_PRIMITIVE:
return Primitives.readPrimitive(in);
case ID_INTERNAL:
return exts.get(in.readUnsignedByte()).readObject(in);
case ID_EXTERNAL:
return exts.get(in.readInt()).readObject(in);
case ID_ANNOTATED:
return readAnnotated(in);
case ID_UNKNOWN:
return external.objectFromObjectStream(in);
case ID_ARRAY:
return readArray(in);
default:
throw new IOException("Unknown type: " + type);
}
}
private Object readAnnotated(BytesObjectInput in) throws IOException, ClassNotFoundException {
Class<? extends Externalizer> clazz = (Class<? extends Externalizer>) in.readObject();
try {
Externalizer ext = clazz.newInstance();
return ext.readObject(in);
} catch (Exception e) {
throw new CacheException("Error instantiating class: " + clazz, e);
}
}
private Object readArray(BytesObjectInput in) throws IOException, ClassNotFoundException {
int flags = in.readByte();
int type = flags & TYPE_MASK;
AdvancedExternalizer<?> componentExt = null;
Class<?> extClazz = null;
Class<?> componentType;
switch (type) {
case ID_NULL:
case ID_PRIMITIVE:
case ID_ARRAY:
throw new IOException("Unexpected component type: " + type);
case ID_INTERNAL:
componentExt = exts.get((int) in.readByte());
componentType = getOrReadClass(in, componentExt);
break;
case ID_EXTERNAL:
componentExt = exts.get(in.readInt());
componentType = getOrReadClass(in, componentExt);
break;
case ID_ANNOTATED:
extClazz = (Class<?>) in.readObject();
// intentional no break
case ID_UNKNOWN:
componentType = (Class<?>) in.readObject();
break;
case ID_CLASS:
componentType = getClass(in.readByte());
break;
default:
throw new IOException("Unknown component type: " + type);
}
int length;
int maskedSize = flags & ARRAY_SIZE_MASK;
switch (maskedSize) {
case FLAG_ARRAY_EMPTY:
length = 0;
break;
case FLAG_ARRAY_SMALL:
length = in.readUnsignedByte() + Primitives.SMALL_ARRAY_MIN;
break;
case FLAG_ARRAY_MEDIUM:
length = in.readUnsignedShort() + Primitives.MEDIUM_ARRAY_MIN;
break;
case FLAG_ARRAY_LARGE:
length = in.readInt();
break;
default:
throw new IOException("Unknown array size: " + maskedSize);
}
Object array = Array.newInstance(componentType, length);
if ((flags & FLAG_ALL_NULL) != 0) {
return array;
}
boolean singleType = (flags & FLAG_SINGLE_TYPE) != 0;
boolean componentTypeMatch = (flags & FLAG_COMPONENT_TYPE_MATCH) != 0;
// If component type match is set, this must be a single type
assert !componentTypeMatch || singleType;
if (singleType) {
Externalizer<?> ext;
if (componentTypeMatch) {
ext = getArrayElementExternalizer(type, componentExt, extClazz);
} else {
type = in.readByte();
ext = readExternalizer(in, type);
}
if (ext != null) {
for (int i = 0; i < length; ++i) {
Array.set(array, i, ext.readObject(in));
}
} else {
switch (type) {
case ID_UNKNOWN:
for (int i = 0; i < length; ++i) {
Array.set(array, i, external.objectFromObjectStream(in));
}
return array;
case ID_PRIMITIVE:
int primitiveId = in.readByte();
for (int i = 0; i < length; ++i) {
Array.set(array, i, Primitives.readRawPrimitive(in, primitiveId));
}
return array;
default:
throw new IllegalStateException();
}
}
} else {
for (int i = 0; i < length; ++i) {
Array.set(array, i, readNullableObject(in));
}
}
return array;
}
private Class<?> getClass(int id) throws IOException {
switch (id) {
case 0: return Object.class;
case 1: return String.class;
case 2: return List.class;
case 3: return Map.Entry.class;
case 16: return InternalCacheValue.class;
default: throw new IOException("Unknown class id " + id);
}
}
private Externalizer<?> getArrayElementExternalizer(int type, AdvancedExternalizer<?> componentExt, Class<?> extClazz) throws IOException {
switch (type) {
case ID_INTERNAL:
case ID_EXTERNAL:
return componentExt;
case ID_ANNOTATED:
try {
return (Externalizer<?>) extClazz.newInstance();
} catch (Exception e) {
throw new CacheException("Error instantiating class: " + extClazz, e);
}
case ID_UNKNOWN:
return null;
default:
throw new IOException("Unexpected component type: " + type);
}
}
private Externalizer<?> readExternalizer(BytesObjectInput in, int type) throws ClassNotFoundException, IOException {
Class<?> extClazz;
switch (type) {
case ID_INTERNAL:
return exts.get(0xFF & in.readByte());
case ID_EXTERNAL:
return exts.get(in.readInt());
case ID_ANNOTATED:
extClazz = (Class<?>) in.readObject();
try {
return (Externalizer<?>) extClazz.newInstance();
} catch (Exception e) {
throw new CacheException("Error instantiating class: " + extClazz, e);
}
case ID_UNKNOWN:
case ID_PRIMITIVE:
return null;
default:
throw new IOException("Unexpected component type: " + type);
}
}
private Class<?> getOrReadClass(BytesObjectInput in, AdvancedExternalizer<?> componentExt) throws ClassNotFoundException, IOException {
if (componentExt.getTypeClasses().size() == 1) {
return componentExt.getTypeClasses().iterator().next();
} else {
return (Class<?>) in.readObject();
}
}
}
| 9,199
| 35.078431
| 142
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan9/ExternalizerTable.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan9;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.infinispan.commons.io.ByteBufferImpl;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.util.Immutables;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.container.versioning.SimpleClusteredVersion;
import org.infinispan.marshall.exts.CollectionExternalizer;
import org.infinispan.marshall.exts.EnumSetExternalizer;
import org.infinispan.marshall.exts.MapExternalizer;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.tools.store.migrator.marshaller.common.ImmortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.ImmortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.InternalMetadataImplExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MarshalledEntryImpl;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataImmortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataImmortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataMortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataMortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientMortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientMortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientMortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientMortalCacheValueExternalizer;
import org.infinispan.util.KeyValuePair;
/**
* Legacy externalizers for Infinispan 9.
*
* @author Ryan Emerson
* @since 10.0
*/
class ExternalizerTable {
private static final int INTERNAL_METADATA = 61;
private static final Set<AdvancedExternalizer> INTERNAL_EXTERNALIZERS = new HashSet<>(26);
static {
INTERNAL_EXTERNALIZERS.add(new CollectionExternalizer());
INTERNAL_EXTERNALIZERS.add(new MapExternalizer());
INTERNAL_EXTERNALIZERS.add(new EnumSetExternalizer());
INTERNAL_EXTERNALIZERS.add(new Immutables.ImmutableMapWrapperExternalizer());
INTERNAL_EXTERNALIZERS.add(new ByteBufferImpl.Externalizer());
INTERNAL_EXTERNALIZERS.add(new NumericVersion.Externalizer());
INTERNAL_EXTERNALIZERS.add(new KeyValuePair.Externalizer());
INTERNAL_EXTERNALIZERS.add(new InternalMetadataImplExternalizer(INTERNAL_METADATA));
INTERNAL_EXTERNALIZERS.add(new ImmortalCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new MortalCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new TransientCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new TransientMortalCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new ImmortalCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new MortalCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new TransientCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new TransientMortalCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new SimpleClusteredVersion.Externalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataImmortalCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataMortalCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataTransientCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataTransientMortalCacheEntryExternalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataImmortalCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataMortalCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataTransientCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new MetadataTransientMortalCacheValueExternalizer());
INTERNAL_EXTERNALIZERS.add(new EmbeddedMetadata.Externalizer());
}
static Map<Integer, AdvancedExternalizer> getInternalExternalizers(Marshaller marshaller) {
Set<AdvancedExternalizer> initializedExternalizers = new HashSet<>(INTERNAL_EXTERNALIZERS);
initializedExternalizers.add(new MarshalledEntryImpl.Externalizer(marshaller));
return initializedExternalizers.stream().collect(Collectors.toMap(AdvancedExternalizer::getId, Function.identity()));
}
}
| 5,204
| 60.964286
| 123
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan9/BytesObjectInput.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan9;
import java.io.IOException;
import org.infinispan.marshall.core.AbstractBytesObjectInput;
class BytesObjectInput extends AbstractBytesObjectInput {
private final Infinispan9Marshaller marshaller;
BytesObjectInput(byte[] bytes, int offset, Infinispan9Marshaller marshaller) {
super(bytes, offset);
this.marshaller = marshaller;
}
@Override
public Object readObject() throws ClassNotFoundException, IOException {
return marshaller.readNullableObject(this);
}
}
| 569
| 26.142857
| 81
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan9/Primitives.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan9;
import java.io.EOFException;
import java.io.IOException;
final class Primitives {
// 0x03-0x0F reserved
private static final int ID_BYTE_ARRAY = 0x01; // byte[].class
private static final int ID_STRING = 0x02; // String.class
private static final int ID_BOOLEAN_OBJ = 0x10; // Boolean.class
private static final int ID_BYTE_OBJ = 0x11; // ..etc..
private static final int ID_CHAR_OBJ = 0x12;
private static final int ID_DOUBLE_OBJ = 0x13;
private static final int ID_FLOAT_OBJ = 0x14;
private static final int ID_INT_OBJ = 0x15;
private static final int ID_LONG_OBJ = 0x16;
private static final int ID_SHORT_OBJ = 0x17;
private static final int ID_BOOLEAN_ARRAY = 0x18; // boolean[].class
private static final int ID_CHAR_ARRAY = 0x19; // ..etc..
private static final int ID_DOUBLE_ARRAY = 0x1A;
private static final int ID_FLOAT_ARRAY = 0x1B;
private static final int ID_INT_ARRAY = 0x1C;
private static final int ID_LONG_ARRAY = 0x1D;
private static final int ID_SHORT_ARRAY = 0x1E;
// 0x1F-0x27 unused
private static final int ID_ARRAY_EMPTY = 0x28; // zero elements
private static final int ID_ARRAY_SMALL = 0x29; // <=0x100 elements
private static final int ID_ARRAY_MEDIUM = 0x2A; // <=0x10000 elements
private static final int ID_ARRAY_LARGE = 0x2B; // <0x80000000 elements
static final int SMALL_ARRAY_MIN = 0x1;
static final int MEDIUM_ARRAY_MIN = 0x101;
private Primitives() {
}
static Object readPrimitive(BytesObjectInput in) throws IOException {
int subId = in.readUnsignedByte();
return readRawPrimitive(in, subId);
}
static Object readRawPrimitive(BytesObjectInput in, int subId) throws IOException {
switch (subId) {
case ID_BYTE_ARRAY:
return readByteArray(in);
case ID_STRING:
return in.readString();
case ID_BOOLEAN_OBJ:
return in.readBoolean();
case ID_BYTE_OBJ:
return in.readByte();
case ID_CHAR_OBJ:
return in.readChar();
case ID_DOUBLE_OBJ:
return in.readDouble();
case ID_FLOAT_OBJ:
return in.readFloat();
case ID_INT_OBJ:
return in.readInt();
case ID_LONG_OBJ:
return in.readLong();
case ID_SHORT_OBJ:
return in.readShort();
case ID_BOOLEAN_ARRAY:
return readBooleanArray(in);
case ID_CHAR_ARRAY:
return readCharArray(in);
case ID_DOUBLE_ARRAY:
return readDoubleArray(in);
case ID_FLOAT_ARRAY:
return readFloatArray(in);
case ID_INT_ARRAY:
return readIntArray(in);
case ID_LONG_ARRAY:
return readLongArray(in);
case ID_SHORT_ARRAY:
return readShortArray(in);
default:
throw new IOException("Unknown primitive sub id: " + Integer.toHexString(subId));
}
}
private static byte[] readByteArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new byte[]{};
case ID_ARRAY_SMALL:
return readFully(mkByteArray(in.readUnsignedByte() + SMALL_ARRAY_MIN), in);
case ID_ARRAY_MEDIUM:
return readFully(mkByteArray(in.readUnsignedShort() + MEDIUM_ARRAY_MIN), in);
case ID_ARRAY_LARGE:
return readFully(new byte[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static byte[] mkByteArray(int len) {
return new byte[len];
}
private static byte[] readFully(byte[] arr, BytesObjectInput in) throws EOFException {
in.readFully(arr);
return arr;
}
private static boolean[] readBooleanArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new boolean[]{};
case ID_ARRAY_SMALL:
return readBooleans(mkBooleanArray(in.readUnsignedByte() + SMALL_ARRAY_MIN), in);
case ID_ARRAY_MEDIUM:
return readBooleans(mkBooleanArray(in.readUnsignedShort() + MEDIUM_ARRAY_MIN), in);
case ID_ARRAY_LARGE:
return readBooleans(new boolean[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static boolean[] mkBooleanArray(int len) {
return new boolean[len];
}
private static boolean[] readBooleans(boolean[] arr, BytesObjectInput in) throws EOFException {
final int len = arr.length;
int v;
int bc = len & ~7;
for (int i = 0; i < bc; ) {
v = in.readByte();
arr[i++] = (v & 1) != 0;
arr[i++] = (v & 2) != 0;
arr[i++] = (v & 4) != 0;
arr[i++] = (v & 8) != 0;
arr[i++] = (v & 16) != 0;
arr[i++] = (v & 32) != 0;
arr[i++] = (v & 64) != 0;
arr[i++] = (v & 128) != 0;
}
if (bc < len) {
v = in.readByte();
switch (len & 7) {
case 7:
arr[bc + 6] = (v & 64) != 0;
case 6:
arr[bc + 5] = (v & 32) != 0;
case 5:
arr[bc + 4] = (v & 16) != 0;
case 4:
arr[bc + 3] = (v & 8) != 0;
case 3:
arr[bc + 2] = (v & 4) != 0;
case 2:
arr[bc + 1] = (v & 2) != 0;
case 1:
arr[bc] = (v & 1) != 0;
}
}
return arr;
}
private static char[] readCharArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new char[]{};
case ID_ARRAY_SMALL:
return readChars(mkCharArray(in.readUnsignedByte() + SMALL_ARRAY_MIN), in);
case ID_ARRAY_MEDIUM:
return readChars(mkCharArray(in.readUnsignedShort() + MEDIUM_ARRAY_MIN), in);
case ID_ARRAY_LARGE:
return readChars(new char[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static char[] mkCharArray(int len) {
return new char[len];
}
private static char[] readChars(char[] arr, BytesObjectInput in) throws EOFException {
final int len = arr.length;
for (int i = 0; i < len; i ++) arr[i] = in.readChar();
return arr;
}
private static double[] readDoubleArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new double[]{};
case ID_ARRAY_SMALL:
return readDoubles(new double[in.readUnsignedByte() + SMALL_ARRAY_MIN], in);
case ID_ARRAY_MEDIUM:
return readDoubles(new double[in.readUnsignedShort() + MEDIUM_ARRAY_MIN], in);
case ID_ARRAY_LARGE:
return readDoubles(new double[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static double[] readDoubles(double[] arr, BytesObjectInput in) throws EOFException {
final int len = arr.length;
for (int i = 0; i < len; i ++) arr[i] = in.readDouble();
return arr;
}
private static float[] readFloatArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new float[]{};
case ID_ARRAY_SMALL:
return readFloats(new float[in.readUnsignedByte() + SMALL_ARRAY_MIN], in);
case ID_ARRAY_MEDIUM:
return readFloats(new float[in.readUnsignedShort() + MEDIUM_ARRAY_MIN], in);
case ID_ARRAY_LARGE:
return readFloats(new float[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static float[] readFloats(float[] arr, BytesObjectInput in) throws EOFException {
final int len = arr.length;
for (int i = 0; i < len; i ++) arr[i] = in.readFloat();
return arr;
}
private static int[] readIntArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new int[]{};
case ID_ARRAY_SMALL:
return readInts(new int[in.readUnsignedByte() + SMALL_ARRAY_MIN], in);
case ID_ARRAY_MEDIUM:
return readInts(new int[in.readUnsignedShort() + MEDIUM_ARRAY_MIN], in);
case ID_ARRAY_LARGE:
return readInts(new int[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static int[] readInts(int[] arr, BytesObjectInput in) throws EOFException {
final int len = arr.length;
for (int i = 0; i < len; i ++) arr[i] = in.readInt();
return arr;
}
private static long[] readLongArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new long[]{};
case ID_ARRAY_SMALL:
return readLongs(new long[in.readUnsignedByte() + SMALL_ARRAY_MIN], in);
case ID_ARRAY_MEDIUM:
return readLongs(new long[in.readUnsignedShort() + MEDIUM_ARRAY_MIN], in);
case ID_ARRAY_LARGE:
return readLongs(new long[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static long[] readLongs(long[] arr, BytesObjectInput in) throws EOFException {
final int len = arr.length;
for (int i = 0; i < len; i ++) arr[i] = in.readLong();
return arr;
}
private static short[] readShortArray(BytesObjectInput in) throws IOException {
byte type = in.readByte();
switch (type) {
case ID_ARRAY_EMPTY:
return new short[]{};
case ID_ARRAY_SMALL:
return readShorts(new short[in.readUnsignedByte() + SMALL_ARRAY_MIN], in);
case ID_ARRAY_MEDIUM:
return readShorts(new short[in.readUnsignedShort() + MEDIUM_ARRAY_MIN], in);
case ID_ARRAY_LARGE:
return readShorts(new short[in.readInt()], in);
default:
throw new IOException("Unknown array type: " + Integer.toHexString(type));
}
}
private static short[] readShorts(short[] arr, BytesObjectInput in) throws EOFException {
final int len = arr.length;
for (int i = 0; i < len; i ++) arr[i] = in.readShort();
return arr;
}
}
| 11,368
| 36.153595
| 98
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan9/ExternalJbossMarshaller.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan9;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import org.infinispan.commons.marshall.Externalizer;
import org.infinispan.jboss.marshalling.commons.ExtendedRiverUnmarshaller;
import org.infinispan.tools.store.migrator.marshaller.LegacyJBossMarshaller;
import org.infinispan.tools.store.migrator.marshaller.common.AbstractUnsupportedStreamingMarshaller;
import org.jboss.marshalling.ObjectTable;
import org.jboss.marshalling.Unmarshaller;
class ExternalJbossMarshaller extends AbstractUnsupportedStreamingMarshaller {
private final LegacyJBossMarshaller jbossMarshaller;
ExternalJbossMarshaller(Infinispan9Marshaller marshaller) {
this.jbossMarshaller = new LegacyJBossMarshaller(new ObjectTable() {
@Override
public Writer getObjectWriter(Object object) {
return null;
}
@Override
public Object readObject(Unmarshaller unmarshaller) throws IOException, ClassNotFoundException {
Externalizer<Object> ext = marshaller.findExternalizerIn(unmarshaller);
return ext == null ? null : ext.readObject(unmarshaller);
}
});
}
@Override
public Object objectFromObjectStream(ObjectInput in) throws IOException, ClassNotFoundException {
ExtendedRiverUnmarshaller jbossIn = (ExtendedRiverUnmarshaller)
jbossMarshaller.startObjectInput(new InputStream() {
@Override
public int read() throws IOException {
return in.read();
}
@Override
public int read(byte[] b, int off, int len) throws IOException {
return in.read(b, off, len);
}
}, false);
try {
return jbossIn.readObject();
} finally {
// Rewind by skipping backwards (negatively)
in.skipBytes(-jbossIn.getUnreadBufferedCount());
jbossMarshaller.finishObjectInput(jbossIn);
}
}
}
| 2,061
| 35.821429
| 105
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/AbstractUnsupportedStreamingMarshaller.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.io.OutputStream;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.commons.io.ByteBuffer;
import org.infinispan.commons.marshall.AbstractMarshaller;
import org.infinispan.commons.marshall.StreamingMarshaller;
/**
* An implementation of {@link AbstractMarshaller} that throws {@link UnsupportedOperationException} for all methods.
*
* @author Ryan Emerson
* @since 10.0
*/
abstract public class AbstractUnsupportedStreamingMarshaller extends AbstractMarshaller implements StreamingMarshaller {
@Override
public void start() {
}
@Override
public void stop() {
}
@Override
protected ByteBuffer objectToBuffer(Object o, int estimatedSize) throws IOException, InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public ObjectOutput startObjectOutput(OutputStream os, boolean isReentrant, int estimatedSize) throws IOException {
throw new UnsupportedOperationException();
}
@Override
public void finishObjectOutput(ObjectOutput oo) {
throw new UnsupportedOperationException();
}
@Override
public void objectToObjectStream(Object obj, ObjectOutput out) throws IOException {
throw new UnsupportedOperationException();
}
@Override
public ObjectInput startObjectInput(InputStream is, boolean isReentrant) throws IOException {
throw new UnsupportedOperationException();
}
@Override
public void finishObjectInput(ObjectInput oi) {
throw new UnsupportedOperationException();
}
@Override
public Object objectFromObjectStream(ObjectInput in) throws IOException, ClassNotFoundException, InterruptedException {
throw new UnsupportedOperationException();
}
@Override
public Object objectFromByteBuffer(byte[] buf, int offset, int length) throws IOException, ClassNotFoundException {
throw new UnsupportedOperationException();
}
@Override
public boolean isMarshallable(Object o) throws Exception {
throw new UnsupportedOperationException();
}
@Override
public MediaType mediaType() {
throw new UnsupportedOperationException();
}
}
| 2,342
| 28.2875
| 122
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/ImmortalCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.ImmortalCacheEntry;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link ImmortalCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class ImmortalCacheEntryExternalizer implements AdvancedExternalizer<ImmortalCacheEntry> {
@Override
public Set<Class<? extends ImmortalCacheEntry>> getTypeClasses() {
return Collections.singleton(ImmortalCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.IMMORTAL_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, ImmortalCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
}
@Override
public ImmortalCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
return new ImmortalCacheEntry(key, value);
}
}
| 1,240
| 26.577778
| 103
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MortalCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.MortalCacheEntry;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link MortalCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MortalCacheEntryExternalizer implements AdvancedExternalizer<MortalCacheEntry> {
@Override
public Set<Class<? extends MortalCacheEntry>> getTypeClasses() {
return Collections.singleton(MortalCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.MORTAL_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, MortalCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
UnsignedNumeric.writeUnsignedLong(output, ice.getCreated());
output.writeLong(ice.getLifespan());
}
@Override
public MortalCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
long lifespan = input.readLong();
return new MortalCacheEntry(key, value, lifespan, created);
}
}
| 1,501
| 29.04
| 101
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataTransientMortalCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataTransientMortalCacheValue;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataTransientMortalCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataTransientMortalCacheValueExternalizer implements AdvancedExternalizer<MetadataTransientMortalCacheValue> {
@Override
public Set<Class<? extends MetadataTransientMortalCacheValue>> getTypeClasses() {
return Collections.singleton(MetadataTransientMortalCacheValue.class);
}
@Override
public Integer getId() {
return Ids.METADATA_TRANSIENT_MORTAL_VALUE;
}
@Override
public void writeObject(ObjectOutput output, MetadataTransientMortalCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
output.writeObject(icv.getMetadata());
UnsignedNumeric.writeUnsignedLong(output, icv.getCreated());
UnsignedNumeric.writeUnsignedLong(output, icv.getLastUsed());
}
@Override
public MetadataTransientMortalCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
return new MetadataTransientMortalCacheValue(value, metadata, created, lastUsed);
}
}
| 1,799
| 34.294118
| 127
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/TransientMortalCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.TransientMortalCacheValue;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link TransientMortalCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class TransientMortalCacheValueExternalizer implements AdvancedExternalizer<TransientMortalCacheValue> {
@Override
public Set<Class<? extends TransientMortalCacheValue>> getTypeClasses() {
return Collections.singleton(TransientMortalCacheValue.class);
}
@Override
public Integer getId() {
return Ids.TRANSIENT_MORTAL_VALUE;
}
@Override
public void writeObject(ObjectOutput output, TransientMortalCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
UnsignedNumeric.writeUnsignedLong(output, icv.getCreated());
output.writeLong(icv.getLifespan());
UnsignedNumeric.writeUnsignedLong(output, icv.getLastUsed());
output.writeLong(icv.getMaxIdle());
}
@Override
public TransientMortalCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
long lifespan = input.readLong();
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
long maxIdle = input.readLong();
return new TransientMortalCacheValue(value, created, lifespan, maxIdle, lastUsed);
}
}
| 1,739
| 32.461538
| 111
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MarshalledEntryImpl.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Set;
import org.infinispan.commons.io.ByteBuffer;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.marshall.Ids;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.util.Util;
import org.infinispan.metadata.InternalMetadata;
import org.infinispan.persistence.spi.PersistenceException;
/**
* @author Mircea Markus
* @since 6.0
*/
public class MarshalledEntryImpl<K,V> {
private ByteBuffer keyBytes;
private ByteBuffer valueBytes;
private ByteBuffer metadataBytes;
private transient K key;
private transient V value;
private transient InternalMetadata metadata;
private final transient Marshaller marshaller;
MarshalledEntryImpl(ByteBuffer key, ByteBuffer valueBytes, ByteBuffer metadataBytes, Marshaller marshaller) {
this.keyBytes = key;
this.valueBytes = valueBytes;
this.metadataBytes = metadataBytes;
this.marshaller = marshaller;
}
public K getKey() {
if (key == null) {
if (keyBytes == null) {
return null;
}
key = unmarshall(keyBytes);
}
return key;
}
public V getValue() {
if (value == null) {
if (valueBytes == null) {
return null;
}
value = unmarshall(valueBytes);
}
return value;
}
public InternalMetadata getMetadata() {
if (metadata == null) {
if (metadataBytes == null)
return null;
else
metadata = unmarshall(metadataBytes);
}
return metadata;
}
public ByteBuffer getKeyBytes() {
if (keyBytes == null) {
if (key == null) {
return null;
}
keyBytes = marshall(key);
}
return keyBytes;
}
public ByteBuffer getValueBytes() {
if (valueBytes == null) {
if (value == null) {
return null;
}
valueBytes = marshall(value);
}
return valueBytes;
}
public ByteBuffer getMetadataBytes() {
if (metadataBytes == null) {
if (metadata == null)
return null;
metadataBytes = marshall(metadata);
}
return metadataBytes;
}
private ByteBuffer marshall(Object obj) {
try {
return marshaller.objectToBuffer(obj);
} catch (Exception e) {
throw new PersistenceException(e);
}
}
@SuppressWarnings(value = "unchecked")
private <T> T unmarshall(ByteBuffer buf) {
try {
return (T) marshaller.objectFromByteBuffer(buf.getBuf(), buf.getOffset(), buf.getLength());
} catch (Exception e) {
throw new PersistenceException(e);
}
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof MarshalledEntryImpl)) return false;
MarshalledEntryImpl that = (MarshalledEntryImpl) o;
if (getKeyBytes() != null ? !getKeyBytes().equals(that.getKeyBytes()) : that.getKeyBytes() != null) return false;
if (getMetadataBytes() != null ? !getMetadataBytes().equals(that.getMetadataBytes()) : that.getMetadataBytes() != null) return false;
if (getValueBytes() != null ? !getValueBytes().equals(that.getValueBytes()) : that.getValueBytes() != null) return false;
return true;
}
@Override
public int hashCode() {
int result = getKeyBytes() != null ? getKeyBytes().hashCode() : 0;
result = 31 * result + (getValueBytes() != null ? getValueBytes().hashCode() : 0);
result = 31 * result + (getMetadataBytes() != null ? getMetadataBytes().hashCode() : 0);
return result;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder().append("MarshalledEntryImpl{")
.append("keyBytes=").append(keyBytes)
.append(", valueBytes=").append(valueBytes)
.append(", metadataBytes=").append(metadataBytes)
.append(", key=").append(key);
if (key == null && keyBytes != null && marshaller != null) {
sb.append('/').append(this.<Object>unmarshall(keyBytes));
}
sb.append(", value=").append(value);
if (value == null && valueBytes != null && marshaller != null) {
sb.append('/').append(this.<Object>unmarshall(valueBytes));
}
sb.append(", metadata=").append(metadata);
if (metadata == null && metadataBytes != null && marshaller != null) {
sb.append('/').append(this.<Object>unmarshall(metadataBytes));
}
sb.append(", marshaller=").append(marshaller).append('}');
return sb.toString();
}
public static class Externalizer extends AbstractExternalizer<MarshalledEntryImpl> {
private static final long serialVersionUID = -5291318076267612501L;
private final Marshaller marshaller;
public Externalizer(Marshaller marshaller) {
this.marshaller = marshaller;
}
@Override
public void writeObject(ObjectOutput output, MarshalledEntryImpl me) throws IOException {
output.writeObject(me.getKeyBytes());
output.writeObject(me.getValueBytes());
output.writeObject(me.getMetadataBytes());
}
@Override
public MarshalledEntryImpl readObject(ObjectInput input) throws IOException, ClassNotFoundException {
ByteBuffer keyBytes = (ByteBuffer) input.readObject();
ByteBuffer valueBytes = (ByteBuffer) input.readObject();
ByteBuffer metadataBytes = (ByteBuffer) input.readObject();
return new MarshalledEntryImpl(keyBytes, valueBytes, metadataBytes, marshaller);
}
@Override
public Integer getId() {
return Ids.MARSHALLED_ENTRY_ID;
}
@Override
@SuppressWarnings("unchecked")
public Set<Class<? extends MarshalledEntryImpl>> getTypeClasses() {
return Util.<Class<? extends MarshalledEntryImpl>>asSet(MarshalledEntryImpl.class);
}
}
}
| 6,113
| 30.515464
| 139
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataTransientCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataTransientCacheEntry;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataTransientCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataTransientCacheEntryExternalizer implements AdvancedExternalizer<MetadataTransientCacheEntry> {
@Override
public Set<Class<? extends MetadataTransientCacheEntry>> getTypeClasses() {
return Collections.singleton(MetadataTransientCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.METADATA_TRANSIENT_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, MetadataTransientCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
output.writeObject(ice.getMetadata());
UnsignedNumeric.writeUnsignedLong(output, ice.getLastUsed());
}
@Override
public MetadataTransientCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
return new MetadataTransientCacheEntry(key, value, metadata, lastUsed);
}
}
| 1,684
| 32.039216
| 115
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataImmortalCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataImmortalCacheValue;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataImmortalCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataImmortalCacheValueExternalizer implements AdvancedExternalizer<MetadataImmortalCacheValue> {
@Override
public Set<Class<? extends MetadataImmortalCacheValue>> getTypeClasses() {
return Collections.singleton(MetadataImmortalCacheValue.class);
}
@Override
public Integer getId() {
return Ids.METADATA_IMMORTAL_VALUE;
}
@Override
public void writeObject(ObjectOutput output, MetadataImmortalCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
output.writeObject(icv.getMetadata());
}
@Override
public MetadataImmortalCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
return new MetadataImmortalCacheValue(value, metadata);
}
}
| 1,399
| 29.434783
| 113
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataMortalCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataMortalCacheEntry;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataMortalCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataMortalCacheEntryExternalizer implements AdvancedExternalizer<MetadataMortalCacheEntry> {
@Override
public Set<Class<? extends MetadataMortalCacheEntry>> getTypeClasses() {
return Collections.singleton(MetadataMortalCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.METADATA_MORTAL_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, MetadataMortalCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
output.writeObject(ice.getMetadata());
UnsignedNumeric.writeUnsignedLong(output, ice.getCreated());
}
@Override
public MetadataMortalCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
return new MetadataMortalCacheEntry(key, value, metadata, created);
}
}
| 1,651
| 31.392157
| 109
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/TransientCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.TransientCacheValue;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link TransientCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class TransientCacheValueExternalizer implements AdvancedExternalizer<TransientCacheValue> {
@Override
public Set<Class<? extends TransientCacheValue>> getTypeClasses() {
return Collections.singleton(TransientCacheValue.class);
}
@Override
public Integer getId() {
return Ids.TRANSIENT_VALUE;
}
@Override
public void writeObject(ObjectOutput output, TransientCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
UnsignedNumeric.writeUnsignedLong(output, icv.getLastUsed());
output.writeLong(icv.getMaxIdle());
}
@Override
public TransientCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
long maxIdle = input.readLong();
return new TransientCacheValue(value, maxIdle, lastUsed);
}
}
| 1,447
| 29.166667
| 104
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/InternalMetadataImplExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Set;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.util.Util;
import org.infinispan.metadata.Metadata;
import org.infinispan.metadata.impl.InternalMetadataImpl;
/**
* Externalizer for ${@link InternalMetadataImpl}.
*
* @author Ryan Emerson
* @since 10.0
*/
public class InternalMetadataImplExternalizer implements AdvancedExternalizer<InternalMetadataImpl> {
private static final long serialVersionUID = -5291318076267612501L;
private final int id;
public InternalMetadataImplExternalizer(int id) {
this.id = id;
}
@Override
public void writeObject(ObjectOutput output, InternalMetadataImpl b) throws IOException {
output.writeLong(b.created());
output.writeLong(b.lastUsed());
output.writeObject(b.actual());
}
@Override
public InternalMetadataImpl readObject(ObjectInput input) throws IOException, ClassNotFoundException {
long created = input.readLong();
long lastUsed = input.readLong();
Metadata actual = (Metadata) input.readObject();
return new InternalMetadataImpl(actual, created, lastUsed);
}
@Override
public Integer getId() {
return id;
}
@Override
@SuppressWarnings("unchecked")
public Set<Class<? extends InternalMetadataImpl>> getTypeClasses() {
return Util.asSet(InternalMetadataImpl.class);
}
}
| 1,547
| 27.666667
| 105
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/ImmortalCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.ImmortalCacheValue;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link ImmortalCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class ImmortalCacheValueExternalizer implements AdvancedExternalizer<ImmortalCacheValue> {
@Override
public Set<Class<? extends ImmortalCacheValue>> getTypeClasses() {
return Collections.singleton(ImmortalCacheValue.class);
}
@Override
public Integer getId() {
return Ids.IMMORTAL_VALUE;
}
@Override
public void writeObject(ObjectOutput output, ImmortalCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
}
@Override
public ImmortalCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
return new ImmortalCacheValue(value);
}
}
| 1,156
| 25.906977
| 103
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/TransientMortalCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.TransientMortalCacheEntry;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link TransientMortalCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class TransientMortalCacheEntryExternalizer implements AdvancedExternalizer<TransientMortalCacheEntry> {
@Override
public Set<Class<? extends TransientMortalCacheEntry>> getTypeClasses() {
return Collections.singleton(TransientMortalCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.TRANSIENT_MORTAL_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, TransientMortalCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
UnsignedNumeric.writeUnsignedLong(output, ice.getCreated());
output.writeLong(ice.getLifespan());
UnsignedNumeric.writeUnsignedLong(output, ice.getLastUsed());
output.writeLong(ice.getMaxIdle());
}
@Override
public TransientMortalCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
long lifespan = input.readLong();
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
long maxIdle = input.readLong();
return new TransientMortalCacheEntry(key, value, maxIdle, lifespan, lastUsed, created);
}
}
| 1,823
| 32.777778
| 111
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataTransientCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataTransientCacheValue;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataTransientCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataTransientCacheValueExternalizer implements AdvancedExternalizer<MetadataTransientCacheValue> {
@Override
public Set<Class<? extends MetadataTransientCacheValue>> getTypeClasses() {
return Collections.singleton(MetadataTransientCacheValue.class);
}
@Override
public Integer getId() {
return Ids.METADATA_TRANSIENT_VALUE;
}
@Override
public void writeObject(ObjectOutput output, MetadataTransientCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
output.writeObject(icv.getMetadata());
UnsignedNumeric.writeUnsignedLong(output, icv.getLastUsed());
}
@Override
public MetadataTransientCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
return new MetadataTransientCacheValue(value, metadata, lastUsed);
}
}
| 1,600
| 31.673469
| 115
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/TransientCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.TransientCacheEntry;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link TransientCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class TransientCacheEntryExternalizer implements AdvancedExternalizer<TransientCacheEntry> {
@Override
public Set<Class<? extends TransientCacheEntry>> getTypeClasses() {
return Collections.singleton(TransientCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.TRANSIENT_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, TransientCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
UnsignedNumeric.writeUnsignedLong(output, ice.getLastUsed());
output.writeLong(ice.getMaxIdle());
}
@Override
public TransientCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
long maxIdle = input.readLong();
return new TransientCacheEntry(key, value, maxIdle, lastUsed);
}
}
| 1,531
| 29.64
| 104
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MortalCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.MortalCacheValue;
import org.infinispan.marshall.core.Ids;
/**
* Externalizer for {@link MortalCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MortalCacheValueExternalizer implements AdvancedExternalizer<MortalCacheValue> {
@Override
public Set<Class<? extends MortalCacheValue>> getTypeClasses() {
return Collections.singleton(MortalCacheValue.class);
}
@Override
public Integer getId() {
return Ids.MORTAL_VALUE;
}
@Override
public void writeObject(ObjectOutput output, MortalCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
UnsignedNumeric.writeUnsignedLong(output, icv.getCreated());
output.writeLong(icv.getLifespan());
}
@Override
public MortalCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
long lifespan = input.readLong();
return new MortalCacheValue(value, created, lifespan);
}
}
| 1,417
| 28.541667
| 101
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataTransientMortalCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataTransientMortalCacheEntry;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataTransientMortalCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataTransientMortalCacheEntryExternalizer implements AdvancedExternalizer<MetadataTransientMortalCacheEntry> {
@Override
public Set<Class<? extends MetadataTransientMortalCacheEntry>> getTypeClasses() {
return Collections.singleton(MetadataTransientMortalCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.METADATA_TRANSIENT_MORTAL_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, MetadataTransientMortalCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
output.writeObject(ice.getMetadata());
UnsignedNumeric.writeUnsignedLong(output, ice.getCreated());
UnsignedNumeric.writeUnsignedLong(output, ice.getLastUsed());
}
@Override
public MetadataTransientMortalCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
long lastUsed = UnsignedNumeric.readUnsignedLong(input);
return new MetadataTransientMortalCacheEntry(key, value, metadata, lastUsed, created);
}
}
| 1,883
| 34.54717
| 127
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataMortalCacheValueExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataMortalCacheValue;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataMortalCacheValue}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataMortalCacheValueExternalizer implements AdvancedExternalizer<MetadataMortalCacheValue> {
@Override
public Set<Class<? extends MetadataMortalCacheValue>> getTypeClasses() {
return Collections.singleton(MetadataMortalCacheValue.class);
}
@Override
public Integer getId() {
return Ids.METADATA_MORTAL_VALUE;
}
@Override
public void writeObject(ObjectOutput output, MetadataMortalCacheValue icv) throws IOException {
output.writeObject(icv.getValue());
output.writeObject(icv.getMetadata());
UnsignedNumeric.writeUnsignedLong(output, icv.getCreated());
}
@Override
public MetadataMortalCacheValue readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
long created = UnsignedNumeric.readUnsignedLong(input);
return new MetadataMortalCacheValue(value, metadata, created);
}
}
| 1,567
| 31
| 109
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/common/MetadataImmortalCacheEntryExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.common;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.Set;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.container.entries.metadata.MetadataImmortalCacheEntry;
import org.infinispan.marshall.core.Ids;
import org.infinispan.metadata.Metadata;
/**
* Externalizer for {@link MetadataImmortalCacheEntry}.
*
* @author Pedro Ruivo
* @since 11.0
*/
public class MetadataImmortalCacheEntryExternalizer implements AdvancedExternalizer<MetadataImmortalCacheEntry> {
@Override
public Set<Class<? extends MetadataImmortalCacheEntry>> getTypeClasses() {
return Collections.singleton(MetadataImmortalCacheEntry.class);
}
@Override
public Integer getId() {
return Ids.METADATA_IMMORTAL_ENTRY;
}
@Override
public void writeObject(ObjectOutput output, MetadataImmortalCacheEntry ice) throws IOException {
output.writeObject(ice.getKey());
output.writeObject(ice.getValue());
output.writeObject(ice.getMetadata());
}
@Override
public MetadataImmortalCacheEntry readObject(ObjectInput input) throws IOException, ClassNotFoundException {
Object key = input.readObject();
Object value = input.readObject();
Metadata metadata = (Metadata) input.readObject();
return new MetadataImmortalCacheEntry(key, value, metadata);
}
}
| 1,483
| 29.916667
| 113
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan10/Infinispan10Marshaller.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan10;
import java.io.IOException;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.marshall.protostream.impl.MarshallableUserObject;
import org.infinispan.protostream.ProtobufUtil;
import org.infinispan.protostream.SerializationContext;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.tools.store.migrator.marshaller.common.AbstractUnsupportedStreamingMarshaller;
public class Infinispan10Marshaller extends AbstractUnsupportedStreamingMarshaller {
final static Set<SerializationContextInitializer> internalSCIs = new HashSet<>();
static {
internalSCIs.add(new org.infinispan.commons.marshall.PersistenceContextInitializerImpl());
internalSCIs.add(new org.infinispan.marshall.persistence.impl.PersistenceContextInitializerImpl());
internalSCIs.add(new org.infinispan.multimap.impl.PersistenceContextInitializerImpl());
internalSCIs.add(new org.infinispan.persistence.rocksdb.PersistenceContextInitializerImpl());
internalSCIs.add(new org.infinispan.persistence.jdbc.impl.PersistenceContextInitializerImpl());
internalSCIs.add(new org.infinispan.query.core.stats.impl.PersistenceContextInitializerImpl());
internalSCIs.add(new org.infinispan.query.impl.PersistenceContextInitializerImpl());
internalSCIs.add(new org.infinispan.server.core.PersistenceContextInitializerImpl());
}
final SerializationContext ctx;
public Infinispan10Marshaller(Marshaller userMarshaller, List<SerializationContextInitializer> userSCIs) {
this.ctx = ProtobufUtil.newSerializationContext();
if (userMarshaller != null) {
ctx.registerMarshaller(
new MarshallableUserObject.Marshaller("org.infinispan.persistence.core.MarshallableUserObject", userMarshaller)
);
}
userSCIs.forEach(this::registerInitializer);
internalSCIs.forEach(this::registerInitializer);
}
private void registerInitializer(SerializationContextInitializer initializer) {
initializer.registerSchema(ctx);
initializer.registerMarshallers(ctx);
}
@Override
public Object objectFromByteBuffer(byte[] buf, int offset, int length) throws IOException {
return unwrapAndInit(ProtobufUtil.fromWrappedByteArray(ctx, buf, offset, length));
}
private Object unwrapAndInit(Object o) {
if (o instanceof MarshallableUserObject) {
MarshallableUserObject wrapper = (MarshallableUserObject) o;
return wrapper.get();
}
return o;
}
}
| 2,672
| 42.112903
| 126
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan8/SingletonListExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan8;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.util.Util;
import net.jcip.annotations.Immutable;
/**
* @author Ryan Emerson
* @since 9.0
*/
@Immutable
class SingletonListExternalizer extends AbstractExternalizer<List<?>> {
@Override
public void writeObject(ObjectOutput output, List<?> list) throws IOException {
output.writeObject(list.get(0));
}
@Override
public List<?> readObject(ObjectInput input) throws IOException, ClassNotFoundException {
return Collections.singletonList(input.readObject());
}
@Override
public Integer getId() {
return ExternalizerTable.SINGLETON_LIST;
}
@Override
public Set<Class<? extends List<?>>> getTypeClasses() {
// This is loadable from any classloader
return Util.<Class<? extends List<?>>>asSet(Util.<List<?>>loadClass("java.util.Collections$SingletonList", null));
}
}
| 1,157
| 25.930233
| 120
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan8/ImmutableListCopyExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan8;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.List;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.util.ImmutableListCopy;
import org.infinispan.commons.util.Util;
class ImmutableListCopyExternalizer extends AbstractExternalizer<List> {
@Override
public void writeObject(ObjectOutput output, List list) throws IOException {
int size = list.size();
UnsignedNumeric.writeUnsignedInt(output, size);
for (int i = 0; i < size; i++) {
output.writeObject(list.get(i));
}
}
@Override
public List readObject(ObjectInput input) throws IOException, ClassNotFoundException {
int size = UnsignedNumeric.readUnsignedInt(input);
Object[] elements = new Object[size];
for (int i = 0; i < size; i++)
elements[i] = input.readObject();
return new ImmutableListCopy(elements);
}
@Override
public Integer getId() {
return ExternalizerTable.IMMUTABLE_LIST;
}
@Override
public Set<Class<? extends List>> getTypeClasses() {
return Util.asSet(ImmutableListCopy.class, ImmutableListCopy.ImmutableSubList.class);
}
}
| 1,352
| 29.066667
| 91
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan8/ArrayExternalizers.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan8;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.List;
import java.util.Set;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.util.Util;
/**
* Externalizers for diverse array types.
*
* @author Galder Zamarreño
* @since 6.0
*/
class ArrayExternalizers {
public static class ListArray implements AdvancedExternalizer<List[]> {
@Override
public void writeObject(ObjectOutput output, List[] lists) throws IOException {
UnsignedNumeric.writeUnsignedInt(output, lists.length);
for (List l : lists)
output.writeObject(l);
}
@Override
public List[] readObject(ObjectInput input) throws IOException, ClassNotFoundException {
int len = UnsignedNumeric.readUnsignedInt(input);
List[] lists = new List[len];
for (int i = 0; i < len; i++)
lists[i] = (List) input.readObject();
return lists;
}
@Override
public Integer getId() {
return ExternalizerTable.LIST_ARRAY;
}
@Override
@SuppressWarnings("unchecked") // on purpose, it would not work otherwise
public Set getTypeClasses() {
return Util.asSet(List[].class);
}
}
}
| 1,413
| 27.28
| 94
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan8/ExternalizerTable.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan8;
import java.io.IOException;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.io.ByteBufferImpl;
import org.infinispan.commons.io.UnsignedNumeric;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.StreamingMarshaller;
import org.infinispan.commons.util.Immutables;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.container.versioning.SimpleClusteredVersion;
import org.infinispan.marshall.exts.EnumSetExternalizer;
import org.infinispan.marshall.exts.MapExternalizer;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.tools.store.migrator.marshaller.common.ImmortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.ImmortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.InternalMetadataImplExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MarshalledEntryImpl;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataImmortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataImmortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataMortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataMortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientMortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MetadataTransientMortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.MortalCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientCacheValueExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientMortalCacheEntryExternalizer;
import org.infinispan.tools.store.migrator.marshaller.common.TransientMortalCacheValueExternalizer;
import org.infinispan.util.KeyValuePair;
import org.infinispan.util.logging.Log;
import org.infinispan.util.logging.LogFactory;
import org.jboss.marshalling.ObjectTable;
import org.jboss.marshalling.Unmarshaller;
/**
* The externalizer table maintains information necessary to be able to map a particular type with the corresponding
* {@link org.infinispan.commons.marshall.AdvancedExternalizer} implementation that it marshall, and it also keeps
* information of which {@link org.infinispan.commons.marshall.AdvancedExternalizer} should be used to read data from a
* buffer given a particular {@link org.infinispan.commons.marshall.AdvancedExternalizer} identifier.
* <p>
* These tables govern how either internal Infinispan classes, or user defined classes, are marshalled to a given
* output, or how these are unmarshalled from a given input.
*
* @author Galder Zamarreño
* @since 5.0
*/
class ExternalizerTable implements ObjectTable {
private static final Map<Integer, Integer> LEGACY_MAP;
static {
HashMap<Integer, Integer> map = new HashMap<>();
map.put(2, 1); // MAPS
map.put(10, 7); // IMMORTAL_ENTRY
map.put(11, 8); // MORTAL_ENTRY
map.put(12, 9); // TRANSIENT_ENTRY
map.put(13, 10); // TRANSIENT_MORTAL_ENTRY
map.put(14, 11); // IMMORTAL_VALUE
map.put(15, 12); // MORTAL_VALUE
map.put(16, 13); // TRANSIENT_VALUE
map.put(17, 14); // TRANSIENT_VALUE
map.put(19, 105); // IMMUTABLE_MAP
map.put(76, 38); // METADATA_IMMORTAL_ENTRY
map.put(77, 39); // METADATA_MORTAL_ENTRY
map.put(78, 40); // METADATA_TRANSIENT_ENTRY
map.put(79, 41); // METADATA_TRANSIENT_MORTAL_ENTRY
map.put(80, 42); // METADATA_IMMORTAL_ENTRY
map.put(81, 43); // METADATA_MORTAL_ENTRY
map.put(82, 44); // METADATA_TRANSIENT_VALUE
map.put(83, 45); // METADATA_TRANSIENT_MORTAL_VALUE
map.put(96, 55); // SIMPLE_CLUSTERED_VERSION
map.put(98, 57); // EMBEDDED_METADATA
map.put(99, 58); // NUMERIC_VERSION
map.put(103, 60); // KEY_VALUE_PAIR
map.put(105, 62); // MARSHALLED_ENTRY
map.put(106, 106); // BYTE_BUFFER
map.put(121, 63); // ENUM_SET
LEGACY_MAP = Collections.unmodifiableMap(map);
}
static int ARRAY_LIST = 0;
static int JDK_SETS = 3;
static int SINGLETON_LIST = 4;
static int IMMUTABLE_LIST = 18;
static int INTERNAL_METADATA = 104;
static int LIST_ARRAY = 122;
private static final Log log = LogFactory.getLog(ExternalizerTable.class);
private static final int MAX_ID = 255;
private final Map<Integer, ExternalizerAdapter> readers = new HashMap<>();
private final StreamingMarshaller marshaller;
ExternalizerTable(StreamingMarshaller marshaller, Map<Integer, ? extends AdvancedExternalizer> externalizerMap) {
this.marshaller = marshaller;
loadInternalMarshallables();
initForeignMarshallables(externalizerMap);
}
@Override
public Writer getObjectWriter(Object o) {
return null;
}
@Override
public Object readObject(Unmarshaller input) throws IOException, ClassNotFoundException {
int readerIndex = input.readUnsignedByte();
int foreignId = -1;
if (readerIndex == MAX_ID) {
// User defined externalizer
foreignId = UnsignedNumeric.readUnsignedInt(input);
readerIndex = generateForeignReaderIndex(foreignId);
} else {
Integer legacyId = LEGACY_MAP.get(readerIndex);
if (legacyId != null)
readerIndex = legacyId;
}
ExternalizerAdapter adapter = readers.get(readerIndex);
if (adapter == null) {
if (foreignId > 0)
throw log.missingForeignExternalizer(foreignId);
throw log.unknownExternalizerReaderIndex(readerIndex);
}
return adapter.externalizer.readObject(input);
}
private void loadInternalMarshallables() {
addInternalExternalizer(new ListExternalizer());
addInternalExternalizer(new MapExternalizer());
addInternalExternalizer(new SetExternalizer());
addInternalExternalizer(new EnumSetExternalizer());
addInternalExternalizer(new ArrayExternalizers.ListArray());
addInternalExternalizer(new SingletonListExternalizer());
addInternalExternalizer(new ImmutableListCopyExternalizer());
addInternalExternalizer(new Immutables.ImmutableMapWrapperExternalizer());
addInternalExternalizer(new ByteBufferImpl.Externalizer());
addInternalExternalizer(new NumericVersion.Externalizer());
addInternalExternalizer(new ByteBufferImpl.Externalizer());
addInternalExternalizer(new KeyValuePair.Externalizer());
addInternalExternalizer(new InternalMetadataImplExternalizer(INTERNAL_METADATA));
addInternalExternalizer(new MarshalledEntryImpl.Externalizer(marshaller));
addInternalExternalizer(new ImmortalCacheEntryExternalizer());
addInternalExternalizer(new MortalCacheEntryExternalizer());
addInternalExternalizer(new TransientCacheEntryExternalizer());
addInternalExternalizer(new TransientMortalCacheEntryExternalizer());
addInternalExternalizer(new ImmortalCacheValueExternalizer());
addInternalExternalizer(new MortalCacheValueExternalizer());
addInternalExternalizer(new TransientCacheValueExternalizer());
addInternalExternalizer(new TransientMortalCacheValueExternalizer());
addInternalExternalizer(new SimpleClusteredVersion.Externalizer());
addInternalExternalizer(new MetadataImmortalCacheEntryExternalizer());
addInternalExternalizer(new MetadataMortalCacheEntryExternalizer());
addInternalExternalizer(new MetadataTransientCacheEntryExternalizer());
addInternalExternalizer(new MetadataTransientMortalCacheEntryExternalizer());
addInternalExternalizer(new MetadataImmortalCacheValueExternalizer());
addInternalExternalizer(new MetadataMortalCacheValueExternalizer());
addInternalExternalizer(new MetadataTransientCacheValueExternalizer());
addInternalExternalizer(new MetadataTransientMortalCacheValueExternalizer());
addInternalExternalizer(new EmbeddedMetadata.Externalizer());
}
private void addInternalExternalizer(AdvancedExternalizer ext) {
int id = checkInternalIdLimit(ext.getId(), ext);
updateExtReadersWithTypes(new ExternalizerAdapter(id, ext));
}
private void updateExtReadersWithTypes(ExternalizerAdapter adapter) {
updateExtReadersWithTypes(adapter, adapter.id);
}
private void updateExtReadersWithTypes(ExternalizerAdapter adapter, int readerIndex) {
Set<Class<?>> typeClasses = adapter.externalizer.getTypeClasses();
if (typeClasses.size() > 0) {
for (Class<?> typeClass : typeClasses)
updateExtReaders(adapter, typeClass, readerIndex);
} else {
throw log.advanceExternalizerTypeClassesUndefined(adapter.externalizer.getClass().getName());
}
}
private void initForeignMarshallables(Map<Integer, ? extends AdvancedExternalizer> externalizerMap) {
for (Map.Entry<Integer, ? extends AdvancedExternalizer> entry : externalizerMap.entrySet()) {
AdvancedExternalizer ext = entry.getValue();
Integer id = ext.getId();
if (entry.getKey() == null && id == null)
throw new CacheConfigurationException(String.format(
"No advanced externalizer identifier set for externalizer %s",
ext.getClass().getName()));
else if (entry.getKey() != null)
id = entry.getKey();
id = checkForeignIdLimit(id, ext);
updateExtReadersWithTypes(new ExternalizerAdapter(id, ext), generateForeignReaderIndex(id));
}
}
private void updateExtReaders(ExternalizerAdapter adapter, Class<?> typeClass, int readerIndex) {
ExternalizerAdapter prevReader = readers.put(readerIndex, adapter);
// Several externalizers might share same id (i.e. HashMap and TreeMap use MapExternalizer)
// but a duplicate is only considered when that particular index has already been entered
// in the readers map and the externalizers are different (they're from different classes)
if (prevReader != null && !prevReader.equals(adapter))
throw log.duplicateExternalizerIdFound(adapter.id, typeClass, prevReader.externalizer.getClass().getName(), readerIndex);
}
private int checkInternalIdLimit(int id, AdvancedExternalizer ext) {
if (id >= MAX_ID)
throw log.internalExternalizerIdLimitExceeded(ext, id, MAX_ID);
return id;
}
private int checkForeignIdLimit(int id, AdvancedExternalizer ext) {
if (id < 0)
throw log.foreignExternalizerUsingNegativeId(ext, id);
return id;
}
private int generateForeignReaderIndex(int foreignId) {
return 0x80000000 | foreignId;
}
private static class ExternalizerAdapter {
final int id;
final AdvancedExternalizer externalizer;
ExternalizerAdapter(int id, AdvancedExternalizer externalizer) {
this.id = id;
this.externalizer = externalizer;
}
@Override
public String toString() {
// Each adapter is represented by the externalizer it delegates to, so just return the class name
return externalizer.getClass().getName();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ExternalizerAdapter that = (ExternalizerAdapter) o;
if (id != that.id) return false;
if (externalizer != null ? !externalizer.getClass().equals(that.externalizer.getClass()) : that.externalizer != null)
return false;
return true;
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + (externalizer.getClass() != null ? externalizer.getClass().hashCode() : 0);
return result;
}
}
}
| 12,570
| 45.387454
| 130
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan8/ListExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan8;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.marshall.MarshallUtil;
import org.infinispan.commons.util.Util;
import net.jcip.annotations.Immutable;
/**
* List externalizer dealing with ArrayList and LinkedList implementations.
*
* @author Galder Zamarreño
* @since 4.0
*/
@Immutable
class ListExternalizer extends AbstractExternalizer<List> {
private static final int ARRAY_LIST = 0;
private static final int LINKED_LIST = 1;
private final Map<Class<?>, Integer> numbers = new HashMap<>(2);
public ListExternalizer() {
numbers.put(ArrayList.class, ARRAY_LIST);
numbers.put(getPrivateArrayListClass(), ARRAY_LIST);
numbers.put(LinkedList.class, LINKED_LIST);
}
@Override
public void writeObject(ObjectOutput output, List list) throws IOException {
int number = numbers.getOrDefault(list.getClass(), -1);
output.writeByte(number);
MarshallUtil.marshallCollection(list, output);
}
@Override
public List readObject(ObjectInput input) throws IOException, ClassNotFoundException {
int magicNumber = input.readUnsignedByte();
switch (magicNumber) {
case ARRAY_LIST:
return MarshallUtil.unmarshallCollection(input, ArrayList::new);
case LINKED_LIST:
return MarshallUtil.unmarshallCollection(input, s -> new LinkedList<>());
default:
throw new IllegalStateException("Unknown List type: " + magicNumber);
}
}
@Override
public Integer getId() {
return ExternalizerTable.ARRAY_LIST;
}
@Override
public Set<Class<? extends List>> getTypeClasses() {
return Util.asSet(ArrayList.class, LinkedList.class,
getPrivateArrayListClass());
}
private Class<List> getPrivateArrayListClass() {
return Util.<List>loadClass("java.util.Arrays$ArrayList", List.class.getClassLoader());
}
}
| 2,231
| 29.162162
| 93
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan8/SetExternalizer.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan8;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import org.infinispan.commons.marshall.AbstractExternalizer;
import org.infinispan.commons.marshall.MarshallUtil;
import org.infinispan.commons.util.Util;
import net.jcip.annotations.Immutable;
/**
* Set externalizer for all set implementations, i.e. HashSet and TreeSet
*
* @author Galder Zamarreño
* @since 4.0
*/
@Immutable
class SetExternalizer extends AbstractExternalizer<Set> {
private static final int HASH_SET = 0;
private static final int TREE_SET = 1;
private final Map<Class<?>, Integer> numbers = new HashMap<>(2);
public SetExternalizer() {
numbers.put(HashSet.class, HASH_SET);
numbers.put(TreeSet.class, TREE_SET);
}
@Override
public void writeObject(ObjectOutput output, Set set) throws IOException {
int number = numbers.getOrDefault(set.getClass(), -1);
output.writeByte(number);
if (number == TREE_SET)
output.writeObject(((TreeSet) set).comparator());
MarshallUtil.marshallCollection(set, output);
}
@Override
public Set readObject(ObjectInput input) throws IOException, ClassNotFoundException {
int magicNumber = input.readUnsignedByte();
switch (magicNumber) {
case HASH_SET:
return MarshallUtil.unmarshallCollection(input, s -> new HashSet<>());
case TREE_SET:
Comparator<Object> comparator = (Comparator<Object>) input.readObject();
return MarshallUtil.unmarshallCollection(input, s -> new TreeSet<>(comparator));
default:
throw new IllegalStateException("Unknown Set type: " + magicNumber);
}
}
@Override
public Integer getId() {
return ExternalizerTable.JDK_SETS;
}
@Override
public Set<Class<? extends Set>> getTypeClasses() {
return Util.asSet(HashSet.class, TreeSet.class);
}
}
| 2,128
| 29.414286
| 92
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/marshaller/infinispan8/Infinispan8Marshaller.java
|
package org.infinispan.tools.store.migrator.marshaller.infinispan8;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInput;
import java.util.Map;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.tools.store.migrator.marshaller.LegacyJBossMarshaller;
import org.infinispan.tools.store.migrator.marshaller.common.AbstractUnsupportedStreamingMarshaller;
/**
* LegacyVersionAwareMarshaller that is used to read bytes marshalled using Infinispan 8.x. This is useful for providing
* a migration path from 8.x stores.
*/
public class Infinispan8Marshaller extends AbstractUnsupportedStreamingMarshaller {
private final LegacyJBossMarshaller external;
public Infinispan8Marshaller(Map<Integer, ? extends AdvancedExternalizer> userExts) {
this.external = new LegacyJBossMarshaller(new ExternalizerTable(this, userExts));
}
@Override
public Object objectFromByteBuffer(byte[] bytes, int offset, int len) throws IOException, ClassNotFoundException {
ByteArrayInputStream is = new ByteArrayInputStream(bytes, offset, len);
ObjectInput in = startObjectInput(is, false);
Object o;
try {
o = external.objectFromObjectStream(in);
} finally {
finishObjectInput(in);
}
return o;
}
@Override
public ObjectInput startObjectInput(InputStream is, boolean isReentrant) throws IOException {
ObjectInput in = external.startObjectInput(is, isReentrant);
try {
in.readShort();
} catch (Exception e) {
finishObjectInput(in);
throw new IOException("Unable to read version id from first two bytes of stream: " + e.getMessage());
}
return in;
}
@Override
public void finishObjectInput(ObjectInput oi) {
external.finishObjectInput(oi);
}
}
| 1,882
| 33.87037
| 120
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/file/SingleFileStoreReader.java
|
package org.infinispan.tools.store.migrator.file;
import static org.infinispan.tools.store.migrator.Element.CACHE_NAME;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import java.io.File;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.io.ByteBufferImpl;
import org.infinispan.persistence.file.SingleFileStore;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.MarshallableEntryFactory;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreIterator;
import org.infinispan.tools.store.migrator.StoreProperties;
import org.infinispan.tools.store.migrator.marshaller.SerializationConfigUtil;
public class SingleFileStoreReader implements StoreIterator {
private final FileChannel channel;
private final MarshallableEntryFactory<?,?> entryFactory;
private final FileEntryReader reader;
public SingleFileStoreReader(StoreProperties props) {
props.required(Element.LOCATION);
String filename = props.get(CACHE_NAME) + ".dat";
Path path = Path.of(props.get(LOCATION)).resolve(filename);
String location = path.toString();
File file = path.toFile();
if (!file.exists() || file.isDirectory())
throw new CacheException(String.format("Unable to read SingleFileStore at '%s'", location));
try {
channel = new RandomAccessFile(file, "rw").getChannel();
byte[] magicBytes = new byte[SingleFileStore.MAGIC_11_0.length];
if (channel.read(ByteBuffer.wrap(magicBytes)) <= 0) {
throw new CacheException(String.format("File at \"%s\" is corrupted.", location));
}
if (Arrays.equals(magicBytes, SingleFileStore.MAGIC_BEFORE_11)) {
this.reader = new OldReader();
} else if (Arrays.equals(magicBytes, SingleFileStore.MAGIC_11_0) || Arrays.equals(magicBytes, SingleFileStore.MAGIC_LATEST)) {
this.reader = new NewReader();
} else {
throw new CacheException(String.format("File at \"%s\" is corrupted. Unexpected magic number.", location));
}
} catch (IOException e) {
throw new CacheException(e);
}
this.entryFactory = SerializationConfigUtil.getEntryFactory(props);
}
@Override
public void close() throws Exception {
channel.close();
}
@Override
public Iterator<MarshallableEntry> iterator() {
return new SingleFileIterator();
}
class SingleFileIterator implements Iterator<MarshallableEntry> {
int filePos = 4; //skip 4 bytes magic number
@Override
public boolean hasNext() {
// return if end of file is reached
return reader.hasNext(channel, filePos);
}
@Override
public MarshallableEntry next() {
for (;;) {
// read next entry using same logic as SingleFileStore#rebuildIndex
Entry entry = reader.read(channel, filePos);
if (entry == null)
throw new NoSuchElementException();
// sanity check
if (entry.size < entry.keyLen + entry.dataLen + entry.metadataLen + entry.internalMetadataLen)
throw new CacheException(String.format("Failed to read entries from file. Error at offset %d", filePos));
if (entry.keyLen > 0) {
try {
// load the key and value from file
byte[] data = new byte[entry.keyLen + entry.dataLen];
if (channel.read(ByteBuffer.wrap(data), filePos + reader.keyOffset()) <= 0) {
throw new CacheException(String.format("Failed to read entries from file. Error at offset %d", filePos));
}
filePos += entry.size;
org.infinispan.commons.io.ByteBuffer keyBb = ByteBufferImpl.create(data, 0, entry.keyLen);
org.infinispan.commons.io.ByteBuffer valueBb = ByteBufferImpl.create(data, entry.keyLen, entry.dataLen);
return entryFactory.create(keyBb, valueBb);
} catch (IOException e) {
throw new CacheException(String.format("Unable to read file entry at offset %d", filePos), e);
}
} else {
filePos += entry.size;
}
}
}
}
private static class Entry {
final int size;
final int keyLen;
final int dataLen;
final int metadataLen;
final int internalMetadataLen;
private Entry(int size, int keyLen, int dataLen, int metadataLen, int internalMetadataLen) {
this.size = size;
this.keyLen = keyLen;
this.dataLen = dataLen;
this.metadataLen = metadataLen;
this.internalMetadataLen = internalMetadataLen;
}
}
private interface FileEntryReader {
Entry read(FileChannel channel, int filePosition);
boolean hasNext(FileChannel channel, int filePosition);
int keyOffset();
}
private static abstract class BaseReader implements FileEntryReader {
private final int keyOffset;
final ByteBuffer byteBuffer;
BaseReader(int keyOffset) {
this.keyOffset = keyOffset;
this.byteBuffer = ByteBuffer.allocate(keyOffset);
}
@Override
public final Entry read(FileChannel channel, int filePosition) {
//in both magics numbers, the size, key length and value length are in the same position in the file
byteBuffer.clear().limit(keyOffset);
try {
if (channel.read(byteBuffer, filePosition) <= 0) {
return null;
}
} catch (IOException e) {
throw new CacheException(e);
}
byteBuffer.flip();
Entry entry = readEntry();
return entry;
}
@Override
public final boolean hasNext(FileChannel channel, int filePosition) {
byteBuffer.clear().limit(keyOffset);
try {
return channel.read(byteBuffer, filePosition) > 0;
} catch (IOException e) {
throw new CacheException(e);
}
}
@Override
public final int keyOffset() {
return keyOffset;
}
abstract Entry readEntry();
}
private static class OldReader extends BaseReader {
OldReader() {
super(SingleFileStore.KEY_POS_BEFORE_11);
}
@Override
Entry readEntry() {
int entrySize = byteBuffer.getInt();
int keyLen = byteBuffer.getInt();
int dataLen = byteBuffer.getInt();
int metadataLen = byteBuffer.getInt();
return new Entry(entrySize, keyLen, dataLen, metadataLen, 0);
}
}
private static class NewReader extends BaseReader {
NewReader() {
super(SingleFileStore.KEY_POS_11_0);
}
@Override
Entry readEntry() {
int entrySize = byteBuffer.getInt();
int keyLen = byteBuffer.getInt();
int dataLen = byteBuffer.getInt();
int metadataLen = byteBuffer.getInt();
int internalMetadataLen = byteBuffer.getInt();
return new Entry(entrySize, keyLen, dataLen, metadataLen, internalMetadataLen);
}
}
}
| 7,498
| 33.557604
| 135
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/file/SoftIndexFileStoreIterator.java
|
package org.infinispan.tools.store.migrator.file;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Iterator;
import java.util.NoSuchElementException;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.io.ByteBufferImpl;
import org.infinispan.persistence.sifs.EntryHeader;
import org.infinispan.persistence.sifs.EntryRecord;
import org.infinispan.persistence.sifs.FileProvider;
import org.infinispan.persistence.sifs.NonBlockingSoftIndexFileStore;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.MarshallableEntryFactory;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreIterator;
import org.infinispan.tools.store.migrator.StoreProperties;
import org.infinispan.tools.store.migrator.marshaller.SerializationConfigUtil;
public class SoftIndexFileStoreIterator implements StoreIterator {
private final MarshallableEntryFactory<?,?> entryFactory;
private final Path location;
private final int majorVersion;
public SoftIndexFileStoreIterator(StoreProperties props) {
props.required(Element.LOCATION);
String location = props.get(LOCATION);
File file = new File(location);
if (!file.exists() || !file.isDirectory())
throw new CacheException(String.format("Unable to read directory at '%s'", location));
this.location = Paths.get(location);
this.entryFactory = SerializationConfigUtil.getEntryFactory(props);
this.majorVersion = props.getMajorVersion();
}
@Override
public void close() {
}
@Override
public Iterator<MarshallableEntry> iterator() {
return new SoftIndexIterator();
}
class SoftIndexIterator implements Iterator<MarshallableEntry> {
final FileProvider fileProvider;
final Iterator<Integer> iterator;
final HeaderReader reader;
FileProvider.Handle handle;
int file = -1;
int offset = 0;
SoftIndexIterator() {
if (majorVersion < 11) {
this.fileProvider = new FileProvider(location, 1000, NonBlockingSoftIndexFileStore.PREFIX_10_1, 1024 * 1024);
this.reader = EntryRecord::read10_1EntryHeader;
} else {
String prefix = majorVersion == 11 ? NonBlockingSoftIndexFileStore.PREFIX_11_0 : NonBlockingSoftIndexFileStore.PREFIX_12_0;
this.fileProvider = new FileProvider(location, 1000, prefix, 1024 * 1024);
this.reader = EntryRecord::readEntryHeader;
}
this.iterator = fileProvider.getFileIterator();
}
@Override
public boolean hasNext() {
return file > -1 || iterator.hasNext();
}
@Override
public MarshallableEntry next() {
try {
while (hasNext()) {
if (file < 0) {
file = iterator.next();
handle = fileProvider.getFile(file);
}
for (; ; ) {
EntryHeader header = reader.read(handle, offset);
if (header == null) {
handle.close();
file = -1;
break; // end of file;
}
if (header.valueLength() > 0) {
byte[] serializedKey = EntryRecord.readKey(handle, header, offset);
byte[] serializedValue = EntryRecord.readValue(handle, header, offset);
offset += header.totalLength();
if (reader.read(handle, offset) == null) {
// We have reached the end of the file, so we must reset fileIndex in case !iterator.hasNext()
handle.close();
file = -1;
}
return entryFactory.create(ByteBufferImpl.create(serializedKey), ByteBufferImpl.create(serializedValue));
}
offset += header.totalLength();
}
}
throw new NoSuchElementException();
} catch (Exception e) {
throw new CacheException(e);
}
}
}
private interface HeaderReader {
EntryHeader read(FileProvider.Handle handle, int offset) throws IOException;
}
}
| 4,411
| 35.46281
| 135
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/BinaryJdbcIterator.java
|
package org.infinispan.tools.store.migrator.jdbc;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.marshall.StreamingMarshaller;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.PersistenceException;
/**
* @author Ryan Emerson
* @since 9.0
*/
class BinaryJdbcIterator extends AbstractJdbcEntryIterator {
private Iterator<MarshallableEntry> iterator = Collections.emptyIterator();
BinaryJdbcIterator(ConnectionFactory connectionFactory, TableManager tableManager, Marshaller marshaller) {
super(connectionFactory, tableManager, marshaller);
}
@Override
public boolean hasNext() {
return iterator.hasNext() || rowIndex < numberOfRows;
}
@Override
public MarshallableEntry next() {
if (!iterator.hasNext()) {
iterator = getNextBucketIterator();
}
rowIndex++;
return iterator.next();
}
private Iterator<MarshallableEntry> getNextBucketIterator() {
try {
if (rs.next()) {
InputStream inputStream = rs.getBinaryStream(1);
Map<Object, MarshallableEntry> bucketEntries = unmarshallBucketEntries(inputStream);
numberOfRows += bucketEntries.size() - 1; // Guaranteed that bucket size will never be 0
return bucketEntries.values().iterator();
} else {
close();
throw new NoSuchElementException();
}
} catch (SQLException e) {
throw new PersistenceException("SQL error while fetching all StoredEntries", e);
}
}
private Map<Object, MarshallableEntry> unmarshallBucketEntries(InputStream inputStream) {
try {
return (Map<Object, MarshallableEntry>) ((StreamingMarshaller) marshaller).objectFromInputStream(inputStream);
} catch (IOException e) {
throw new PersistenceException("I/O error while unmarshalling from stream", e);
} catch (ClassNotFoundException e) {
throw new PersistenceException(e);
}
}
}
| 2,394
| 33.710145
| 119
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/AbstractStringJdbcIterator.java
|
package org.infinispan.tools.store.migrator.jdbc;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.NoSuchElementException;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.marshall.StreamAwareMarshaller;
import org.infinispan.commons.marshall.StreamingMarshaller;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.keymappers.TwoWayKey2StringMapper;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.MarshallableEntryFactory;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.tools.store.migrator.marshaller.SerializationConfigUtil;
/**
* @author Ryan Emerson
* @since 10.0
*/
abstract class AbstractStringJdbcIterator extends AbstractJdbcEntryIterator {
final TwoWayKey2StringMapper key2StringMapper;
final MarshallableEntryFactory entryFactory;
AbstractStringJdbcIterator(ConnectionFactory connectionFactory, TableManager tableManager, Marshaller marshaller,
TwoWayKey2StringMapper key2StringMapper) {
super(connectionFactory, tableManager, marshaller);
this.key2StringMapper = key2StringMapper;
this.entryFactory = SerializationConfigUtil.getEntryFactory(marshaller);
}
abstract MarshallableEntry readMarshalledEntry(Object key, InputStream is);
@Override
public final boolean hasNext() {
return rowIndex < numberOfRows;
}
@Override
public final MarshallableEntry next() {
try {
if (rs.next()) {
rowIndex++;
Object key = key2StringMapper.getKeyMapping(rs.getString(2));
return readMarshalledEntry(key, rs.getBinaryStream(1));
} else {
close();
throw new NoSuchElementException();
}
} catch (SQLException e) {
throw new PersistenceException("SQL error while fetching all StoredEntries", e);
}
}
@SuppressWarnings("unchecked")
<T> T unmarshall(InputStream inputStream) throws PersistenceException {
try {
Object retVal = null;
if (marshaller instanceof StreamingMarshaller) {
retVal = ((StreamingMarshaller) marshaller).objectFromInputStream(inputStream);
} else if (marshaller instanceof StreamAwareMarshaller) {
retVal = ((StreamAwareMarshaller) marshaller).readObject(inputStream);
}
return (T) retVal;
} catch (IOException e) {
throw new PersistenceException("I/O error while unmarshalling from stream", e);
} catch (ClassNotFoundException e) {
throw new PersistenceException(e);
}
}
}
| 2,817
| 36.573333
| 116
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/StringJdbcIterator10.java
|
package org.infinispan.tools.store.migrator.jdbc;
import java.io.InputStream;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.keymappers.TwoWayKey2StringMapper;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.MarshalledValue;
/**
* @author Ryan Emerson
* @since 10.0
*/
class StringJdbcIterator10 extends AbstractStringJdbcIterator {
StringJdbcIterator10(ConnectionFactory connectionFactory, TableManager tableManager, Marshaller marshaller,
TwoWayKey2StringMapper key2StringMapper) {
super(connectionFactory, tableManager, marshaller, key2StringMapper);
}
@Override
MarshallableEntry readMarshalledEntry(Object key, InputStream is) {
return entryFactory.create(key, (MarshalledValue) unmarshall(is));
}
}
| 995
| 34.571429
| 110
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/AbstractJdbcEntryIterator.java
|
package org.infinispan.tools.store.migrator.jdbc;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Iterator;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.persistence.jdbc.common.JdbcUtil;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.impl.table.AbstractTableManager;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.PersistenceException;
/**
* @author Ryan Emerson
* @since 9.0
*/
abstract class AbstractJdbcEntryIterator implements Iterator<MarshallableEntry>, AutoCloseable {
final ConnectionFactory connectionFactory;
final TableManager tableManager;
final Marshaller marshaller;
private Connection conn;
private PreparedStatement ps;
ResultSet rs;
long numberOfRows = 0;
int rowIndex = 0;
AbstractJdbcEntryIterator(ConnectionFactory connectionFactory, TableManager tableManager,
Marshaller marshaller) {
this.connectionFactory = connectionFactory;
this.tableManager = tableManager;
this.marshaller = marshaller;
try {
conn = connectionFactory.getConnection();
String sizeSql = ((AbstractTableManager<?, ?>) tableManager).getSizeSql();
ps = conn.prepareStatement(sizeSql);
ps.setLong(1, System.currentTimeMillis());
rs = ps.executeQuery();
rs.next();
numberOfRows = rs.getInt(1);
JdbcUtil.safeClose(rs);
JdbcUtil.safeClose(ps);
ps = conn.prepareStatement(tableManager.getLoadAllRowsSql(), ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
ps.setFetchSize(tableManager.getFetchSize());
rs = ps.executeQuery();
} catch (SQLException e) {
this.close();
throw new PersistenceException("SQL error while fetching all StoredEntries", e);
}
}
@Override
public void close() {
JdbcUtil.safeClose(rs);
JdbcUtil.safeClose(ps);
connectionFactory.releaseConnection(conn);
}
}
| 2,233
| 33.90625
| 127
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/MixedJdbcIterator.java
|
package org.infinispan.tools.store.migrator.jdbc;
import java.util.Iterator;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.keymappers.TwoWayKey2StringMapper;
/**
* @author Ryan Emerson
* @since 9.0
*/
class MixedJdbcIterator implements Iterator<MarshallableEntry>, AutoCloseable {
private BinaryJdbcIterator binaryIt;
private StringJdbcIterator stringIt;
MixedJdbcIterator(ConnectionFactory connectionFactory, TableManager binaryTm, TableManager stringTm,
Marshaller marshaller, TwoWayKey2StringMapper key2StringMapper) {
binaryIt = new BinaryJdbcIterator(connectionFactory, binaryTm, marshaller);
stringIt = new StringJdbcIterator(connectionFactory, stringTm, marshaller, key2StringMapper);
}
@Override
public boolean hasNext() {
return binaryIt.hasNext() || stringIt.hasNext();
}
@Override
public MarshallableEntry next() {
if (binaryIt.hasNext())
return binaryIt.next();
return stringIt.next();
}
@Override
public void close() {
binaryIt.close();
stringIt.close();
}
}
| 1,336
| 30.093023
| 103
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/StringJdbcIterator.java
|
package org.infinispan.tools.store.migrator.jdbc;
import java.io.InputStream;
import org.infinispan.commons.io.ByteBuffer;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.keymappers.TwoWayKey2StringMapper;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.util.KeyValuePair;
/**
* @author Ryan Emerson
* @since 9.0
*/
class StringJdbcIterator extends AbstractStringJdbcIterator {
StringJdbcIterator(ConnectionFactory connectionFactory, TableManager tableManager, Marshaller marshaller,
TwoWayKey2StringMapper key2StringMapper) {
super(connectionFactory, tableManager, marshaller, key2StringMapper);
}
@Override
MarshallableEntry readMarshalledEntry(Object key, InputStream is) {
KeyValuePair<ByteBuffer, ByteBuffer> icv = unmarshall(is);
ByteBuffer buf = icv.getKey();
try {
Object value = marshaller.objectFromByteBuffer(buf.getBuf(), buf.getOffset(), buf.getLength());
return entryFactory.create(key, value);
} catch (Exception e) {
throw new PersistenceException(e);
}
}
}
| 1,357
| 35.702703
| 108
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/JdbcConfigurationUtil.java
|
package org.infinispan.tools.store.migrator.jdbc;
import static org.infinispan.tools.store.migrator.Element.BINARY;
import static org.infinispan.tools.store.migrator.Element.CONNECTION_POOL;
import static org.infinispan.tools.store.migrator.Element.CONNECTION_URL;
import static org.infinispan.tools.store.migrator.Element.DATA;
import static org.infinispan.tools.store.migrator.Element.DB;
import static org.infinispan.tools.store.migrator.Element.DIALECT;
import static org.infinispan.tools.store.migrator.Element.DISABLE_INDEXING;
import static org.infinispan.tools.store.migrator.Element.DISABLE_UPSERT;
import static org.infinispan.tools.store.migrator.Element.DRIVER_CLASS;
import static org.infinispan.tools.store.migrator.Element.ID;
import static org.infinispan.tools.store.migrator.Element.KEY_TO_STRING_MAPPER;
import static org.infinispan.tools.store.migrator.Element.MAJOR_VERSION;
import static org.infinispan.tools.store.migrator.Element.MINOR_VERSION;
import static org.infinispan.tools.store.migrator.Element.NAME;
import static org.infinispan.tools.store.migrator.Element.PASSWORD;
import static org.infinispan.tools.store.migrator.Element.SEGMENT;
import static org.infinispan.tools.store.migrator.Element.STRING;
import static org.infinispan.tools.store.migrator.Element.TABLE;
import static org.infinispan.tools.store.migrator.Element.TABLE_NAME_PREFIX;
import static org.infinispan.tools.store.migrator.Element.TIMESTAMP;
import static org.infinispan.tools.store.migrator.Element.TYPE;
import static org.infinispan.tools.store.migrator.Element.USERNAME;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.jdbc.common.DatabaseType;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfiguration;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.configuration.TableManipulationConfiguration;
import org.infinispan.persistence.jdbc.impl.table.TableManagerFactory;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreProperties;
import org.infinispan.tools.store.migrator.StoreType;
public class JdbcConfigurationUtil {
static JdbcStringBasedStoreConfiguration getStoreConfig(StoreProperties props) {
JdbcStringBasedStoreConfigurationBuilder builder = new ConfigurationBuilder().persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
configureStore(props, builder);
return builder.create();
}
public static JdbcStringBasedStoreConfigurationBuilder configureStore(StoreProperties props, JdbcStringBasedStoreConfigurationBuilder builder) {
StoreType type = props.storeType();
configureDbMeta(props, builder);
if (type == StoreType.JDBC_MIXED || type == StoreType.JDBC_STRING) {
createTableConfig(props, STRING, builder);
String mapper = props.get(KEY_TO_STRING_MAPPER);
if (mapper != null)
builder.key2StringMapper(props.get(KEY_TO_STRING_MAPPER));
}
if (type == StoreType.JDBC_MIXED || type == StoreType.JDBC_BINARY) {
createTableConfig(props, BINARY, builder);
}
createConnectionConfig(props, builder);
builder.validate();
return builder;
}
static TableManipulationConfiguration createTableConfig(StoreProperties props, Element tableType, JdbcStringBasedStoreConfigurationBuilder storeBuilder) {
return storeBuilder.table()
.createOnStart(props.isTargetStore())
.tableNamePrefix(props.get(TABLE, tableType, TABLE_NAME_PREFIX))
.idColumnName(props.get(TABLE, tableType, ID, NAME))
.idColumnType(props.get(TABLE, tableType, ID, TYPE))
.dataColumnName(props.get(TABLE, tableType, DATA, NAME))
.dataColumnType(props.get(TABLE, tableType, DATA, TYPE))
.timestampColumnName(props.get(TABLE, tableType, TIMESTAMP, NAME))
.timestampColumnType(props.get(TABLE, tableType, TIMESTAMP, TYPE))
.segmentColumnName(props.get(TABLE, tableType, SEGMENT, NAME))
.segmentColumnType(props.get(TABLE, tableType, SEGMENT, TYPE))
.create();
}
private static void configureDbMeta(StoreProperties props, JdbcStringBasedStoreConfigurationBuilder builder) {
props.required(DIALECT);
DatabaseType type = DatabaseType.valueOf(props.get(DIALECT).toUpperCase());
builder.dialect(type);
String prop;
if ((prop = props.get(DB, MAJOR_VERSION)) != null) {
builder.dbMajorVersion(new Integer(prop));
}
if ((prop = props.get(DB, MINOR_VERSION)) != null) {
builder.dbMinorVersion(new Integer(prop));
}
String disableUpsert = props.get(DB, DISABLE_UPSERT);
boolean upsert = Boolean.parseBoolean(disableUpsert);
if (upsert)
builder.addProperty(TableManagerFactory.UPSERT_DISABLED, disableUpsert);
String disableIndexing = props.get(DB, DISABLE_INDEXING);
boolean indexing = Boolean.parseBoolean(disableIndexing);
if (indexing)
builder.addProperty(TableManagerFactory.INDEXING_DISABLED, disableIndexing);
}
private static void createConnectionConfig(StoreProperties props, JdbcStringBasedStoreConfigurationBuilder storeBuilder) {
props.required(props.key(CONNECTION_POOL, CONNECTION_URL));
props.required(props.key(CONNECTION_POOL, DRIVER_CLASS));
storeBuilder.connectionPool()
.connectionUrl(props.get(CONNECTION_POOL, CONNECTION_URL))
.driverClass(props.get(CONNECTION_POOL, DRIVER_CLASS))
.username(props.get(CONNECTION_POOL, USERNAME))
.password(props.get(CONNECTION_POOL, PASSWORD))
.create();
}
}
| 5,814
| 49.565217
| 157
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/jdbc/JdbcStoreReader.java
|
package org.infinispan.tools.store.migrator.jdbc;
import static org.infinispan.tools.store.migrator.Element.BINARY;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
import java.util.Iterator;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.jdbc.common.connectionfactory.ConnectionFactory;
import org.infinispan.persistence.jdbc.common.impl.connectionfactory.PooledConnectionFactory;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfiguration;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.jdbc.impl.table.DbMetaData;
import org.infinispan.persistence.jdbc.impl.table.TableManager;
import org.infinispan.persistence.jdbc.impl.table.TableManagerFactory;
import org.infinispan.persistence.keymappers.DefaultTwoWayKey2StringMapper;
import org.infinispan.persistence.keymappers.TwoWayKey2StringMapper;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreIterator;
import org.infinispan.tools.store.migrator.StoreProperties;
import org.infinispan.tools.store.migrator.StoreType;
import org.infinispan.tools.store.migrator.marshaller.SerializationConfigUtil;
/**
* @author Ryan Emerson
* @since 9.0
*/
public class JdbcStoreReader implements StoreIterator {
private final StoreProperties props;
private final Marshaller marshaller;
private final JdbcStringBasedStoreConfiguration config;
private final ConnectionFactory connectionFactory;
private final DbMetaData metaData;
private final JdbcStringBasedStoreConfiguration stringConfig;
private final JdbcStringBasedStoreConfiguration binaryConfig;
public JdbcStoreReader(StoreProperties props) {
this.props = props;
this.marshaller = SerializationConfigUtil.getMarshaller(props);
this.config = JdbcConfigurationUtil.getStoreConfig(props);
this.connectionFactory = new PooledConnectionFactory();
this.stringConfig = config;
this.binaryConfig = createBinaryTableConfig();
connectionFactory.start(config.connectionFactory(), JdbcStoreReader.class.getClassLoader());
String segmentCount = props.get(Element.SEGMENT_COUNT);
metaData = TableManagerFactory.getDbMetaData(connectionFactory, config,
// If we don't have segments then disable it
segmentCount == null || Integer.parseInt(segmentCount) <= 0);
}
@Override
public void close() {
connectionFactory.stop();
}
public Iterator<MarshallableEntry> iterator() {
switch (props.storeType()) {
case JDBC_BINARY:
return new BinaryJdbcIterator(connectionFactory, getTableManager(true), marshaller);
case JDBC_STRING:
return props.getMajorVersion() > 9 ?
new StringJdbcIterator10(connectionFactory, getTableManager(false), marshaller, getTwoWayMapper()) :
new StringJdbcIterator(connectionFactory, getTableManager(false), marshaller, getTwoWayMapper());
case JDBC_MIXED:
return new MixedJdbcIterator(connectionFactory, getTableManager(true), getTableManager(false),
marshaller, getTwoWayMapper());
default:
throw new CacheConfigurationException("Unknown Store Type: " + props.storeType());
}
}
private TableManager getTableManager(boolean binary) {
JdbcStringBasedStoreConfiguration config = binary ? binaryConfig : stringConfig;
return TableManagerFactory.getManager(metaData, null, connectionFactory, config, props.cacheName());
}
private JdbcStringBasedStoreConfiguration createBinaryTableConfig() {
if (props.storeType() == StoreType.JDBC_STRING)
return null;
JdbcStringBasedStoreConfigurationBuilder builder = new ConfigurationBuilder().persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
JdbcConfigurationUtil.createTableConfig(props, BINARY, builder);
return builder.create();
}
private TwoWayKey2StringMapper getTwoWayMapper() {
String mapperClass = config.key2StringMapper();
if (mapperClass != null) {
ClassLoader classLoader = JdbcConfigurationUtil.class.getClassLoader();
try {
return (TwoWayKey2StringMapper) Util.loadClass(mapperClass, classLoader).newInstance();
} catch (IllegalAccessException | InstantiationException e) {
throw new CacheConfigurationException(String.format("Unabled to load TwoWayKey2StringMapper '%s' for %s store",
mapperClass, SOURCE), e);
}
}
return new DefaultTwoWayKey2StringMapper();
}
}
| 4,938
| 44.731481
| 123
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/rocksdb/RocksDBReader.java
|
package org.infinispan.tools.store.migrator.rocksdb;
import static org.infinispan.tools.store.migrator.Element.CACHE_NAME;
import static org.infinispan.tools.store.migrator.Element.COMPRESSION;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import java.io.File;
import java.util.Iterator;
import org.infinispan.commons.CacheException;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.marshall.persistence.impl.MarshalledEntryFactoryImpl;
import org.infinispan.metadata.InternalMetadata;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.persistence.spi.MarshallableEntryFactory;
import org.infinispan.persistence.spi.PersistenceException;
import org.infinispan.tools.store.migrator.StoreIterator;
import org.infinispan.tools.store.migrator.StoreProperties;
import org.infinispan.tools.store.migrator.marshaller.SerializationConfigUtil;
import org.infinispan.tools.store.migrator.marshaller.common.MarshalledEntryImpl;
import org.rocksdb.CompressionType;
import org.rocksdb.Options;
import org.rocksdb.ReadOptions;
import org.rocksdb.RocksDB;
import org.rocksdb.RocksDBException;
import org.rocksdb.RocksIterator;
public class RocksDBReader implements StoreIterator {
private final RocksDB db;
private final Marshaller marshaller;
private final MarshallableEntryFactory entryFactory;
public RocksDBReader(StoreProperties props) {
props.required(LOCATION);
String location = props.get(LOCATION) + props.get(CACHE_NAME).replaceAll("[^a-zA-Z0-9-_\\.]", "_");
File f = new File(location);
if (!f.exists() || !f.isDirectory())
throw new CacheException(String.format("Unable to read db directory '%s'", location));
Options options = new Options().setCreateIfMissing(false);
String compressionType = props.get(COMPRESSION);
if (compressionType != null) {
options.setCompressionType(CompressionType.getCompressionType(compressionType));
}
try {
this.db = RocksDB.openReadOnly(options, location);
} catch (RocksDBException e) {
throw new CacheException(e);
}
this.marshaller = SerializationConfigUtil.getMarshaller(props);
this.entryFactory = new MarshalledEntryFactoryImpl(marshaller);
}
@Override
public void close() {
db.close();
}
@Override
public Iterator<MarshallableEntry> iterator() {
return new RocksDBIterator();
}
class RocksDBIterator implements Iterator<MarshallableEntry>, AutoCloseable {
final RocksIterator it;
private RocksDBIterator() {
this.it = db.newIterator(new ReadOptions().setFillCache(false));
it.seekToFirst();
}
@Override
public void close() {
it.close();
}
@Override
public boolean hasNext() {
return it.isValid();
}
@Override
public MarshallableEntry next() {
Object entry = unmarshall(it.value());
if (entry instanceof MarshalledEntryImpl) {
MarshalledEntryImpl me = (MarshalledEntryImpl) entry;
InternalMetadata meta = me.getMetadata();
long created = meta != null ? meta.created() : -1;
long lifespan = meta != null ? meta.lifespan() : -1;
entry = entryFactory.create(me.getKeyBytes(), me.getValueBytes(), me.getMetadataBytes(), null, created, lifespan);
}
it.next();
return (MarshallableEntry) entry;
}
@SuppressWarnings(value = "unchecked")
private <T> T unmarshall(byte[] bytes) {
try {
return (T) marshaller.objectFromByteBuffer(bytes);
} catch (Exception e) {
throw new PersistenceException(e);
}
}
}
}
| 3,769
| 33.587156
| 126
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/xsd/XSDoc.java
|
package org.infinispan.tools.xsd;
import java.io.File;
import java.io.InputStream;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import org.infinispan.tools.ToolUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
public class XSDoc {
public static class Schema {
final String namespace;
final String name;
final Document doc;
final int major;
final int minor;
public Schema(Document doc, String name) {
this.name = name;
this.doc = doc;
String versionedNamespace = getDocumentNamespace(doc);
if (versionedNamespace.startsWith("urn:")) {
int versionSeparator = versionedNamespace.lastIndexOf(':');
namespace = versionedNamespace.substring(0, versionSeparator);
String[] versionParts = versionedNamespace.substring(versionSeparator + 1).split("\\.");
major = Integer.parseInt(versionParts[0]);
minor = Integer.parseInt(versionParts[1]);
} else {
namespace = versionedNamespace;
major = 0;
minor = 0;
}
}
public boolean since(Schema schema) {
return (schema == null) || (this.major > schema.major) || ((this.major == schema.major) && (this.minor >= schema.minor));
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Schema schema = (Schema) o;
if (major != schema.major) return false;
if (minor != schema.minor) return false;
if (!namespace.equals(schema.namespace)) return false;
return name.equals(schema.name);
}
@Override
public int hashCode() {
int result = namespace.hashCode();
result = 31 * result + name.hashCode();
result = 31 * result + major;
result = 31 * result + minor;
return result;
}
}
private final Map<String, Document> xmls = new LinkedHashMap<>(32);
private final Map<String, Schema> latestSchemas = new LinkedHashMap<>(32);
private final Collection<Schema> skipSchemas = new HashSet<>(32);
private final Transformer xslt;
private final DocumentBuilder docBuilder;
private final Document indexDoc;
private final Element indexRoot;
private final TransformerFactory factory;
XSDoc() throws Exception {
factory = TransformerFactory.newInstance();
factory.setURIResolver((href, base) -> {
Document doc = xmls.get(ToolUtils.getBaseFileName(href));
if (doc != null) {
return new DOMSource(doc);
} else {
return null;
}
});
ClassLoader cl = XSDoc.class.getClassLoader();
try (InputStream xsl = cl.getResourceAsStream("xsd/xsdoc.xslt")) {
xslt = factory.newTransformer(new StreamSource(xsl));
}
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
docBuilder = dbf.newDocumentBuilder();
indexDoc = docBuilder.newDocument();
indexRoot = indexDoc.createElement("files");
indexDoc.appendChild(indexRoot);
}
void load(String fileName, boolean skipTransform) throws Exception {
Document doc = docBuilder.parse(new File(fileName));
String name = ToolUtils.getBaseFileName(fileName);
xmls.put(name, doc);
Schema schema = new Schema(doc, name);
Schema current = latestSchemas.get(schema.namespace);
if (schema.since(current)) {
latestSchemas.put(schema.namespace, schema);
}
if (skipTransform) {
skipSchemas.add(schema);
}
}
private void transform(String name, Document doc, File outputDir) {
try {
xslt.transform(new DOMSource(doc), new StreamResult(new File(outputDir, name + ".html")));
Element item = indexDoc.createElement("file");
item.setAttribute("name", name + ".html");
String ns = getDocumentNamespace(doc);
item.setAttribute("ns", ns);
indexRoot.appendChild(item);
} catch (TransformerException e) {
throw new RuntimeException(e);
}
}
public static String getDocumentNamespace(Document doc) {
Node child = doc.getFirstChild();
while (!(child instanceof Element)) child = child.getNextSibling();
return ((Element) child).getAttribute("targetNamespace");
}
void transformAll(File outputDir) {
latestSchemas.values().stream()
.filter(schema -> !skipSchemas.contains(schema))
.forEach(schema -> transform(schema.name, schema.doc, outputDir));
}
private void generateIndex(File outputDir) throws Exception {
ToolUtils.printDocument(indexDoc, System.out);
ClassLoader cl = XSDoc.class.getClassLoader();
try (InputStream xsl = cl.getResourceAsStream("xsd/index.xslt")) {
Transformer indexXSLT = factory.newTransformer(new StreamSource(xsl));
indexXSLT.transform(new DOMSource(indexDoc), new StreamResult(new File(outputDir, "index.html")));
}
}
public static void main(String[] argv) throws Exception {
XSDoc xsDoc = new XSDoc();
String outputDir = System.getProperty("user.dir");
HashSet<String> skipSchema = new HashSet<>(32);
LinkedHashSet<String> files = new LinkedHashSet<>();
for (int i = 0; i < argv.length; i++) {
switch (argv[i]) {
case "-o":
outputDir = argv[++i];
break;
case "-s":
skipSchema.add(ToolUtils.getBaseFileName(argv[++i]));
break;
default:
files.add(argv[i]);
}
}
File outDir = new File(outputDir);
outDir.mkdirs();
for (String file : files) {
xsDoc.load(file, skipSchema.contains(ToolUtils.getBaseFileName(file)));
}
xsDoc.transformAll(outDir);
xsDoc.generateIndex(outDir);
}
}
| 6,477
| 33.827957
| 130
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/licenses/LicenseReplacer.java
|
package org.infinispan.tools.licenses;
import static java.lang.System.exit;
import static org.infinispan.tools.ToolUtils.EMPTY;
import static org.infinispan.tools.ToolUtils.findFirstChildByPath;
import static org.infinispan.tools.ToolUtils.findFirstChildByTagName;
import static org.infinispan.tools.ToolUtils.parseXMLDependencies;
import static org.infinispan.tools.ToolUtils.removeEmptyLinesFromFile;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.TransformerException;
import org.infinispan.tools.Dependency;
import org.infinispan.tools.ToolUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
/**
* Looks for "unknown" or "empty" license information and replaces.
* <p>
* It reads an XML file with the licenses (usually manually created) and replaces all the "unknown" or "missing"
* licenses information from an XMl licenses file. It does not touch entries with correct license information.
*
* @author Pedro Ruivo
* @since 12.0
**/
public class LicenseReplacer {
private final DocumentBuilder docBuilder;
private final Document emptyDocument;
private final Map<String, Node> overwriteArtifacts = new ConcurrentHashMap<>();
private Document licensesDoc;
private boolean verbose;
LicenseReplacer() throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
docBuilder = dbf.newDocumentBuilder();
emptyDocument = docBuilder.newDocument();
}
public static void main(String[] argv) throws Exception {
LicenseReplacer replacer = new LicenseReplacer();
File outputFile = new File(System.getProperty("user.dir"), "licenses.xml");
for (int i = 0; i < argv.length; i++) {
switch (argv[i]) {
case "-v":
replacer.setVerbose();
break;
case "-i":
replacer.loadOverwriteXML(argv[++i]);
break;
case "-o":
outputFile = new File(argv[++i]);
break;
case "-l":
replacer.loadLicenseFromXML(argv[++i]);
break;
}
}
if (replacer.licensesDoc == null || replacer.licensesDoc == replacer.emptyDocument) {
System.err.println("License XML file is invalid or missing. Did you use '-l' option?");
exit(1);
}
if (!outputFile.getParentFile().exists() && !outputFile.getParentFile().mkdirs()) {
System.err.printf("Unable to create output file \"%s\"%n", outputFile.getAbsolutePath());
exit(2);
}
if (replacer.overwriteArtifacts.isEmpty()) {
System.err.println("Licenses overwrite XML file is empty or missing! Did you use '-i' option?");
exit(3);
}
try (OutputStream os = new FileOutputStream(outputFile)) {
replacer.write(os);
if (replacer.verbose) {
System.out.printf("Wrote merged licenses to %s%n", outputFile);
}
}
removeEmptyLinesFromFile(outputFile);
}
public void write(OutputStream os) throws TransformerException {
Document aggregated = docBuilder.newDocument();
Element aggregatedDependencies = (Element) aggregated
.appendChild(aggregated.createElement("licenseSummary"))
.appendChild(aggregated.createElement("dependencies"));
List<Node> children = new LinkedList<>();
if (licensesDoc != null && licensesDoc != emptyDocument) {
for (Dependency dep : parseXMLDependencies(licensesDoc)) {
Node depNode = aggregated.adoptNode(dep.getNode().cloneNode(true));
String licenseName = findFirstChildByPath(depNode, "licenses/license/name")
.map(ToolUtils::textFromNode)
.orElse(EMPTY);
if (licenseName.isEmpty() || "unknown".equalsIgnoreCase(licenseName)) {
Node overwriteNode = overwriteArtifacts.get(dep.getArtifact());
if (overwriteNode != null) {
if (verbose) {
System.out.printf("Overwriting license information for \"%s\"%n", dep.getArtifact());
}
findFirstChildByTagName(depNode, "licenses")
.ifPresent(depNode::removeChild);
findFirstChildByTagName(overwriteNode, "licenses")
.ifPresent(node -> depNode.appendChild(aggregated.adoptNode(node.cloneNode(true))));
}
}
children.add(depNode);
}
}
children.forEach(aggregatedDependencies::appendChild);
ToolUtils.printDocument(aggregated, os);
}
void loadOverwriteXML(String fileName) throws IOException, SAXException {
System.out.printf("Loading XML with overwrites from \"%s\"%n", fileName);
Document doc = docBuilder.parse(new File(fileName));
if (doc == emptyDocument) {
System.err.printf("File \"%s\" is empty!%n", fileName);
}
ToolUtils.parseXMLDependencies(doc)
.forEach(deo -> {
overwriteArtifacts.put(deo.getArtifact(), deo.getNode());
if (verbose) {
System.out.printf("Found artifact %s to overwrite.%n", deo.getArtifact());
}
});
}
private void setVerbose() {
this.verbose = true;
}
private void loadLicenseFromXML(String fileName) throws Exception {
System.out.printf("Loading licenses from XML \"%s\"%n", fileName);
licensesDoc = docBuilder.parse(new File(fileName));
if (licensesDoc == emptyDocument) {
System.err.printf("File \"%s\" is empty!%n", fileName);
}
}
}
| 6,019
| 38.346405
| 112
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/licenses/LicenseMerger.java
|
package org.infinispan.tools.licenses;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.TransformerException;
import org.infinispan.tools.Dependency;
import org.infinispan.tools.ToolUtils;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class LicenseMerger {
private final DocumentBuilder docBuilder;
private final Map<String, Document> xmls = new LinkedHashMap<>();
private final Document emptyDocument;
private boolean verbose;
LicenseMerger() throws Exception {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
dbf.setNamespaceAware(true);
docBuilder = dbf.newDocumentBuilder();
emptyDocument = docBuilder.newDocument();
}
private void setVerbose(boolean verbose) {
this.verbose = verbose;
}
private void loadLicenseFromJar(String fileName) throws Exception {
try (JarFile jar = new JarFile(fileName)) {
JarEntry entry = jar.getJarEntry("META-INF/licenses.xml");
if (entry != null) {
try (InputStream inputStream = jar.getInputStream(entry)) {
Document doc = docBuilder.parse(inputStream);
xmls.put(ToolUtils.getBaseFileName(fileName), doc);
if (verbose) {
System.out.printf("Loaded license from JAR %s%n", fileName);
}
}
} else {
xmls.put(ToolUtils.getBaseFileName(fileName), emptyDocument);
if (verbose) {
System.out.printf("Empty license for JAR %s%n", fileName);
}
}
}
}
private void loadLicenseFromXML(String fileName) throws Exception {
Document doc = docBuilder.parse(new File(fileName));
xmls.put(ToolUtils.getBaseFileName(fileName), doc);
if (verbose) {
System.out.printf("Loaded license from XML %s%n", fileName);
}
}
void loadLicense(String filename) throws Exception {
if (filename.endsWith(".jar"))
loadLicenseFromJar(filename);
else if (filename.endsWith(".xml"))
loadLicenseFromXML(filename);
else
throw new IllegalArgumentException(filename);
}
public void write(boolean inclusiveMode, OutputStream os) throws TransformerException {
if (verbose) {
System.out.printf("Inclusive mode %s%n", inclusiveMode);
}
Document aggregated = docBuilder.newDocument();
Element aggregatedDependencies = (Element) aggregated
.appendChild(aggregated.createElement("licenseSummary"))
.appendChild(aggregated.createElement("dependencies"));
Map<String, Node> artifacts = new ConcurrentHashMap<>();
// Loop through all of the collected licenses.xml files
for (Map.Entry<String, Document> l : xmls.entrySet()) {
Document doc = l.getValue();
if (doc == emptyDocument) continue;
for (Dependency dep : ToolUtils.parseXMLDependencies(doc)) {
if (!inclusiveMode || xmls.containsKey(String.format("%s-%s", dep.getArtifact(), dep.getVersion()))) {
artifacts.computeIfAbsent(dep.getId(), a -> aggregated.adoptNode(dep.getNode().cloneNode(true)));
}
}
}
artifacts.entrySet().stream()
.sorted(Map.Entry.comparingByKey())
.forEach(entry -> aggregatedDependencies.appendChild(entry.getValue()));
ToolUtils.printDocument(aggregated, os);
}
public static void main(String[] argv) throws Exception {
LicenseMerger licenseMerger = new LicenseMerger();
File outputFile = new File(System.getProperty("user.dir"), "licenses.xml");
boolean inclusiveMode = false;
boolean verbose = false;
LinkedHashSet<String> files = new LinkedHashSet<>();
for(int i = 0; i < argv.length; i++) {
switch (argv[i]) {
case "-v":
verbose = true;
licenseMerger.setVerbose(true);
break;
case "-i":
inclusiveMode = true;
break;
case "-o":
outputFile = new File(argv[++i]);
break;
case "-r":
String[] responseData = new String(Files.readAllBytes(Paths.get(argv[++i])), StandardCharsets.UTF_8).split("\\s+");
for(String filename : responseData) {
licenseMerger.loadLicense(filename);
}
break;
default:
files.add(argv[i]);
}
}
outputFile.getParentFile().mkdirs();
for (String file : files) {
licenseMerger.loadLicense(file);
}
try (OutputStream os = new FileOutputStream(outputFile)) {
licenseMerger.write(inclusiveMode, os);
if (verbose) {
System.out.printf("Wrote merged licenses to %s%n", outputFile);
}
}
ToolUtils.removeEmptyLinesFromFile(outputFile);
}
}
| 5,497
| 35.171053
| 130
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/io/micrometer/core/instrument/binder/cache/NotAuthorizedRemoteCacheMetricBinderTest.java
|
package io.micrometer.core.instrument.binder.cache;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.simple.SimpleMeterRegistry;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ClientIntelligence;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.commons.configuration.StringConfiguration;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.api.TestUser;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.infinispan.spring.common.provider.SpringCache;
import org.infinispan.spring.starter.remote.actuator.RemoteInfinispanCacheMeterBinderProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
import static java.util.Collections.emptyList;
import static org.assertj.core.api.Assertions.assertThat;
public class NotAuthorizedRemoteCacheMetricBinderTest {
@RegisterExtension
static InfinispanServerExtension infinispanServerExtension = InfinispanServerExtensionBuilder.server();
private RemoteCache<String, String> cacheAdminConnection;
private RemoteCache<String, String> cacheObserverConnection;
private MeterRegistry registry = new SimpleMeterRegistry();
private CacheMeterBinder binder;
@BeforeEach
void bindToRegistry() {
this.binder = this.binder();
this.binder.bindTo(this.registry);
}
public CacheMeterBinder binder() {
org.infinispan.configuration.cache.ConfigurationBuilder cacheConfigBuilder =
new org.infinispan.configuration.cache.ConfigurationBuilder();
cacheConfigBuilder.clustering().cacheMode(CacheMode.DIST_SYNC);
cacheConfigBuilder.security().authorization().roles("admin");
StringConfiguration stringConfiguration =
new StringConfiguration(cacheConfigBuilder.build().toStringConfiguration("mycache"));
ConfigurationBuilder clientBuilder = new ConfigurationBuilder();
clientBuilder.statistics().enable();
clientBuilder.clientIntelligence(ClientIntelligence.BASIC);
clientBuilder.security()
.authentication()
.username(TestUser.ADMIN.getUser())
.password(TestUser.ADMIN.getPassword());
RemoteCacheManager remoteCacheManagerAdmin =
infinispanServerExtension.hotrod().withClientConfiguration(clientBuilder)
.createRemoteCacheManager();
cacheAdminConnection = remoteCacheManagerAdmin.administration().getOrCreateCache("mycache", stringConfiguration);
clientBuilder = new ConfigurationBuilder();
clientBuilder.statistics().enable();
clientBuilder.clientIntelligence(ClientIntelligence.BASIC);
clientBuilder.security()
.authentication()
.username(TestUser.OBSERVER.getUser())
.password(TestUser.OBSERVER.getPassword());
RemoteCacheManager remoteCacheManagerObserver =
infinispanServerExtension.hotrod().withClientConfiguration(clientBuilder)
.createRemoteCacheManager();
// The cache is got with OBSERVER instead of ADMIN
cacheObserverConnection = remoteCacheManagerObserver.getCache("mycache");
RemoteInfinispanCacheMeterBinderProvider remoteInfinispanCacheMeterBinderProvider =
new RemoteInfinispanCacheMeterBinderProvider();
return (CacheMeterBinder) remoteInfinispanCacheMeterBinderProvider
.getMeterBinder(new SpringCache(cacheObserverConnection), emptyList());
}
@Test
void puts() {
cacheAdminConnection.put("k", "v");
assertThat(this.binder.putCount()).isEqualTo(0L);
assertThat(this.registry.get("cache.puts").tag("cache", "mycache").functionCounter().count()).isEqualTo(0.0);
}
@Test
void gets() {
cacheAdminConnection.put("k", "v");
cacheAdminConnection.get("k");
cacheAdminConnection.get("does.not.exist");
assertThat(this.binder.hitCount()).isEqualTo(0L);
assertThat(this.registry.get("cache.gets").tag("result", "hit").tag("cache", "mycache").functionCounter().count()).isEqualTo(0.0);
if (this.binder.missCount() != null) {
assertThat(this.binder.missCount()).isIn(new Object[]{0L});
assertThat(this.registry.get("cache.gets").tag("result", "miss").tag("cache", "mycache").functionCounter().count()).isIn(new Object[]{0.0});
}
}
}
| 4,646
| 44.116505
| 149
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/ApplicationPropertiesTest.java
|
package test.org.infinispan.spring.starter.remote;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ClientIntelligence;
import org.infinispan.client.hotrod.configuration.ClusterConfiguration;
import org.infinispan.client.hotrod.configuration.Configuration;
import org.infinispan.client.hotrod.configuration.ExhaustedAction;
import org.infinispan.client.hotrod.configuration.NearCacheMode;
import org.infinispan.client.hotrod.configuration.TransactionMode;
import org.infinispan.client.hotrod.impl.async.DefaultAsyncExecutorFactory;
import org.infinispan.client.hotrod.security.BasicCallbackHandler;
import org.infinispan.commons.marshall.JavaSerializationMarshaller;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.sasl.RealmCallback;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.groups.Tuple.tuple;
@SpringBootTest(
classes = {
InfinispanRemoteAutoConfiguration.class,
InfinispanRemoteCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off"
})
@TestPropertySource(locations = "classpath:test-application.properties")
public class ApplicationPropertiesTest {
@Autowired
private RemoteCacheManager remoteCacheManager;
@Test
public void testDefaultClient() throws Exception {
//when
Configuration configuration = remoteCacheManager.getConfiguration();
String hostObtainedFromPropertiesFile = configuration.servers().get(0).host();
int portObtainedFromPropertiesFile = configuration.servers().get(0).port();
configuration.asyncExecutorFactory().factoryClass();
// properties
assertThat(hostObtainedFromPropertiesFile).isEqualTo("180.567.112.333");
assertThat(portObtainedFromPropertiesFile).isEqualTo(6668);
assertThat(configuration.tcpNoDelay()).isFalse();
assertThat(configuration.tcpKeepAlive()).isTrue();
assertThat(configuration.clientIntelligence()).isEqualTo(ClientIntelligence.TOPOLOGY_AWARE);
assertThat(configuration.socketTimeout()).isEqualTo(500);
assertThat(configuration.connectionTimeout()).isEqualTo(200);
assertThat(configuration.maxRetries()).isEqualTo(30);
assertThat(configuration.batchSize()).isEqualTo(91);
assertThat(configuration.version()).isEqualTo(ProtocolVersion.PROTOCOL_VERSION_24);
// pool
assertThat(configuration.connectionPool().maxActive()).isEqualTo(90);
assertThat(configuration.connectionPool().maxWait()).isEqualTo(20000);
assertThat(configuration.connectionPool().minIdle()).isEqualTo(1000);
assertThat(configuration.connectionPool().maxPendingRequests()).isEqualTo(845);
assertThat(configuration.connectionPool().minEvictableIdleTime()).isEqualTo(9000);
assertThat(configuration.connectionPool().exhaustedAction()).isEqualTo(ExhaustedAction.CREATE_NEW);
// Thread pool properties
assertThat(configuration.asyncExecutorFactory().factoryClass()).isEqualTo(DefaultAsyncExecutorFactory.class);
// TODO: how to assert thread pool size ? default-executor-factory-pool-size
// Marshalling properties
assertThat(configuration.marshallerClass()).isEqualTo(JavaSerializationMarshaller.class);
assertThat(configuration.keySizeEstimate()).isEqualTo(88889);
assertThat(configuration.valueSizeEstimate()).isEqualTo(11112);
assertThat(configuration.forceReturnValues()).isTrue();
assertThat(configuration.serialWhitelist()).contains("APP-KILLER1", "APP-KILLER2");
// TODO: Consistent Hash Impl ??
//assertThat(configuration.consistentHashImpl().getClass().toString()).isEqualTo("");
// Encryption properties
assertThat(configuration.security().ssl().enabled()).isTrue();
assertThat(configuration.security().ssl().keyStoreFileName()).isEqualTo("superKeyStoreFile");
assertThat(configuration.security().ssl().keyStoreType()).isEqualTo("SKL");
assertThat(configuration.security().ssl().keyStorePassword().length).isEqualTo(17);
assertThat(configuration.security().ssl().keyAlias()).isEqualTo("superAliasKey");
assertThat(configuration.security().ssl().keyStoreCertificatePassword()).hasSize(13);
assertThat(configuration.security().ssl().trustStoreFileName()).isEqualTo("superTrustFileName");
assertThat(configuration.security().ssl().trustStorePath()).isNull();
assertThat(configuration.security().ssl().trustStoreType()).isEqualTo("CKO");
assertThat(configuration.security().ssl().trustStorePassword().length).isEqualTo(18);
assertThat(configuration.security().ssl().sniHostName()).isEqualTo("elahost");
assertThat(configuration.security().ssl().protocol()).isEqualTo("TLSv1.4");
// authentication
assertThat(configuration.security().authentication().enabled()).isTrue();
assertThat(configuration.security().authentication().callbackHandler().getClass()).isEqualTo(BasicCallbackHandler.class);
assertThat(configuration.security().authentication().saslMechanism()).isEqualTo("my-sasl-mechanism");
assertThat(configuration.security().authentication().serverName()).isEqualTo("my-server-name");
BasicCallbackHandler basicCallbackHandler = (BasicCallbackHandler) configuration.security().authentication().callbackHandler();
NameCallback nameCallback = new NameCallback("test", "test");
PasswordCallback passwordCallback = new PasswordCallback("test", false);
RealmCallback realmCallback = new RealmCallback("test", "test");
basicCallbackHandler.handle(new Callback[]{nameCallback, passwordCallback, realmCallback});
assertThat(nameCallback.getName()).isEqualTo("oihana");
assertThat(passwordCallback.getPassword()).isEqualTo("oipass".toCharArray());
assertThat(realmCallback.getText()).isEqualTo("oirealm");
assertThat(configuration.security().authentication().saslProperties()).hasSize(2);
assertThat(configuration.security().authentication().saslProperties()).containsKeys("prop1", "prop2");
assertThat(configuration.security().authentication().saslProperties()).containsValues("value1", "value2");
// transactions
assertThat(configuration.transaction().transactionMode()).isEqualTo(TransactionMode.NON_DURABLE_XA);
assertThat(configuration.transaction().timeout()).isEqualTo(50000);
// near cache
assertThat(configuration.nearCache().mode()).isEqualTo(NearCacheMode.INVALIDATED);
assertThat(configuration.nearCache().maxEntries()).isEqualTo(2000);
assertThat(configuration.nearCache().cacheNamePattern().pattern()).isEqualTo("appCache*");
// xsite
assertThat(configuration.clusters()).hasSize(1);
ClusterConfiguration site = configuration.clusters().get(0);
assertThat(site.getCluster()).extracting("host", "port").containsExactly(tuple("hostOi1", 21222), tuple("hostOi2", 21223));
// statistics
assertThat(configuration.statistics().enabled()).isTrue();
assertThat(configuration.statistics().jmxEnabled()).isTrue();
assertThat(configuration.statistics().jmxName()).isEqualTo("oiJmx");
assertThat(configuration.statistics().jmxDomain()).isEqualTo("oiJmxDom");
}
}
| 7,847
| 55.869565
| 133
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/PreventingAutoCreatingBeansTest.java
|
package test.org.infinispan.spring.starter.remote;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(
classes = {
InfinispanRemoteAutoConfiguration.class,
InfinispanRemoteCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"infinispan.remote.client-properties=test-hotrod-client.properties",
"infinispan.remote.enabled=false"
}
)
public class PreventingAutoCreatingBeansTest {
@Autowired
private ListableBeanFactory beanFactory;
@Test
public void testIfNoDefaultClientWasCreated() {
assertThat(beanFactory.getBeansOfType(RemoteCacheManager.class)).isEmpty();
}
@Test
public void testIfNoEmbeddedCacheManagerWasCreated() {
assertThat(beanFactory.containsBeanDefinition("defaultCacheManager")).isFalse();
}
}
| 1,337
| 33.307692
| 90
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/IntegrationTest.java
|
package test.org.infinispan.spring.starter.remote;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.spring.remote.provider.SpringRemoteCacheManager;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import test.org.infinispan.spring.starter.remote.testconfiguration.InfinispanCacheTestConfiguration;
@SpringBootTest(
classes = {
InfinispanRemoteAutoConfiguration.class,
InfinispanRemoteCacheManagerAutoConfiguration.class,
InfinispanCacheTestConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"infinispan.remote.client-properties=test-hotrod-client.properties"
}
)
public class IntegrationTest {
@Autowired
private RemoteCacheManager remoteCacheManager;
@Autowired
private SpringRemoteCacheManager springRemoteCacheManager;
@Test
public void testConfiguredClient() {
int portObtainedFromPropertiesFile = remoteCacheManager.getConfiguration().servers().get(0).port();
assertThat(portObtainedFromPropertiesFile).isEqualTo(11555);
}
@Test
public void testIfSpringCachingWasCreatedUsingProperEmbeddedCacheManager() throws Exception {
assertThat(remoteCacheManager).isEqualTo(springRemoteCacheManager.getNativeCacheManager());
}
}
| 1,650
| 35.688889
| 105
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/EnablingTest.java
|
package test.org.infinispan.spring.starter.remote;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.infinispan.spring.starter.remote.actuator.RemoteInfinispanCacheMeterBinderProvider;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(
classes = {
InfinispanRemoteAutoConfiguration.class,
InfinispanRemoteCacheManagerAutoConfiguration.class},
properties = {
"spring.main.banner-mode=off",
"infinispan.remote.client-properties=test-hotrod-client.properties",
"infinispan.remote.enabled=true"
}
)
public class EnablingTest {
@Autowired
private ListableBeanFactory beanFactory;
@Test
public void testDefaultClient() {
assertThat(beanFactory.containsBeanDefinition(InfinispanRemoteAutoConfiguration.REMOTE_CACHE_MANAGER_BEAN_QUALIFIER)).isTrue();
assertThat(beanFactory.containsBeanDefinition(RemoteInfinispanCacheMeterBinderProvider.NAME)).isTrue();
}
}
| 1,337
| 38.352941
| 133
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/CustomPropertiesTest.java
|
package test.org.infinispan.spring.starter.remote;
import org.infinispan.client.hotrod.ProtocolVersion;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ClientIntelligence;
import org.infinispan.client.hotrod.configuration.ClusterConfiguration;
import org.infinispan.client.hotrod.configuration.Configuration;
import org.infinispan.client.hotrod.configuration.ExhaustedAction;
import org.infinispan.client.hotrod.configuration.NearCacheMode;
import org.infinispan.client.hotrod.configuration.TransactionMode;
import org.infinispan.client.hotrod.impl.async.DefaultAsyncExecutorFactory;
import org.infinispan.client.hotrod.security.BasicCallbackHandler;
import org.infinispan.commons.marshall.JavaSerializationMarshaller;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import javax.security.auth.callback.Callback;
import javax.security.auth.callback.NameCallback;
import javax.security.auth.callback.PasswordCallback;
import javax.security.sasl.RealmCallback;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.groups.Tuple.tuple;
@SpringBootTest(
classes = {
InfinispanRemoteAutoConfiguration.class,
InfinispanRemoteCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"infinispan.remote.client-properties=custom-test-hotrod-client.properties"
}
)
public class CustomPropertiesTest {
@Autowired
private RemoteCacheManager remoteCacheManager;
@Test
public void testDefaultClient() throws Exception {
//when
Configuration configuration = remoteCacheManager.getConfiguration();
String hostObtainedFromPropertiesFile = configuration.servers().get(0).host();
int portObtainedFromPropertiesFile = configuration.servers().get(0).port();
// Connection
assertThat(hostObtainedFromPropertiesFile).isEqualTo("127.0.0.1");
assertThat(portObtainedFromPropertiesFile).isEqualTo(6667);
assertThat(configuration.tcpNoDelay()).isFalse();
assertThat(configuration.tcpKeepAlive()).isTrue();
assertThat(configuration.clientIntelligence()).isEqualTo(ClientIntelligence.TOPOLOGY_AWARE);
assertThat(configuration.socketTimeout()).isEqualTo(3000);
assertThat(configuration.connectionTimeout()).isEqualTo(5000);
assertThat(configuration.maxRetries()).isEqualTo(42);
assertThat(configuration.batchSize()).isEqualTo(90);
assertThat(configuration.version()).isEqualTo(ProtocolVersion.PROTOCOL_VERSION_28);
// Connection pool properties
assertThat(configuration.connectionPool().maxActive()).isEqualTo(91);
assertThat(configuration.connectionPool().exhaustedAction()).isEqualTo(ExhaustedAction.EXCEPTION);
assertThat(configuration.connectionPool().maxWait()).isEqualTo(20001);
assertThat(configuration.connectionPool().minIdle()).isEqualTo(1001);
assertThat(configuration.connectionPool().minEvictableIdleTime()).isEqualTo(9001);
assertThat(configuration.connectionPool().maxPendingRequests()).isEqualTo(846);
// Thread pool properties
assertThat(configuration.asyncExecutorFactory().factoryClass()).isEqualTo(DefaultAsyncExecutorFactory.class);
// TODO: how to assert thread pool size ? default_executor_factory.pool_size
// Marshalling properties
assertThat(configuration.marshallerClass()).isEqualTo(JavaSerializationMarshaller.class);
assertThat(configuration.keySizeEstimate()).isEqualTo(123456);
assertThat(configuration.valueSizeEstimate()).isEqualTo(789012);
assertThat(configuration.forceReturnValues()).isTrue();
assertThat(configuration.serialWhitelist()).contains("SERIAL-KILLER");
// TODO: Consistent Hash Impl ??
//assertThat(configuration.consistentHashImpl().getClass().toString()).isEqualTo("");
// Encryption properties
assertThat(configuration.security().ssl().enabled()).isTrue();
assertThat(configuration.security().ssl().keyStoreFileName()).isEqualTo("keyStoreFile");
assertThat(configuration.security().ssl().keyStoreType()).isEqualTo("JKS");
assertThat(configuration.security().ssl().keyStorePassword()).hasSize(12);
assertThat(configuration.security().ssl().keyAlias()).isEqualTo("aliasKey");
assertThat(configuration.security().ssl().keyStoreCertificatePassword()).hasSize(9);
assertThat(configuration.security().ssl().trustStoreFileName()).isEqualTo("trustFileName");
assertThat(configuration.security().ssl().trustStorePath()).isNull();
assertThat(configuration.security().ssl().trustStoreType()).isEqualTo("LOL");
assertThat(configuration.security().ssl().trustStorePassword().length).isEqualTo(13);
assertThat(configuration.security().ssl().sniHostName()).isEqualTo("oihost");
assertThat(configuration.security().ssl().protocol()).isEqualTo("TLSv1.3");
// authentication
assertThat(configuration.security().authentication().enabled()).isTrue();
assertThat(configuration.security().authentication().saslMechanism()).isEqualTo("DIGEST-MD5");
assertThat(configuration.security().authentication().callbackHandler()).isInstanceOf(BasicCallbackHandler.class);
assertThat(configuration.security().authentication().serverName()).isEqualTo("my_ela_server_name");
BasicCallbackHandler basicCallbackHandler = (BasicCallbackHandler) configuration.security().authentication().callbackHandler();
NameCallback nameCallback = new NameCallback("test", "test");
PasswordCallback passwordCallback = new PasswordCallback("test", false);
RealmCallback realmCallback = new RealmCallback("test", "test");
basicCallbackHandler.handle(new Callback[]{nameCallback, passwordCallback, realmCallback});
assertThat(nameCallback.getName()).isEqualTo("elaia");
assertThat(passwordCallback.getPassword()).isEqualTo("elapass".toCharArray());
assertThat(realmCallback.getText()).isEqualTo("elarealm");
assertThat(configuration.security().authentication().saslProperties()).hasSize(1);
assertThat(configuration.security().authentication().saslProperties()).containsOnlyKeys("prop1");
assertThat(configuration.security().authentication().saslProperties()).containsValues("value1");
// Transaction properties
// TODO: transaction_manager_lookup??
assertThat(configuration.transaction().transactionMode()).isEqualTo(TransactionMode.FULL_XA);
assertThat(configuration.transaction().timeout()).isEqualTo(50001);
// near cache
assertThat(configuration.nearCache().mode()).isEqualTo(NearCacheMode.INVALIDATED);
assertThat(configuration.nearCache().maxEntries()).isEqualTo(10000);
assertThat(configuration.nearCache().cacheNamePattern().pattern()).isEqualTo("nearSuperCache*");
// xsite
assertThat(configuration.clusters()).hasSize(2);
ClusterConfiguration siteA = configuration.clusters().get(0);
ClusterConfiguration siteB = configuration.clusters().get(1);
assertThat(siteA.getClusterName()).isEqualTo("siteA");
assertThat(siteB.getClusterName()).isEqualTo("siteB");
assertThat(siteA.getCluster()).extracting("host", "port").containsExactly(tuple("hostA1", 11222), tuple("hostA2", 11223));
assertThat(siteB.getCluster()).extracting("host", "port").containsExactly(tuple("hostB1", 11224), tuple("hostB2", 11225));
// statistics
assertThat(configuration.statistics().enabled()).isTrue();
assertThat(configuration.statistics().jmxEnabled()).isTrue();
assertThat(configuration.statistics().jmxName()).isEqualTo("elaJmx");
assertThat(configuration.statistics().jmxDomain()).isEqualTo("elaJmxDom2");
}
}
| 8,068
| 56.635714
| 133
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/CustomConfigurationTest.java
|
package test.org.infinispan.spring.starter.remote;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheCustomizer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.Ordered;
import org.springframework.core.annotation.Order;
@SpringBootTest(
classes = {
CustomConfigurationTest.TestConfiguration.class,
InfinispanRemoteAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off"
}
)
public class CustomConfigurationTest {
@Autowired
private RemoteCacheManager manager;
@Test
public void testConfiguredClient() {
assertThat(manager.getConfiguration().servers().get(0).port()).isEqualTo(6667);
assertThat(manager.getConfiguration().tcpNoDelay()).isFalse();
assertThat(manager.getConfiguration().tcpKeepAlive()).isFalse();
}
@Configuration
static class TestConfiguration {
@Bean
public org.infinispan.client.hotrod.configuration.Configuration customConfiguration() {
return new ConfigurationBuilder()
.addServers("127.0.0.1:6667")
.tcpNoDelay(false)
.tcpKeepAlive(true)
.build();
}
@Order(Ordered.HIGHEST_PRECEDENCE)
@Bean
public InfinispanRemoteCacheCustomizer customizer() {
return b -> b.tcpKeepAlive(false);
}
}
}
| 1,886
| 33.309091
| 93
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/InfinispanJmxConfigurationTest.java
|
package test.org.infinispan.spring.starter.remote;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.spring.starter.remote.InfinispanJmxConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.jmx.export.MBeanExporter;
@SpringBootTest(classes = {
InfinispanRemoteAutoConfiguration.class,
InfinispanRemoteCacheManagerAutoConfiguration.class,
InfinispanJmxConfiguration.class,
MBeanExporter.class},
properties = {
"spring.main.banner-mode=off",
"infinispan.remote.server-list=180.567.112.333:6668",
"infinispan.remote.jmx=true",
"infinispan.remote.enabled=true"})
public class InfinispanJmxConfigurationTest {
@Autowired
RemoteCacheManager remoteCacheManager;
@Test
public void contextIsUp() {
/**
* When JMX is enabled in Spring and Infinispan, if {@link InfinispanJmxConfiguration} does not exclude
* 'remoteCacheManager', this test will fail because context won't start
*/
assertThat(remoteCacheManager).isNotNull();
}
}
| 1,455
| 37.315789
| 110
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/CustomConfigurerWithPropertyInjectionTest.java
|
package test.org.infinispan.spring.starter.remote;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteConfigurer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@SpringBootTest(
classes = {
CustomConfigurerWithPropertyInjectionTest.TestConfiguration.class,
InfinispanRemoteAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"myServerList=localhost:6667"
}
)
public class CustomConfigurerWithPropertyInjectionTest {
@Autowired
private RemoteCacheManager manager;
@Test
public void testConfiguredClient() {
assertThat(manager.getConfiguration().servers().get(0).port()).isEqualTo(6667);
}
@Configuration
static class TestConfiguration {
@Value("${myServerList}")
private String serverList;
@Bean
public InfinispanRemoteConfigurer configuration() {
return () -> new ConfigurationBuilder()
.addServers(serverList)
.build();
}
}
}
| 1,583
| 32
| 85
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/DisablingTest.java
|
package test.org.infinispan.spring.starter.remote;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.infinispan.spring.starter.remote.actuator.RemoteInfinispanCacheMeterBinderProvider;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(
classes = {
InfinispanRemoteAutoConfiguration.class,
InfinispanRemoteCacheManagerAutoConfiguration.class},
properties = {
"spring.main.banner-mode=off",
"infinispan.remote.client-properties=test-hotrod-client.properties",
"infinispan.remote.enabled=false"
}
)
public class DisablingTest {
@Autowired
private ListableBeanFactory beanFactory;
@Test
public void testDefaultClient() {
assertThat(beanFactory.containsBeanDefinition(InfinispanRemoteAutoConfiguration.REMOTE_CACHE_MANAGER_BEAN_QUALIFIER)).isFalse();
assertThat(beanFactory.containsBeanDefinition(RemoteInfinispanCacheMeterBinderProvider.NAME)).isFalse();
}
}
| 1,341
| 38.470588
| 134
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/testconfiguration/InfinispanCacheTestConfiguration.java
|
package test.org.infinispan.spring.starter.remote.testconfiguration;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.spring.starter.remote.InfinispanRemoteConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class InfinispanCacheTestConfiguration {
public static final int PORT = 11555;
@Bean
public InfinispanRemoteConfigurer infinispanRemoteConfigurer() {
return () -> new ConfigurationBuilder().statistics().disable().addServer().host("127.0.0.1").port(PORT).build();
}
}
| 637
| 34.444444
| 118
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/test/java/test/org/infinispan/spring/starter/remote/actuator/RemoteCacheMetricBinderTest.java
|
package test.org.infinispan.spring.starter.remote.actuator;
import io.micrometer.core.instrument.binder.cache.CacheMeterBinder;
import io.micrometer.core.instrument.binder.cache.CacheMeterBinderCompatibilityKit;
import org.infinispan.client.hotrod.RemoteCache;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ClientIntelligence;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.commons.configuration.StringConfiguration;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.server.test.api.TestUser;
import org.infinispan.server.test.junit5.InfinispanServerExtension;
import org.infinispan.server.test.junit5.InfinispanServerExtensionBuilder;
import org.infinispan.spring.common.provider.SpringCache;
import org.infinispan.spring.starter.remote.actuator.RemoteInfinispanCacheMeterBinderProvider;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
import static java.util.Collections.emptyList;
public class RemoteCacheMetricBinderTest extends CacheMeterBinderCompatibilityKit {
@RegisterExtension
static InfinispanServerExtension infinispanServerExtension = InfinispanServerExtensionBuilder.server();
private RemoteCache<String, String> cache;
@Override
public CacheMeterBinder binder() {
org.infinispan.configuration.cache.ConfigurationBuilder cacheConfigBuilder =
new org.infinispan.configuration.cache.ConfigurationBuilder();
cacheConfigBuilder.clustering().cacheMode(CacheMode.DIST_SYNC);
StringConfiguration stringConfiguration =
new StringConfiguration(cacheConfigBuilder.build().toStringConfiguration("mycache"));
ConfigurationBuilder clientBuilder = new ConfigurationBuilder();
clientBuilder.statistics().enable();
clientBuilder.clientIntelligence(ClientIntelligence.BASIC);
clientBuilder.security()
.authentication()
.username(TestUser.ADMIN.getUser())
.password(TestUser.ADMIN.getPassword());
RemoteCacheManager remoteCacheManager =
infinispanServerExtension.hotrod().withClientConfiguration(clientBuilder)
.createRemoteCacheManager();
cache = remoteCacheManager.administration().getOrCreateCache("mycache", stringConfiguration);
RemoteInfinispanCacheMeterBinderProvider remoteInfinispanCacheMeterBinderProvider =
new RemoteInfinispanCacheMeterBinderProvider();
return (CacheMeterBinder) remoteInfinispanCacheMeterBinderProvider
.getMeterBinder(new SpringCache(cache), emptyList());
}
@Override
public Object createCache() {
return cache;
}
@Test
void size() {
// Do nothing
}
@Override
public void put(String key, String value) {
cache.put(key, value);
}
@Override
public String get(String key) {
return cache.get(key);
}
@Test
void dereferencedCacheIsGarbageCollected() {
// Do nothing
}
}
| 3,056
| 37.2125
| 106
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/InfinispanRemoteConfigurationProperties.java
|
package org.infinispan.spring.starter.remote;
import java.util.Map;
import java.util.Properties;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties(value = "infinispan.remote", ignoreInvalidFields = true)
public class InfinispanRemoteConfigurationProperties extends org.infinispan.client.hotrod.impl.ConfigurationProperties {
public static final String DEFAULT_CLIENT_PROPERTIES = "classpath:hotrod-client.properties";
/**
* Enable remote cache.
*/
private boolean enabled = true;
/**
* The hotrod client properties location.
*/
private String clientProperties = DEFAULT_CLIENT_PROPERTIES;
public String getClientProperties() {
return clientProperties;
}
public void setClientProperties(String clientProperties) {
this.clientProperties = clientProperties;
}
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public ConfigurationBuilder getConfigurationBuilder() {
ConfigurationBuilder builder = new ConfigurationBuilder();
Properties properties = this.getProperties();
builder.withProperties(properties);
return builder;
}
public void setSaslProperties(Map<String, String> saslProperties) {
saslProperties.forEach((k, v) -> this.getProperties().setProperty(SASL_PROPERTIES_PREFIX + "." + k, v));
}
public void setCluster(Map<String, String> cluster) {
cluster.forEach((k, v) -> this.getProperties().setProperty(CLUSTER_PROPERTIES_PREFIX + "." + k, v));
}
}
| 1,692
| 28.701754
| 120
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/InfinispanRemoteCacheCustomizer.java
|
package org.infinispan.spring.starter.remote;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
@FunctionalInterface
public interface InfinispanRemoteCacheCustomizer {
void customize(ConfigurationBuilder builder);
}
| 244
| 26.222222
| 71
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/InfinispanRemoteCacheManagerAutoConfiguration.java
|
package org.infinispan.spring.starter.remote;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.spring.remote.provider.SpringRemoteCacheManager;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan
//Since a jar with configuration might be missing (which would result in TypeNotPresentExceptionProxy), we need to
//use String based methods.
//See https://github.com/spring-projects/spring-boot/issues/1733
@ConditionalOnClass(name = "org.infinispan.spring.remote.provider.SpringRemoteCacheManager")
@ConditionalOnProperty(value = "infinispan.remote.cache.enabled", havingValue = "true", matchIfMissing = true)
public class InfinispanRemoteCacheManagerAutoConfiguration {
@Bean
@ConditionalOnBean(RemoteCacheManager.class)
@ConditionalOnMissingBean(type = {"org.infinispan.spring.remote.provider.SpringRemoteCacheManager", "org.infinispan.spring.remote.provider.SpringRemoteCacheManagerFactoryBean"})
public SpringRemoteCacheManager springRemoteCacheManager(RemoteCacheManager remoteCacheManager) {
return new SpringRemoteCacheManager(remoteCacheManager);
}
}
| 1,574
| 53.310345
| 180
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/InfinispanJmxConfiguration.java
|
package org.infinispan.spring.starter.remote;
import jakarta.annotation.PostConstruct;
import org.springframework.beans.factory.ObjectProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Configuration;
import org.springframework.jmx.export.MBeanExporter;
/**
* Spring and Infinispan register the same bean. Avoid an exception telling Spring not to export Infinispan's
* bean
*
* @since 2.1.x
*/
@Configuration
@ConditionalOnProperty(prefix = "infinispan.remote", name = "jmx", havingValue = "true")
public class InfinispanJmxConfiguration {
private final ObjectProvider<MBeanExporter> mBeanExporter;
InfinispanJmxConfiguration(ObjectProvider<MBeanExporter> mBeanExporter) {
this.mBeanExporter = mBeanExporter;
}
@PostConstruct
public void excludeRemoteCacheManagerMBean() {
this.mBeanExporter
.ifUnique((exporter) -> exporter.addExcludedBean("remoteCacheManager"));
}
}
| 1,005
| 30.4375
| 109
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/InfinispanRemoteConfigurer.java
|
package org.infinispan.spring.starter.remote;
import org.infinispan.client.hotrod.configuration.Configuration;
@FunctionalInterface
public interface InfinispanRemoteConfigurer {
Configuration getRemoteConfiguration();
}
| 226
| 24.222222
| 64
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/InfinispanRemoteAutoConfiguration.java
|
package org.infinispan.spring.starter.remote;
import java.io.IOException;
import java.io.InputStream;
import java.lang.invoke.MethodHandles;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Properties;
import java.util.logging.Logger;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.client.hotrod.configuration.ConfigurationBuilder;
import org.infinispan.commons.marshall.JavaSerializationMarshaller;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration;
import org.springframework.boot.autoconfigure.cache.CacheType;
import org.springframework.boot.autoconfigure.condition.AnyNestedCondition;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ConfigurationCondition;
import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotatedTypeMetadata;
import org.springframework.util.StringUtils;
@Configuration
@ComponentScan
@AutoConfigureBefore(CacheAutoConfiguration.class)
//Since a jar with configuration might be missing (which would result in TypeNotPresentExceptionProxy), we need to
//use String based methods.
//See https://github.com/spring-projects/spring-boot/issues/1733
@ConditionalOnClass(name = "org.infinispan.client.hotrod.RemoteCacheManager")
@ConditionalOnProperty(value = "infinispan.remote.enabled", havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(InfinispanRemoteConfigurationProperties.class)
public class InfinispanRemoteAutoConfiguration {
private static final Logger logger = Logger.getLogger(MethodHandles.lookup().lookupClass().getName());
public static final String REMOTE_CACHE_MANAGER_BEAN_QUALIFIER = "remoteCacheManager";
@Autowired
private InfinispanRemoteConfigurationProperties infinispanProperties;
@Autowired(required = false)
private InfinispanRemoteConfigurer infinispanRemoteConfigurer;
@Autowired(required = false)
private org.infinispan.client.hotrod.configuration.Configuration infinispanConfiguration;
@Autowired(required = false)
private List<InfinispanRemoteCacheCustomizer> cacheCustomizers = Collections.emptyList();
@Autowired
private ApplicationContext ctx;
@Bean
@Conditional({ConditionalOnCacheType.class, ConditionalOnConfiguration.class})
@ConditionalOnMissingBean
@Qualifier(REMOTE_CACHE_MANAGER_BEAN_QUALIFIER)
public RemoteCacheManager remoteCacheManager() throws IOException {
boolean hasHotRodPropertiesFile = ctx.getResource(infinispanProperties.getClientProperties()).exists();
boolean hasConfigurer = infinispanRemoteConfigurer != null;
boolean hasProperties = StringUtils.hasText(infinispanProperties.getServerList());
ConfigurationBuilder builder = new ConfigurationBuilder();
//by default, add java white list and marshaller
builder.addJavaSerialAllowList("java.util.*", "java.time.*", "org.springframework.*", "org.infinispan.spring.common.*", "org.infinispan.spring.remote.*");
builder.marshaller(new JavaSerializationMarshaller());
if (hasConfigurer) {
builder.read(Objects.requireNonNull(infinispanRemoteConfigurer.getRemoteConfiguration()));
} else if (hasHotRodPropertiesFile) {
String remoteClientPropertiesLocation = infinispanProperties.getClientProperties();
Resource hotRodClientPropertiesFile = ctx.getResource(remoteClientPropertiesLocation);
try (InputStream stream = hotRodClientPropertiesFile.getURL().openStream()) {
Properties hotrodClientProperties = new Properties();
hotrodClientProperties.load(stream);
builder.withProperties(hotrodClientProperties);
}
} else if (hasProperties) {
builder.withProperties(infinispanProperties.getProperties());
} else if (infinispanConfiguration != null) {
builder.read(infinispanConfiguration);
} else {
throw new IllegalStateException("Not enough data to create RemoteCacheManager. Check InfinispanRemoteCacheManagerChecker" +
"and update conditions.");
}
cacheCustomizers.forEach(c -> c.customize(builder));
return new RemoteCacheManager(builder.build());
}
public static class ConditionalOnConfiguration extends AnyNestedCondition {
public ConditionalOnConfiguration() {
super(ConfigurationCondition.ConfigurationPhase.REGISTER_BEAN);
}
@Conditional(ConditionalOnConfigurationResources.class)
static class OnConfigurationResources {
}
@ConditionalOnBean(InfinispanRemoteConfigurer.class)
static class OnRemoteConfigurer {
}
@ConditionalOnBean(org.infinispan.client.hotrod.configuration.Configuration.class)
static class OnConfiguration {
}
}
public static class ConditionalOnCacheType implements Condition {
@Override
public boolean matches(ConditionContext ctx, AnnotatedTypeMetadata atm) {
String cacheType = ctx.getEnvironment().getProperty("spring.cache.type");
return cacheType == null || CacheType.INFINISPAN.name().equalsIgnoreCase(cacheType);
}
}
public static class ConditionalOnConfigurationResources implements Condition {
@Override
public boolean matches(ConditionContext ctx, AnnotatedTypeMetadata atm) {
return hasHotRodClientPropertiesFile(ctx) || hasServersProperty(ctx);
}
private boolean hasServersProperty(ConditionContext conditionContext) {
return conditionContext.getEnvironment().getProperty("infinispan.remote.server-list") != null;
}
private boolean hasHotRodClientPropertiesFile(ConditionContext conditionContext) {
String hotRodPropertiesPath = conditionContext.getEnvironment().getProperty("infinispan.remote.client-properties");
if (hotRodPropertiesPath == null) {
hotRodPropertiesPath = InfinispanRemoteConfigurationProperties.DEFAULT_CLIENT_PROPERTIES;
}
return conditionContext.getResourceLoader().getResource(hotRodPropertiesPath).exists();
}
}
}
| 7,076
| 45.254902
| 160
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/actuator/RemoteInfinispanCacheMeterBinder.java
|
package org.infinispan.spring.starter.remote.actuator;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tag;
import io.micrometer.core.instrument.binder.cache.CacheMeterBinder;
import org.infinispan.client.hotrod.RemoteCache;
/**
* Implements {@link CacheMeterBinder} to expose Infinispan remote metrics
*
* @author Katia Aresti, karesti@redhat.com
* @since 2.1
*/
public class RemoteInfinispanCacheMeterBinder extends CacheMeterBinder {
private final RemoteCache cache;
public RemoteInfinispanCacheMeterBinder(RemoteCache cache, Iterable<Tag> tags) {
super(cache, cache.getName(), tags);
this.cache = cache;
}
@Override
protected Long size() {
return null;
}
@Override
protected long hitCount() {
if (cache == null) return 0L;
return cache.clientStatistics().getRemoteHits();
}
@Override
protected Long missCount() {
if (cache == null) return 0L;
return cache.clientStatistics().getRemoteMisses();
}
@Override
protected Long evictionCount() {
if (cache == null) return 0L;
return cache.clientStatistics().getRemoteRemoves();
}
@Override
protected long putCount() {
if (cache == null) return 0L;
return cache.clientStatistics().getRemoteStores();
}
@Override
protected void bindImplementationSpecificMetrics(MeterRegistry registry) {
if (cache == null) return;
Gauge.builder("cache.reset", cache, cache -> cache.clientStatistics().getTimeSinceReset())
.tags(getTagsWithCacheName()).tag("ownership", "backup")
.description("Time elapsed in seconds since the last statistics reset")
.register(registry);
averages(registry);
nearCacheMetrics(registry);
}
private void averages(MeterRegistry registry) {
Gauge.builder("cache.puts.latency", cache, cache -> cache.clientStatistics().getAverageRemoteStoreTime())
.tags(getTagsWithCacheName())
.description("Cache puts")
.register(registry);
Gauge.builder("cache.gets.latency", cache, cache -> cache.clientStatistics().getAverageRemoteReadTime())
.tags(getTagsWithCacheName())
.description("Cache gets")
.register(registry);
Gauge.builder("cache.removes.latency", cache, cache -> cache.clientStatistics().getAverageRemoteRemovesTime())
.tags(getTagsWithCacheName())
.description("Cache removes")
.register(registry);
}
private void nearCacheMetrics(MeterRegistry registry) {
if (isNearCacheEnabled()) {
Gauge.builder("cache.near.requests", cache, cache -> cache.clientStatistics().getNearCacheHits())
.tags(getTagsWithCacheName()).tag("result", "hit")
.description("The number of hits (reads) of near cache entries owned by this client")
.register(registry);
Gauge.builder("cache.near.requests", cache, cache -> cache.clientStatistics().getNearCacheMisses())
.tags(getTagsWithCacheName()).tag("result", "miss")
.description("The number of hits (reads) of near cache entries owned by this client")
.register(registry);
Gauge.builder("cache.near.invalidations", cache, cache -> cache.clientStatistics().getNearCacheInvalidations())
.tags(getTagsWithCacheName())
.description("The number of invalidations of near cache entries owned by this client")
.register(registry);
Gauge.builder("cache.near.size", cache, cache -> cache.clientStatistics().getNearCacheSize())
.tags(getTagsWithCacheName())
.description("The size of the near cache owned by this client")
.register(registry);
}
}
private boolean isNearCacheEnabled() {
return cache.getRemoteCacheContainer().getConfiguration().nearCache().mode().enabled();
}
}
| 4,036
| 33.504274
| 120
|
java
|
null |
infinispan-main/spring/spring-boot-3/remote/src/main/java/org/infinispan/spring/starter/remote/actuator/RemoteInfinispanCacheMeterBinderProvider.java
|
package org.infinispan.spring.starter.remote.actuator;
import org.infinispan.client.hotrod.RemoteCache;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.actuate.metrics.cache.CacheMeterBinderProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cache.Cache;
import org.springframework.stereotype.Component;
import io.micrometer.core.instrument.Tag;
import io.micrometer.core.instrument.binder.MeterBinder;
/**
* When actuate dependency is found in the classpath, this component links Infinispan cache metrics with Actuator
*
* @author Katia Aresti, karesti@redhat.com
* @since 2.1
*/
@Component
@Qualifier(RemoteInfinispanCacheMeterBinderProvider.NAME)
@ConditionalOnClass(name = "org.springframework.boot.actuate.metrics.cache.CacheMeterBinderProvider")
@ConditionalOnProperty(value = "infinispan.remote.enabled", havingValue = "true", matchIfMissing = true)
public class RemoteInfinispanCacheMeterBinderProvider implements CacheMeterBinderProvider<Cache> {
public static final String NAME = "remoteInfinispanCacheMeterBinderProvider";
@Override
public MeterBinder getMeterBinder(Cache cache, Iterable<Tag> tags) {
if (cache.getNativeCache() instanceof RemoteCache) {
return new RemoteInfinispanCacheMeterBinder((RemoteCache) cache.getNativeCache(), tags);
} else {
return new RemoteInfinispanCacheMeterBinder(null, tags);
}
}
}
| 1,573
| 40.421053
| 113
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/AbstractSpringSessionTCK.java
|
package test.infinispan.integration;
import org.infinispan.spring.common.session.AbstractInfinispanSessionRepository;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.test.web.server.LocalServerPort;
import org.springframework.http.HttpHeaders;
import org.springframework.session.SessionRepository;
import java.util.List;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
public class AbstractSpringSessionTCK {
@Autowired
private SessionRepository<AbstractInfinispanSessionRepository.InfinispanSession> sessionRepository;
@Autowired
protected InfinispanSessionListener httpSessionListener;
@Autowired
TestRestTemplate testRestTemplate;
@LocalServerPort
private int port;
@Test
public void testCreatingSessionWhenUsingREST() {
assertNull(httpSessionListener.getCreatedSession());
assertNull(httpSessionListener.getDestroyedSession());
HttpHeaders httpHeaders = testRestTemplate
.withBasicAuth("user", "password")
.headForHeaders(getTestURL());
assertNotNull(httpSessionListener.getCreatedSession());
String sessionId = getSessionId(httpHeaders);
assertNotNull(sessionId);
assertNotNull(sessionRepository.findById(sessionId));
sessionRepository.deleteById(getSessionId(httpHeaders));
assertNotNull(httpSessionListener.getDestroyedSession());
}
private String getTestURL() {
return "http://localhost:" + port + "/test";
}
private String getSessionId(HttpHeaders httpHeaders) {
List<String> sessionIdHeaders = httpHeaders.getValuesAsList("x-auth-token");
return sessionIdHeaders.isEmpty() ? null : sessionIdHeaders.get(0);
}
}
| 1,897
| 32.298246
| 102
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/SecurityConfig.java
|
package test.infinispan.integration;
import org.springframework.context.annotation.Bean;
import org.springframework.security.config.Customizer;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;
import org.springframework.security.web.SecurityFilterChain;
import org.springframework.session.web.http.HeaderHttpSessionIdResolver;
import org.springframework.session.web.http.HttpSessionIdResolver;
public class SecurityConfig {
@Bean
public InMemoryUserDetailsManager userDetailsService() {
UserDetails user = User.withDefaultPasswordEncoder()
.username("user")
.password("password")
.roles("USER")
.build();
return new InMemoryUserDetailsManager(user);
}
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests((requests) -> requests
.anyRequest().authenticated()
)
.sessionManagement(sm -> sm.sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED))
.formLogin(Customizer.withDefaults())
.httpBasic(Customizer.withDefaults());
return http.build();
}
@Bean
public HttpSessionIdResolver httpSessionStrategy() {
return new HeaderHttpSessionIdResolver("x-auth-token");
}
@Bean
public InfinispanSessionListener httpSessionListener(){
return new InfinispanSessionListener();
}
}
| 1,745
| 34.632653
| 97
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/TestRESTController.java
|
package test.infinispan.integration;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestRESTController {
@GetMapping("/test")
public String testRest(){
return "Ok";
}
}
| 291
| 19.857143
| 62
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/InfinispanSessionListener.java
|
package test.infinispan.integration;
import jakarta.servlet.http.HttpSession;
import jakarta.servlet.http.HttpSessionEvent;
import jakarta.servlet.http.HttpSessionListener;
public class InfinispanSessionListener implements HttpSessionListener {
private HttpSession createdSession;
private HttpSession destroyedSession;
@Override
public void sessionCreated(HttpSessionEvent httpSessionEvent) {
createdSession = httpSessionEvent.getSession();
}
@Override
public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {
destroyedSession = httpSessionEvent.getSession();
}
public HttpSession getCreatedSession() {
return createdSession;
}
public HttpSession getDestroyedSession() {
return destroyedSession;
}
}
| 776
| 24.9
| 71
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/remote/RemoteSpringSessionTest.java
|
package test.infinispan.integration.remote;
import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.server.hotrod.HotRodServer;
import org.infinispan.server.hotrod.configuration.HotRodServerConfigurationBuilder;
import org.infinispan.spring.remote.provider.SpringRemoteCacheManager;
import org.infinispan.spring.remote.session.configuration.EnableInfinispanRemoteHttpSession;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cache.CacheManager;
import org.springframework.test.annotation.DirtiesContext;
import test.infinispan.integration.AbstractSpringSessionTCK;
import static org.infinispan.commons.dataconversion.MediaType.APPLICATION_SERIALIZED_OBJECT_TYPE;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@SpringBootTest(classes = RemoteSessionApp.class,
webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT,
properties = "spring.main.banner-mode=off")
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
public class RemoteSpringSessionTest extends AbstractSpringSessionTCK {
private static EmbeddedCacheManager serverCache;
private static HotRodServer server;
@Autowired
CacheManager cacheManager;
@BeforeAll
public static void beforeClass() {
GlobalConfigurationBuilder globalConfigurationBuilder = new GlobalConfigurationBuilder().nonClusteredDefault();
globalConfigurationBuilder.globalState().disable();
globalConfigurationBuilder.jmx().disable();
ConfigurationBuilder cacheConfiguration = new ConfigurationBuilder();
cacheConfiguration.encoding().key().mediaType(APPLICATION_SERIALIZED_OBJECT_TYPE);
cacheConfiguration.encoding().value().mediaType(APPLICATION_SERIALIZED_OBJECT_TYPE);
cacheConfiguration.statistics().disable();
serverCache = new DefaultCacheManager(globalConfigurationBuilder.build());
serverCache.defineConfiguration(EnableInfinispanRemoteHttpSession.DEFAULT_CACHE_NAME, cacheConfiguration.build());
HotRodServerConfigurationBuilder hotRodServerConfigurationBuilder = new HotRodServerConfigurationBuilder();
hotRodServerConfigurationBuilder.name(RemoteSpringSessionTest.class.getSimpleName());
hotRodServerConfigurationBuilder.port(RemoteSessionApp.SERVER_PORT).defaultCacheName(EnableInfinispanRemoteHttpSession.DEFAULT_CACHE_NAME);
server = new HotRodServer();
server.start(hotRodServerConfigurationBuilder.build(), serverCache);
}
@AfterAll
public static void afterClass() {
server.stop();
serverCache.stop();
}
@Test
public void testCacheManagerBean() {
assertNotNull(cacheManager);
assertTrue(cacheManager instanceof SpringRemoteCacheManager);
RemoteCacheManager nativeCacheManager = ((SpringRemoteCacheManager) cacheManager).getNativeCacheManager();
assertNotNull(nativeCacheManager);
}
}
| 3,379
| 44.675676
| 145
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/remote/RemoteSessionApp.java
|
package test.infinispan.integration.remote;
import org.infinispan.spring.remote.AbstractRemoteCacheManagerFactory;
import org.infinispan.spring.remote.provider.SpringRemoteCacheManagerFactoryBean;
import org.infinispan.spring.remote.session.configuration.EnableInfinispanRemoteHttpSession;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.Primary;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.test.util.TestSocketUtils;
import test.infinispan.integration.SecurityConfig;
import java.net.InetSocketAddress;
import java.util.Arrays;
@SpringBootApplication
@EnableInfinispanRemoteHttpSession
@EnableCaching
@EnableWebSecurity
@Import(SecurityConfig.class)
public class RemoteSessionApp {
static final int SERVER_PORT = TestSocketUtils.findAvailableTcpPort();
@Bean
@Primary
public SpringRemoteCacheManagerFactoryBean springCacheManager() {
SpringRemoteCacheManagerFactoryBean factoryBean = new SpringRemoteCacheManagerFactoryBean();
factoryBean.setServerList(Arrays.asList(new InetSocketAddress("localhost", SERVER_PORT)));
factoryBean.setClassAllowList(AbstractRemoteCacheManagerFactory.SPRING_JAVA_SERIAL_ALLOWLIST + ",java.util.*");
return factoryBean;
}
}
| 1,505
| 40.833333
| 117
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/embedded/EmbeddedSpringSessionTest.java
|
package test.infinispan.integration.embedded;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManager;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.cache.CacheManager;
import org.springframework.test.annotation.DirtiesContext;
import test.infinispan.integration.AbstractSpringSessionTCK;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
@SpringBootTest(classes = EmbeddedSessionApp.class,
webEnvironment= SpringBootTest.WebEnvironment.RANDOM_PORT,
properties = "spring.main.banner-mode=off")
@DirtiesContext(classMode = DirtiesContext.ClassMode.AFTER_CLASS)
public class EmbeddedSpringSessionTest extends AbstractSpringSessionTCK {
@Autowired
CacheManager cacheManager;
@Test
public void testCacheManagerBean() {
assertNotNull(cacheManager);
assertTrue(cacheManager instanceof SpringEmbeddedCacheManager);
EmbeddedCacheManager nativeCacheManager = ((SpringEmbeddedCacheManager) cacheManager).getNativeCacheManager();
assertNotNull(nativeCacheManager);
}
}
| 1,295
| 39.5
| 116
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/integration/embedded/EmbeddedSessionApp.java
|
package test.infinispan.integration.embedded;
import org.infinispan.commons.dataconversion.MediaType;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.spring.embedded.session.configuration.EnableInfinispanEmbeddedHttpSession;
import org.infinispan.spring.starter.embedded.InfinispanCacheConfigurer;
import org.infinispan.spring.starter.embedded.InfinispanGlobalConfigurer;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import test.infinispan.integration.SecurityConfig;
@SpringBootApplication
@EnableCaching
@EnableInfinispanEmbeddedHttpSession
@EnableWebSecurity
@Import(SecurityConfig.class)
public class EmbeddedSessionApp {
@Bean
public InfinispanCacheConfigurer cacheConfigurer() {
return manager -> {
final org.infinispan.configuration.cache.Configuration ispnConfig = new ConfigurationBuilder()
.clustering().cacheMode(CacheMode.DIST_SYNC)
.encoding().mediaType(MediaType.APPLICATION_PROTOSTREAM_TYPE)
.statistics().disable()
.build();
manager.defineConfiguration("sessions", ispnConfig);
};
}
@Bean
public InfinispanGlobalConfigurer globalCustomizer() {
return () -> GlobalConfigurationBuilder
.defaultClusteredBuilder()
.metrics().gauges(false).histograms(false)
.globalState().disable()
.build();
}
}
| 1,818
| 38.543478
| 103
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/autoconfigure/CacheDisabledTest.java
|
package test.infinispan.autoconfigure;
//import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
//import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
//import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
@SpringBootTest(
classes = {
CacheAutoConfiguration.class,
// InfinispanRemoteAutoConfiguration.class,
// InfinispanRemoteCacheManagerAutoConfiguration.class,
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"spring.cache.type=NONE",
"infinispan.remote.server-list=127.0.0.1:6667"
})
public class CacheDisabledTest {
@Autowired
private ApplicationContext context;
@Test
public void testDefaultCacheManager() {
Assertions.assertThrows(NoSuchBeanDefinitionException.class, () -> {
context.getBean(DefaultCacheManager.class);
});
}
@Test
public void testRemoteCacheManager() {
// Assertions.assertThrows(NoSuchBeanDefinitionException.class, () -> {
// context.getBean(RemoteCacheManager.class);
// });
}
}
| 1,888
| 38.354167
| 94
|
java
|
null |
infinispan-main/spring/spring-boot-3/tests/src/test/java/test/infinispan/autoconfigure/CacheManagerTest.java
|
package test.infinispan.autoconfigure;
import static org.junit.jupiter.api.Assertions.assertNotNull;
//
//import org.infinispan.client.hotrod.RemoteCacheManager;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
//import org.infinispan.spring.starter.remote.InfinispanRemoteAutoConfiguration;
//import org.infinispan.spring.starter.remote.InfinispanRemoteCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ApplicationContext;
@SpringBootTest(
classes = {
// InfinispanRemoteAutoConfiguration.class,
// InfinispanRemoteCacheManagerAutoConfiguration.class,
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"infinispan.remote.server-list=127.0.0.1:6667"
})
public class CacheManagerTest {
@Autowired
private ApplicationContext context;
@Test
public void testRemoteCacheManager() {
// assertNotNull(context.getBean(RemoteCacheManager.class));
}
@Test
public void testDefaultCacheManager() {
assertNotNull(context.getBean(DefaultCacheManager.class));
}
}
| 1,533
| 36.414634
| 94
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/InfinispanEmbeddedAutoConfigurationPropertiesTest.java
|
package test.org.infinispan.spring.starter.embedded;
import static org.assertj.core.api.Assertions.assertThat;
import java.util.Collections;
import org.infinispan.commons.marshall.JavaSerializationMarshaller;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.TestPropertySource;
@SpringBootTest(
classes = {
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off"
}
)
@TestPropertySource(properties = "infinispan.embedded.config-xml=infinispan-test-conf.xml")
public class InfinispanEmbeddedAutoConfigurationPropertiesTest {
@Autowired
EmbeddedCacheManager defaultCacheManager;
@Test
public void testCacheManagerXmlConfig() {
assertThat(defaultCacheManager.getCacheNames()).isEqualTo(Collections.singleton("default-local"));
final GlobalConfiguration globalConfiguration = defaultCacheManager.getCacheManagerConfiguration();
assertThat(globalConfiguration.globalJmxStatistics().enabled()).isTrue();
assertThat(globalConfiguration.globalJmxStatistics().domain()).isEqualTo("properties.test.spring.infinispan");
assertThat(globalConfiguration.serialization().marshaller()).isInstanceOf(JavaSerializationMarshaller.class);
final Configuration defaultCacheConfiguration = defaultCacheManager.getDefaultCacheConfiguration();
assertThat(defaultCacheConfiguration.memory().size()).isEqualTo(2000L);
}
}
| 2,010
| 42.717391
| 116
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/InfinispanEmbeddedAutoConfigurationIntegrationTest.java
|
package test.org.infinispan.spring.starter.embedded;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManager;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(
classes = {
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off"
}
)
public class InfinispanEmbeddedAutoConfigurationIntegrationTest {
@Autowired
EmbeddedCacheManager defaultCacheManager;
@Autowired
SpringEmbeddedCacheManager springEmbeddedCacheManager;
@Test
public void testAutowired() {
assertThat(defaultCacheManager).isNotNull();
}
@Test
public void testDefaultConfigurations() {
assertThat(defaultCacheManager.getClusterName()).isEqualTo("default-autoconfigure");
assertThat(defaultCacheManager.getCacheNames()).containsExactly("default");
final Configuration defaultCacheConfiguration = defaultCacheManager.getDefaultCacheConfiguration();
assertThat(defaultCacheConfiguration).isNull();
final GlobalConfiguration globalConfiguration = defaultCacheManager.getCacheManagerConfiguration();
assertThat(globalConfiguration.jmx().enabled()).isTrue();
assertThat(globalConfiguration.jmx().domain()).isEqualTo("org.infinispan");
}
@Test
public void testIfSpringCachingWasCreatedUsingProperEmbeddedCacheManager() throws Exception {
assertThat(defaultCacheManager).isEqualTo(springEmbeddedCacheManager.getNativeCacheManager());
}
}
| 2,097
| 37.145455
| 105
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/InfinispanEmbeddedEnableTest.java
|
package test.org.infinispan.spring.starter.embedded;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration.DEFAULT_CACHE_MANAGER_QUALIFIER;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
import org.infinispan.spring.starter.embedded.actuator.InfinispanCacheMeterBinderProvider;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import test.org.infinispan.spring.starter.embedded.testconfiguration.InfinispanCacheTestConfiguration;
@SpringBootTest(
classes = {
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class,
InfinispanCacheTestConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"infinispan.embedded.enabled=true",
"infinispan.embedded.caching.enabled=true"
}
)
public class InfinispanEmbeddedEnableTest {
@Autowired
private ListableBeanFactory beanFactory;
@Test
public void testDefaultClient() {
assertThat(beanFactory.containsBeanDefinition(DEFAULT_CACHE_MANAGER_QUALIFIER)).isTrue();
assertThat(beanFactory.containsBeanDefinition(InfinispanCacheMeterBinderProvider.NAME)).isTrue();
}
}
| 1,580
| 40.605263
| 121
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/InfinispanEmbeddedAutoConfigurationIntegrationConfigurerTest.java
|
package test.org.infinispan.spring.starter.embedded;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.StorageType;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.eviction.EvictionStrategy;
import org.infinispan.eviction.EvictionType;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanGlobalConfigurationCustomizer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import test.org.infinispan.spring.starter.embedded.testconfiguration.InfinispanCacheTestConfiguration;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(
classes = {
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class,
InfinispanCacheTestConfiguration.class,
InfinispanEmbeddedAutoConfigurationIntegrationConfigurerTest.TestConfiguration.class
},
properties = {
"spring.main.banner-mode=off"
}
)
public class InfinispanEmbeddedAutoConfigurationIntegrationConfigurerTest {
private static final String JMX_TEST_DOMAIN = InfinispanEmbeddedAutoConfigurationIntegrationConfigurerTest.class.getName();
@org.springframework.context.annotation.Configuration
static class TestConfiguration {
@Bean
public InfinispanGlobalConfigurationCustomizer globalCustomizer() {
return builder -> builder.jmx()
.domain(JMX_TEST_DOMAIN);
}
}
@Autowired
EmbeddedCacheManager defaultCacheManager;
@Test
public void testWithCacheConfigurer() {
assertThat(defaultCacheManager.getCacheNames()).containsExactlyInAnyOrder(InfinispanCacheTestConfiguration.TEST_CACHE_NAME, "default");
final Configuration testCacheConfiguration = defaultCacheManager.getCacheConfiguration(InfinispanCacheTestConfiguration.TEST_CACHE_NAME);
assertThat(testCacheConfiguration.statistics().enabled()).isTrue();
assertThat(testCacheConfiguration.memory().storageType()).isEqualTo(StorageType.OBJECT);
assertThat(testCacheConfiguration.memory().evictionType()).isEqualTo(EvictionType.COUNT);
assertThat(testCacheConfiguration.memory().evictionStrategy()).isEqualTo(EvictionStrategy.MANUAL);
}
@Test
public void testWithGlobalConfigurer() {
final GlobalConfiguration globalConfiguration = defaultCacheManager.getCacheManagerConfiguration();
assertThat(globalConfiguration.jmx().enabled()).isTrue();
assertThat(globalConfiguration.jmx().domain()).isEqualTo(JMX_TEST_DOMAIN);
assertThat(globalConfiguration.transport().clusterName()).isEqualTo(InfinispanCacheTestConfiguration.TEST_CLUSTER);
}
}
| 3,092
| 45.164179
| 143
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/InfinispanEmbeddedAutoConfigurationCustomizerIntegrationTest.java
|
package test.org.infinispan.spring.starter.embedded;
import static org.assertj.core.api.Assertions.assertThat;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.eviction.EvictionType;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.notifications.Listener;
import org.infinispan.notifications.cachemanagerlistener.annotation.CacheStarted;
import org.infinispan.notifications.cachemanagerlistener.event.CacheStartedEvent;
import org.infinispan.spring.starter.embedded.InfinispanCacheConfigurer;
import org.infinispan.spring.starter.embedded.InfinispanConfigurationCustomizer;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanGlobalConfigurationCustomizer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@SpringBootTest(
classes = {
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class,
InfinispanEmbeddedAutoConfigurationCustomizerIntegrationTest.TestConfiguration.class,
},
properties = {
"spring.main.banner-mode=off"
}
)
public class InfinispanEmbeddedAutoConfigurationCustomizerIntegrationTest {
private static final String CLUSTER_NAME = Util.threadLocalRandomUUID().toString();
@Autowired
EmbeddedCacheManager manager;
static CacheStartedEvent startedEvent;
@Test
public void testConfiguration() {
assertThat(manager.getCacheManagerConfiguration().transport().clusterName()).isEqualTo(CLUSTER_NAME);
assertThat(manager.getDefaultCacheConfiguration()).isNull();
assertThat(manager.getCacheNames()).contains("small-cache");
assertThat(manager.getCacheConfiguration("small-cache").memory().size()).isEqualTo(1000L);
assertThat(manager.getCacheConfiguration("small-cache").memory().evictionType()).isEqualTo(EvictionType.COUNT);
assertThat(startedEvent).isNotNull();
}
@Configuration
static class TestConfiguration {
@Listener
public class ExampleListener {
@CacheStarted
public void cacheStarted(CacheStartedEvent event) {
startedEvent = event;
}
}
@Bean(name = "small-cache")
public org.infinispan.configuration.cache.Configuration smallCache() {
return new ConfigurationBuilder()
.simpleCache(true)
.memory().size(1000L)
.memory().evictionType(EvictionType.COUNT)
.build();
}
@Bean
public InfinispanCacheConfigurer cacheConfigurer() {
return manager -> manager.addListener(new ExampleListener());
}
@Bean
public InfinispanGlobalConfigurationCustomizer globalCustomizer() {
return builder -> builder.transport().clusterName(CLUSTER_NAME).jmx().disable();
}
@Bean
public InfinispanConfigurationCustomizer configurationCustomizer() {
return builder -> {
builder.memory().evictionType(EvictionType.COUNT);
};
}
}
}
| 3,468
| 37.544444
| 117
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/InfinispanEmbeddedAutoConfigurationIntegrationConfigurationTest.java
|
package test.org.infinispan.spring.starter.embedded;
import org.infinispan.eviction.EvictionType;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanGlobalConfigurer;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import test.org.infinispan.spring.starter.embedded.testconfiguration.GlobalConfigurerJmxDisabledConfiguration;
import test.org.infinispan.spring.starter.embedded.testconfiguration.InfinispanCacheConfigurationBaseTestConfiguration;
import test.org.infinispan.spring.starter.embedded.testconfiguration.InfinispanCacheConfigurationTestConfiguration;
import static org.assertj.core.api.Assertions.assertThat;
@SpringBootTest(
classes = {
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class,
InfinispanCacheConfigurationBaseTestConfiguration.class,
InfinispanCacheConfigurationTestConfiguration.class,
InfinispanGlobalConfigurer.class,
GlobalConfigurerJmxDisabledConfiguration.class
},
properties = {
"spring.main.banner-mode=off"
}
)
public class InfinispanEmbeddedAutoConfigurationIntegrationConfigurationTest {
@Autowired
EmbeddedCacheManager manager;
@Test
public void testConfiguration() {
assertThat(manager.getCacheNames()).contains("base-cache", "small-cache", "large-cache");
assertThat(manager.getCacheConfiguration("base-cache").memory().size()).isEqualTo(500L);
assertThat(manager.getCacheConfiguration("base-cache").memory().evictionType()).isEqualTo(EvictionType.COUNT);
assertThat(manager.getCacheConfiguration("small-cache").memory().size()).isEqualTo(1000L);
assertThat(manager.getCacheConfiguration("small-cache").memory().evictionType()).isEqualTo(EvictionType.COUNT);
assertThat(manager.getCacheConfiguration("large-cache").memory().size()).isEqualTo(2000L);
assertThat(manager.getCacheConfiguration("large-cache").memory().evictionType()).isEqualTo(EvictionType.COUNT);
}
}
| 2,366
| 50.456522
| 119
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/InfinispanEmbeddedDisableTest.java
|
package test.org.infinispan.spring.starter.embedded;
import static org.assertj.core.api.Assertions.assertThat;
import static org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration.DEFAULT_CACHE_MANAGER_QUALIFIER;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedAutoConfiguration;
import org.infinispan.spring.starter.embedded.InfinispanEmbeddedCacheManagerAutoConfiguration;
import org.infinispan.spring.starter.embedded.actuator.InfinispanCacheMeterBinderProvider;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest(
classes = {
InfinispanEmbeddedAutoConfiguration.class,
InfinispanEmbeddedCacheManagerAutoConfiguration.class
},
properties = {
"spring.main.banner-mode=off",
"infinispan.embedded.enabled=false",
"infinispan.embedded.caching.enabled=true"
}
)
public class InfinispanEmbeddedDisableTest {
@Autowired
private ListableBeanFactory beanFactory;
@Test
public void testDefaultClient() {
assertThat(beanFactory.containsBeanDefinition(DEFAULT_CACHE_MANAGER_QUALIFIER)).isFalse();
assertThat(beanFactory.containsBeanDefinition(InfinispanCacheMeterBinderProvider.NAME)).isFalse();
}
}
| 1,429
| 38.722222
| 121
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/testconfiguration/InfinispanCacheConfigurationBaseTestConfiguration.java
|
package test.org.infinispan.spring.starter.embedded.testconfiguration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.eviction.EvictionType;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class InfinispanCacheConfigurationBaseTestConfiguration {
@Bean(name = "base-cache")
public org.infinispan.configuration.cache.Configuration smallCache() {
return new ConfigurationBuilder()
.simpleCache(true)
.memory().size(500L)
.memory().evictionType(EvictionType.COUNT)
.build();
}
}
| 673
| 32.7
| 74
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/testconfiguration/InfinispanCacheConfigurationTestConfiguration.java
|
package test.org.infinispan.spring.starter.embedded.testconfiguration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.eviction.EvictionType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class InfinispanCacheConfigurationTestConfiguration {
@Autowired
@Qualifier("base-cache")
org.infinispan.configuration.cache.Configuration baseCache;
@Bean(name = "small-cache")
public org.infinispan.configuration.cache.Configuration smallCache() {
return new ConfigurationBuilder()
.read(baseCache)
.memory().size(1000L)
.memory().evictionType(EvictionType.COUNT)
.build();
}
@Bean(name = "large-cache")
public org.infinispan.configuration.cache.Configuration largeCache() {
return new ConfigurationBuilder()
.read(baseCache)
.memory().size(2000L)
.memory().evictionType(EvictionType.COUNT)
.build();
}
}
| 1,199
| 34.294118
| 74
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/testconfiguration/GlobalConfigurerJmxDisabledConfiguration.java
|
package test.org.infinispan.spring.starter.embedded.testconfiguration;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.spring.starter.embedded.InfinispanGlobalConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import static test.org.infinispan.spring.starter.embedded.testconfiguration.InfinispanCacheTestConfiguration.TEST_CLUSTER;
@Configuration
public class GlobalConfigurerJmxDisabledConfiguration {
@Bean
public InfinispanGlobalConfigurer globalConfigurer() {
return () -> {
final GlobalConfiguration globalConfiguration = new GlobalConfigurationBuilder()
.transport().clusterName(TEST_CLUSTER)
.jmx().disable()
.build();
return globalConfiguration;
};
}
}
| 934
| 34.961538
| 122
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/testconfiguration/InfinispanCacheTestConfiguration.java
|
package test.org.infinispan.spring.starter.embedded.testconfiguration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.StorageType;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.eviction.EvictionStrategy;
import org.infinispan.eviction.EvictionType;
import org.infinispan.spring.starter.embedded.InfinispanCacheConfigurer;
import org.infinispan.spring.starter.embedded.InfinispanGlobalConfigurer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class InfinispanCacheTestConfiguration {
public static final String TEST_CLUSTER = "TEST_CLUSTER";
public static final String TEST_CACHE_NAME = "test-simple-cache";
public static final String TEST_GLOBAL_JMX_DOMAIN = "test.infinispan";
@Bean
public InfinispanCacheConfigurer cacheConfigurer() {
return cacheManager -> {
final org.infinispan.configuration.cache.ConfigurationBuilder testCacheBuilder = new ConfigurationBuilder();
testCacheBuilder.simpleCache(true)
.memory()
.storageType(StorageType.OBJECT)
.evictionType(EvictionType.COUNT)
.evictionStrategy(EvictionStrategy.MANUAL);
testCacheBuilder.statistics().enable();
cacheManager.defineConfiguration(TEST_CACHE_NAME, testCacheBuilder.build());
};
}
@Bean
public InfinispanGlobalConfigurer globalConfigurer() {
return () -> {
final GlobalConfiguration globalConfiguration = new GlobalConfigurationBuilder()
.transport().clusterName(TEST_CLUSTER)
.jmx().domain(TEST_GLOBAL_JMX_DOMAIN).enable()
.build();
return globalConfiguration;
};
}
}
| 1,915
| 37.32
| 117
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/test/java/test/org/infinispan/spring/starter/embedded/actuator/InfinispanCacheMetricBinderTest.java
|
package test.org.infinispan.spring.starter.embedded.actuator;
import io.micrometer.core.instrument.binder.cache.CacheMeterBinder;
import io.micrometer.core.instrument.binder.cache.CacheMeterBinderCompatibilityKit;
import org.infinispan.Cache;
import org.infinispan.commons.api.CacheContainerAdmin;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.spring.starter.embedded.actuator.InfinispanCacheMeterBinder;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.Test;
import static java.util.Collections.emptyList;
public class InfinispanCacheMetricBinderTest extends CacheMeterBinderCompatibilityKit<Cache<String, String>> {
private static EmbeddedCacheManager cacheManager;
private InfinispanCacheMeterBinder binder;
@AfterAll
public static void cleanup() {
cacheManager.stop();
}
@Override
public Cache<String, String> createCache() {
GlobalConfigurationBuilder global = new GlobalConfigurationBuilder();
global.metrics().accurateSize(true);
cacheManager = new DefaultCacheManager(global.build());
return cacheManager.administration()
.withFlags(CacheContainerAdmin.AdminFlag.VOLATILE).getOrCreateCache("mycache", new ConfigurationBuilder().statistics().enable().build());
}
@Override
public CacheMeterBinder binder() {
binder = new InfinispanCacheMeterBinder(cache, emptyList());
return binder;
}
@Override
public void put(String key, String value) {
cache.put(key, value);
}
@Override
public String get(String key) {
return cache.get(key);
}
@Test
void dereferencedCacheIsGarbageCollected() {
// We can't remove cache ref from the manager only by setting the cache property to null
}
}
| 1,957
| 33.350877
| 149
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanGlobalConfigurationCustomizer.java
|
package org.infinispan.spring.starter.embedded;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
@FunctionalInterface
public interface InfinispanGlobalConfigurationCustomizer {
void customize(GlobalConfigurationBuilder builder);
}
| 259
| 27.888889
| 70
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanEmbeddedAutoConfiguration.java
|
package org.infinispan.spring.starter.embedded;
import java.io.IOException;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.infinispan.commons.marshall.JavaSerializationMarshaller;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.ParserRegistry;
import org.infinispan.manager.DefaultCacheManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.AutoConfigureBefore;
import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan
@AutoConfigureBefore(CacheAutoConfiguration.class)
//Since a jar with configuration might be missing (which would result in TypeNotPresentExceptionProxy), we need to
//use String based methods.
//See https://github.com/spring-projects/spring-boot/issues/1733
@ConditionalOnClass(name = "org.infinispan.manager.EmbeddedCacheManager")
@ConditionalOnProperty(value = "infinispan.embedded.enabled", havingValue = "true", matchIfMissing = true)
@EnableConfigurationProperties(InfinispanEmbeddedConfigurationProperties.class)
public class InfinispanEmbeddedAutoConfiguration {
public static final String DEFAULT_CACHE_MANAGER_QUALIFIER = "defaultCacheManager";
@Autowired
private InfinispanEmbeddedConfigurationProperties infinispanProperties;
@Autowired(required = false)
private List<InfinispanCacheConfigurer> configurers = Collections.emptyList();
@Autowired(required = false)
private List<InfinispanConfigurationCustomizer> configurationCustomizers = Collections.emptyList();
@Autowired(required = false)
private Map<String, org.infinispan.configuration.cache.Configuration> cacheConfigurations = Collections.emptyMap();
@Autowired(required = false)
private InfinispanGlobalConfigurer infinispanGlobalConfigurer;
@Autowired(required = false)
private List<InfinispanGlobalConfigurationCustomizer> globalConfigurationCustomizers = Collections.emptyList();
@Bean(destroyMethod = "stop")
@Conditional(InfinispanEmbeddedCacheManagerChecker.class)
@ConditionalOnMissingBean
@Qualifier(DEFAULT_CACHE_MANAGER_QUALIFIER)
public DefaultCacheManager defaultCacheManager() throws IOException {
final String configXml = infinispanProperties.getConfigXml();
final DefaultCacheManager manager;
ConfigurationBuilderHolder holder;
if (!configXml.isEmpty()) {
holder = new ParserRegistry().parseFile(configXml);
GlobalConfigurationBuilder globalConfigurationBuilder = holder.getGlobalConfigurationBuilder();
if (globalConfigurationBuilder.serialization().getMarshaller() == null) {
// spring session needs does not work with protostream right now, easy users to configure the marshaller
// and the classes we need for spring embedded
globalConfigurationBuilder.serialization().marshaller(new JavaSerializationMarshaller());
}
allowInternalClasses(globalConfigurationBuilder);
manager = new DefaultCacheManager(holder, false);
} else {
GlobalConfigurationBuilder globalConfigurationBuilder = new GlobalConfigurationBuilder();
globalConfigurationBuilder.serialization().marshaller(new JavaSerializationMarshaller());
allowInternalClasses(globalConfigurationBuilder);
if (infinispanGlobalConfigurer != null) {
globalConfigurationBuilder.read(infinispanGlobalConfigurer.getGlobalConfiguration());
} else {
globalConfigurationBuilder.transport().clusterName(infinispanProperties.getClusterName());
globalConfigurationBuilder.jmx().enable();
}
globalConfigurationCustomizers.forEach(customizer -> customizer.customize(globalConfigurationBuilder));
manager = new DefaultCacheManager(globalConfigurationBuilder.build(), false);
ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
configurationCustomizers.forEach(customizer -> customizer.customize(configurationBuilder));
manager.defineConfiguration("default", configurationBuilder.build());
}
cacheConfigurations.forEach(manager::defineConfiguration);
configurers.forEach(configurer -> configurer.configureCache(manager));
manager.start();
return manager;
}
private void allowInternalClasses(GlobalConfigurationBuilder globalConfigurationBuilder) {
globalConfigurationBuilder.serialization().allowList().addClass("org.springframework.session.MapSession");
globalConfigurationBuilder.serialization().allowList().addRegexp("java.util.*");
}
}
| 5,451
| 49.018349
| 118
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanEmbeddedConfigurationProperties.java
|
package org.infinispan.spring.starter.embedded;
import org.springframework.boot.context.properties.ConfigurationProperties;
@ConfigurationProperties("infinispan.embedded")
public class InfinispanEmbeddedConfigurationProperties {
public static final String DEFAULT_CLUSTER_NAME = "default-autoconfigure";
/**
* Enable embedded cache.
*/
private boolean enabled = true;
/**
* The configuration file to use as a template for all caches created.
*/
private String configXml = "";
private String machineId = "";
/**
* The name of the cluster.
*/
private String clusterName = DEFAULT_CLUSTER_NAME;
public String getConfigXml() {
return configXml;
}
public void setConfigXml(String configXml) {
this.configXml = configXml;
}
public String getMachineId() {
return machineId;
}
public void setMachineId(String machineId) {
this.machineId = machineId;
}
public String getClusterName() {
return clusterName;
}
public void setClusterName(String clusterName) {
this.clusterName = clusterName;
}
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
}
| 1,257
| 20.689655
| 77
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanEmbeddedCacheManagerAutoConfiguration.java
|
package org.infinispan.spring.starter.embedded;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManager;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
@Configuration
@ComponentScan
//Since a jar with configuration might be missing (which would result in TypeNotPresentExceptionProxy), we need to
//use String based methods.
//See https://github.com/spring-projects/spring-boot/issues/1733
@ConditionalOnClass(name = "org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManager")
@ConditionalOnProperty(value = "infinispan.embedded.cache.enabled", havingValue = "true", matchIfMissing = true)
public class InfinispanEmbeddedCacheManagerAutoConfiguration {
@Bean
@ConditionalOnMissingBean(type = {"org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManager", "org.infinispan.spring.embedded.provider.SpringEmbeddedCacheManagerFactoryBean"})
@ConditionalOnBean(type = "org.infinispan.manager.EmbeddedCacheManager")
public SpringEmbeddedCacheManager springEmbeddedCacheManager(EmbeddedCacheManager embeddedCacheManager) {
return new SpringEmbeddedCacheManager(embeddedCacheManager);
}
}
| 1,632
| 55.310345
| 188
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanEmbeddedCacheManagerChecker.java
|
package org.infinispan.spring.starter.embedded;
import org.springframework.boot.autoconfigure.cache.CacheType;
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
public class InfinispanEmbeddedCacheManagerChecker implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String cacheType = context.getEnvironment().getProperty("spring.cache.type");
return cacheType == null || CacheType.INFINISPAN.name().equalsIgnoreCase(cacheType);
}
}
| 657
| 40.125
| 92
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanGlobalConfigurer.java
|
package org.infinispan.spring.starter.embedded;
import org.infinispan.configuration.global.GlobalConfiguration;
@FunctionalInterface
public interface InfinispanGlobalConfigurer {
GlobalConfiguration getGlobalConfiguration();
}
| 233
| 25
| 63
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanCacheConfigurer.java
|
package org.infinispan.spring.starter.embedded;
import org.infinispan.manager.EmbeddedCacheManager;
@FunctionalInterface
public interface InfinispanCacheConfigurer {
/**
* Configure an Infinispan cache.
*
* @param manager The {@link EmbeddedCacheManager}.
*/
void configureCache(final EmbeddedCacheManager manager);
}
| 348
| 23.928571
| 60
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/InfinispanConfigurationCustomizer.java
|
package org.infinispan.spring.starter.embedded;
import org.infinispan.configuration.cache.ConfigurationBuilder;
@Deprecated
// Will be removed in future releases
@FunctionalInterface
public interface InfinispanConfigurationCustomizer {
void customize(ConfigurationBuilder builder);
}
| 290
| 25.454545
| 63
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/actuator/InfinispanCacheMeterBinder.java
|
package org.infinispan.spring.starter.embedded.actuator;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tag;
import io.micrometer.core.instrument.binder.cache.CacheMeterBinder;
import org.infinispan.Cache;
import java.util.concurrent.TimeUnit;
/**
* Implements {@link CacheMeterBinder} to expose Infinispan embedded metrics
*
* @author Katia Aresti, karesti@redhat.com
* @since 2.1
*/
public class InfinispanCacheMeterBinder extends CacheMeterBinder {
private final Cache cache;
public InfinispanCacheMeterBinder(Cache cache, Iterable<Tag> tags) {
super(cache, cache.getName(), tags);
this.cache = cache;
}
@Override
protected Long size() {
if (cache == null) return 0L;
return cache.getAdvancedCache().getStats().getApproximateEntriesInMemory();
}
@Override
protected long hitCount() {
if (cache == null) return 0L;
return cache.getAdvancedCache().getStats().getHits();
}
@Override
protected Long missCount() {
if (cache == null) return 0L;
return cache.getAdvancedCache().getStats().getMisses();
}
@Override
protected Long evictionCount() {
if (cache == null) return 0L;
return cache.getAdvancedCache().getStats().getEvictions();
}
@Override
protected long putCount() {
if (cache == null) return 0L;
return cache.getAdvancedCache().getStats().getStores();
}
@Override
protected void bindImplementationSpecificMetrics(MeterRegistry registry) {
if (cache == null) return;
Gauge.builder("cache.start", cache, cache -> cache.getAdvancedCache().getStats().getTimeSinceStart())
.baseUnit(TimeUnit.SECONDS.name())
.tags(getTagsWithCacheName())
.description("Time elapsed since start")
.register(registry);
Gauge.builder("cache.reset", cache, cache -> cache.getAdvancedCache().getStats().getTimeSinceReset())
.baseUnit(TimeUnit.SECONDS.name())
.tags(getTagsWithCacheName())
.description("Time elapsed since the last statistics reset")
.register(registry);
memory(registry);
averages(registry);
averagesNanos(registry);
}
private void memory(MeterRegistry registry) {
Gauge.builder("cache.memory.size", cache, cache -> cache.getAdvancedCache().getStats().getCurrentNumberOfEntriesInMemory())
.tags(getTagsWithCacheName())
.description("Approximate number of entries in the cache, excluding passivated entries")
.register(registry);
if (cache.getCacheConfiguration().memory().evictionStrategy().isEnabled()) {
Gauge.builder("cache.memory.used", cache, cache -> cache.getAdvancedCache().getStats().getDataMemoryUsed())
.tags(getTagsWithCacheName())
.description("Provides how much memory the current eviction algorithm estimates is in use for data")
.register(registry);
}
Gauge.builder("cache.memory.offHeap", cache, cache -> cache.getAdvancedCache().getStats().getOffHeapMemoryUsed())
.tags(getTagsWithCacheName())
.description("The amount of off-heap memory used by this cache")
.register(registry);
}
private void averages(MeterRegistry registry) {
Gauge.builder("cache.puts.latency", cache, cache -> cache.getAdvancedCache().getStats().getAverageWriteTime())
.baseUnit(TimeUnit.MILLISECONDS.name())
.tags(getTagsWithCacheName())
.description("Cache puts")
.register(registry);
Gauge.builder("cache.gets.latency", cache, cache -> cache.getAdvancedCache().getStats().getAverageReadTime())
.baseUnit(TimeUnit.MILLISECONDS.name())
.tags(getTagsWithCacheName())
.description("Cache gets")
.register(registry);
Gauge.builder("cache.removes.latency", cache, cache -> cache.getAdvancedCache().getStats().getAverageRemoveTime())
.baseUnit(TimeUnit.MILLISECONDS.name())
.tags(getTagsWithCacheName())
.description("Cache removes")
.register(registry);
}
private void averagesNanos(MeterRegistry registry) {
Gauge.builder("cache.puts.nlatency", cache, cache -> cache.getAdvancedCache().getStats().getAverageWriteTimeNanos())
.baseUnit(TimeUnit.NANOSECONDS.name())
.tags(getTagsWithCacheName())
.description("Cache puts in nanos")
.register(registry);
Gauge.builder("cache.gets.nlatency", cache, cache -> cache.getAdvancedCache().getStats().getAverageReadTimeNanos())
.baseUnit(TimeUnit.NANOSECONDS.name())
.tags(getTagsWithCacheName())
.description("Cache gets in nanos")
.register(registry);
Gauge.builder("cache.removes.nlatency", cache, cache -> cache.getAdvancedCache().getStats().getAverageRemoveTimeNanos())
.baseUnit(TimeUnit.NANOSECONDS.name())
.tags(getTagsWithCacheName())
.description("Cache removes in nanos")
.register(registry);
}
}
| 5,210
| 35.697183
| 129
|
java
|
null |
infinispan-main/spring/spring-boot-3/embedded/src/main/java/org/infinispan/spring/starter/embedded/actuator/InfinispanCacheMeterBinderProvider.java
|
package org.infinispan.spring.starter.embedded.actuator;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.actuate.metrics.cache.CacheMeterBinderProvider;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.cache.Cache;
import org.springframework.stereotype.Component;
import io.micrometer.core.instrument.Tag;
import io.micrometer.core.instrument.binder.MeterBinder;
/**
* When actuate dependency is found in the classpath, this component links Infinispan cache metrics with Actuator
*
* @author Katia Aresti, karesti@redtat.com
* @since 2.1
*/
@Component
@Qualifier(InfinispanCacheMeterBinderProvider.NAME)
@ConditionalOnClass(name = "org.springframework.boot.actuate.metrics.cache.CacheMeterBinderProvider")
@ConditionalOnProperty(value = "infinispan.embedded.enabled", havingValue = "true", matchIfMissing = true)
public class InfinispanCacheMeterBinderProvider implements CacheMeterBinderProvider<Cache> {
public static final String NAME = "infinispanCacheMeterBinderProvider";
@Override
public MeterBinder getMeterBinder(Cache cache, Iterable<Tag> tags) {
Object nativeCache = cache.getNativeCache();
MeterBinder meterBinder = null;
if (nativeCache instanceof org.infinispan.Cache) {
meterBinder = new InfinispanCacheMeterBinder((org.infinispan.Cache) nativeCache, tags);
}
return meterBinder;
}
}
| 1,540
| 40.648649
| 113
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.