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/cli/src/main/java/org/infinispan/cli/patching/ServerFile.java
|
package org.infinispan.cli.patching;
import java.nio.file.Path;
import java.nio.file.Paths;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class ServerFile {
private final Path directory;
private final String filename;
private final String basename;
private final String digest;
private final String permissions;
private final boolean soft;
public ServerFile(Path path, String digest, String permissions, boolean soft) {
this.directory = path.getParent();
this.filename = path.getFileName().toString();
this.basename = basename(filename);
this.digest = digest;
this.permissions = permissions;
this.soft = soft;
}
@Override
public String toString() {
return "ServerFile{" +
"directory=" + directory +
", filename='" + filename + '\'' +
", basename='" + basename + '\'' +
", permissions='" + permissions + '\'' +
", soft=" + soft +
'}';
}
private static String basename(String filename) {
// Get the artifact name up to the version
int l = filename.length();
for (int i = 0; i < l; i++) {
char c = filename.charAt(i);
if (c == '-' && i < l - 1) {
c = filename.charAt(i + 1);
if (c >= '0' && c <= '9') {
return filename.substring(0, i);
}
}
}
// Could not obtain an artifact
return filename;
}
public String getFilename() {
return filename;
}
public String getDigest() {
return digest;
}
public String getPermissions() {
return permissions;
}
Path getVersionedPath() {
return directory != null ? directory.resolve(filename) : Paths.get(filename);
}
Path getUnversionedPath() {
return directory != null ? directory.resolve(basename) : Paths.get(basename);
}
public boolean isSoft() {
return soft;
}
}
| 1,989
| 24.512821
| 83
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/patching/PatchOperation.java
|
package org.infinispan.cli.patching;
import java.nio.file.Path;
import java.nio.file.Paths;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class PatchOperation implements JsonSerialization {
public static final String ACTION = "action";
public static final String PATH = "path";
public static final String DIGEST = "digest";
public static final String PERMISSIONS = "permissions";
public static final String NEW_PATH = "new-path";
public static final String NEW_DIGEST = "new-digest";
public static final String NEW_PERMISSIONS = "new-permissions";
enum Action {
ADD,
REMOVE,
UPGRADE,
HARD_REPLACE,
SOFT_REPLACE
}
private final Action action;
private final Path path;
private final String digest;
private final String permissions;
private final Path newPath;
private final String newDigest;
private final String newPermissions;
public static PatchOperation add(Path path, String digest, String permissions) {
return new PatchOperation(Action.ADD, null, null, null, path, digest, permissions);
}
public static PatchOperation remove(Path path, String digest, String permissions) {
return new PatchOperation(Action.REMOVE, path, digest, permissions, null, null, null);
}
public static PatchOperation upgrade(Path path, String digest, String permissions, Path newPath, String newDigest, String newPermissions) {
return new PatchOperation(Action.UPGRADE, path, digest, permissions, newPath, newDigest, newPermissions);
}
public static PatchOperation replace(boolean soft, Path path, String digest, String permissions, String newDigest, String newPermissions) {
return new PatchOperation(soft ? Action.SOFT_REPLACE : Action.HARD_REPLACE, path, digest, permissions, path, newDigest, newPermissions);
}
private PatchOperation(Action action, Path path, String digest, String permissions, Path newPath, String newDigest, String newPermissions) {
this.action = action;
this.path = path;
this.digest = digest;
this.permissions = permissions;
this.newPath = newPath;
this.newDigest = newDigest;
this.newPermissions = newPermissions;
}
public Action getAction() {
return action;
}
public Path getPath() {
return path;
}
public String getDigest() {
return digest;
}
public String getPermissions() {
return permissions;
}
public Path getNewPath() {
return newPath;
}
public String getNewDigest() {
return newDigest;
}
public String getNewPermissions() {
return newPermissions;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder(action.name());
if (path != null) {
sb.append(" ").append(path).append(" [").append(digest).append("] ").append(permissions);
}
if (newPath != null) {
sb.append(" -> ").append(newPath).append(" [").append(newDigest).append("] ").append(newPermissions);
}
return sb.toString();
}
public static PatchOperation fromJson(Json json) {
Action action = Action.valueOf(json.at(ACTION).asString());
switch (action) {
case ADD:
return add(Paths.get(json.at(NEW_PATH).asString()), json.at(NEW_DIGEST).asString(), json.at(NEW_PERMISSIONS).asString());
case REMOVE:
return remove(Paths.get(json.at(PATH).asString()), json.at(DIGEST).asString(), json.at(PERMISSIONS).asString());
case HARD_REPLACE:
return replace(false, Paths.get(json.at(PATH).asString()), json.at(DIGEST).asString(), json.at(PERMISSIONS).asString(), json.at(NEW_DIGEST).asString(), json.at(NEW_PERMISSIONS).asString());
case SOFT_REPLACE:
return replace(true, Paths.get(json.at(PATH).asString()), json.at(DIGEST).asString(), json.at(PERMISSIONS).asString(), json.at(NEW_DIGEST).asString(), json.at(NEW_PERMISSIONS).asString());
case UPGRADE:
return upgrade(Paths.get(json.at(PATH).asString()), json.at(DIGEST).asString(), json.at(PERMISSIONS).asString(), Paths.get(json.at(NEW_PATH).asString()), json.at(NEW_DIGEST).asString(), json.at(NEW_PERMISSIONS).asString());
default:
throw new IllegalArgumentException(action.name());
}
}
@Override
public Json toJson() {
Json result = Json.object().set(ACTION, action.name());
if (path != null) {
result.set(PATH, path.toString());
result.set(DIGEST, digest);
result.set(PERMISSIONS, permissions);
}
if (newPath != null) {
result.set(NEW_PATH, newPath.toString());
}
if (newDigest != null) {
result.set(NEW_DIGEST, newDigest);
}
if (newPermissions != null) {
result.set(NEW_PERMISSIONS, newPermissions);
}
return result;
}
}
| 5,050
| 34.076389
| 235
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/patching/PatchTool.java
|
package org.infinispan.cli.patching;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.infinispan.cli.logging.Messages.MSG;
import static org.infinispan.cli.util.Utils.sha256;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.URI;
import java.nio.file.FileSystem;
import java.nio.file.FileSystems;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.nio.file.attribute.BasicFileAttributes;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.util.Util;
import org.infinispan.commons.util.Version;
/**
* Creates/installs/removes patches
*
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class PatchTool {
public static final String PATCHES_DIR = ".patches";
public static final String PATCHES_FILE = "patches.json";
private final PrintStream out;
private final PrintStream err;
public PatchTool(PrintStream out, PrintStream err) {
this.out = out;
this.err = err;
}
public void createPatch(String qualifier, Path patch, Path target, Path... sources) throws IOException {
// Obtain version information
Version targetVersion = getVersion(target);
// Build a list of files in the target
Map<Path, ServerFile> targetFiles = getServerFiles(target);
// Create the patch zip file
try (FileSystem zipfs = getPatchFile(patch, true)) {
for (Path source : sources) {
createSinglePatch(qualifier, source, target, targetVersion, targetFiles, zipfs);
}
}
}
public void describePatch(Path patch, boolean verbose) throws IOException {
try (FileSystem zipfs = getPatchFile(patch)) {
getPatchInfos(zipfs).forEach(patchInfo -> {
out.println(patchInfo);
if (verbose) {
patchInfo.getOperations().forEach(op -> out.println(" " + op));
}
}
);
}
}
public void listPatches(Path target, boolean verbose) {
List<PatchInfo> installedPatches = getInstalledPatches(target);
if (installedPatches.isEmpty()) {
out.println(MSG.patchNoPatchesInstalled());
} else {
for (PatchInfo patchInfo : installedPatches) {
out.println(MSG.patchInfo(patchInfo));
if (verbose) {
patchInfo.getOperations().forEach(op -> out.println(" " + op));
}
}
}
}
public void installPatch(Path patch, Path target, boolean dryRun) throws IOException {
// Obtain the target version
Version targetVersion = getVersion(target);
String version = targetVersion.brandVersion();
String brandName = targetVersion.brandName();
List<PatchInfo> installedPatches = getInstalledPatches(target);
// Open the patch file
try (FileSystem zipfs = getPatchFile(patch)) {
// Iterate the patch json files to find one that matches our version as a source
PatchInfo patchInfo = getPatchInfos(zipfs).stream()
.filter(info -> brandName.equals(info.getBrandName()) && version.equals(info.getSourceVersion()))
.findFirst().orElseThrow(() -> {
throw MSG.patchCannotApply(brandName, version);
});
// Validate the SHAs of the existing files against the source ones in the patch
List<PatchOperation> operations = patchInfo.getOperations();
// Collect all errors
List<String> errors = new ArrayList<>();
// Scan the patch to ensure its contents match with the list of operations
for (PatchOperation operation : operations) {
switch (operation.getAction()) {
case ADD:
case SOFT_REPLACE:
case HARD_REPLACE:
case UPGRADE:
String sha256 = sha256(zipfs.getPath(operation.getNewPath().toString()));
if (sha256 == null || !sha256.equals(operation.getNewDigest())) {
errors.add(MSG.patchCorruptArchive(operation));
}
}
}
if (errors.size() > 0) {
throw MSG.patchValidationErrors(String.join("\n", errors));
}
// Scan the server files to ensure that the patch can be installed
for (PatchOperation operation : operations) {
switch (operation.getAction()) {
case ADD:
case SOFT_REPLACE:
// Ignore adds and soft replaces
break;
case REMOVE:
case HARD_REPLACE:
case UPGRADE:
String sha256 = sha256(target.resolve(operation.getPath()));
if (sha256 == null || !sha256.equals(operation.getDigest())) {
errors.add(MSG.patchShaMismatch(operation.getPath(), operation.getDigest(), sha256));
}
break;
}
}
if (errors.size() > 0) {
throw MSG.patchValidationErrors(String.join("\n", errors));
}
// We're good to go, backup the files being removed / replaced
Path backup = getBackupPath(target, patchInfo);
Files.createDirectories(backup);
for (PatchOperation operation : operations) {
switch (operation.getAction()) {
case ADD:
// Ignore adds
break;
case SOFT_REPLACE:
// We backup only if the checksum matches (which means we will be replacing a distribution file)
String sha256 = sha256(target.resolve(operation.getPath()));
if (sha256 == null || !sha256.equals(operation.getDigest())) {
break;
}
case REMOVE:
case HARD_REPLACE:
case UPGRADE:
Path file = backup.resolve(operation.getPath());
println(dryRun, MSG.patchBackup(target.resolve(operation.getPath()), file));
if (!dryRun) {
Files.createDirectories(file.getParent());
Files.move(target.resolve(operation.getPath()), file);
}
break;
}
}
// Now perform the actual operations
for (PatchOperation operation : operations) {
switch (operation.getAction()) {
case REMOVE:
// Do nothing, the file has already been removed as part of the backup
break;
case SOFT_REPLACE:
String sha256 = sha256(target.resolve(operation.getPath()));
if (sha256 == null || sha256.equals(operation.getDigest())) {
if (!dryRun) {
Path file = Files.copy(zipfs.getPath(operation.getNewPath().toString()), target.resolve(operation.getNewPath()));
Files.setPosixFilePermissions(file, PosixFilePermissions.fromString(operation.getNewPermissions()));
}
} else {
// We create a new file by appending the target version to the filename
if (!dryRun) {
Path file = target.resolve(operation.getNewPath());
file = file.getParent().resolve(file.getFileName().toString() + "-" + patchInfo.getTargetVersion());
Files.copy(zipfs.getPath(operation.getNewPath().toString()), file);
Files.setPosixFilePermissions(file, PosixFilePermissions.fromString(operation.getNewPermissions()));
}
}
break;
case ADD:
case HARD_REPLACE:
case UPGRADE:
if (!dryRun) {
Path file = target.resolve(operation.getNewPath());
if (file.getParent() != null) {
Files.createDirectories(file.getParent());
}
Files.copy(zipfs.getPath(operation.getNewPath().toString()), file, StandardCopyOption.REPLACE_EXISTING);
Files.setPosixFilePermissions(file, PosixFilePermissions.fromString(operation.getNewPermissions()));
}
break;
}
}
patchInfo.setInstallationDate(new Date());
if (!dryRun) {
installedPatches.add(patchInfo);
writeInstalledPatches(target, installedPatches);
}
println(dryRun, MSG.patchInfo(patchInfo));
}
}
public void rollbackPatch(Path target, boolean dryRun) throws IOException {
List<PatchInfo> installedPatches = getInstalledPatches(target);
if (installedPatches.isEmpty()) {
throw MSG.patchNoPatchesInstalledToRollback();
}
PatchInfo patchInfo = installedPatches.remove(installedPatches.size() - 1);
Path backup = getBackupPath(target, patchInfo);
for (PatchOperation operation : patchInfo.getOperations()) {
switch (operation.getAction()) {
case ADD: {
Path file = target.resolve(operation.getNewPath());
// Remove any added files
println(dryRun, MSG.patchRollbackFile(file));
if (!dryRun) {
Files.delete(file);
}
}
break;
case SOFT_REPLACE: {
// We only restore if the file hasn't been changed
Path file = target.resolve(operation.getPath());
String sha256 = sha256(file);
if (sha256 != null && sha256.equals(operation.getNewDigest())) {
println(dryRun, MSG.patchRollbackFile(file));
if (!dryRun) {
Files.move(backup.resolve(operation.getPath()), target.resolve(operation.getPath()), StandardCopyOption.REPLACE_EXISTING);
}
}
// We might have created a side-file, remove it
file = target.resolve(operation.getNewPath());
file = file.getParent().resolve(file.getFileName().toString() + "-" + patchInfo.getTargetVersion());
if (Files.exists(file)) {
println(dryRun, MSG.patchRollbackFile(file));
if (!dryRun) {
Files.delete(file);
}
}
break;
}
case UPGRADE: {
Path file = target.resolve(operation.getNewPath());
if (!dryRun) {
Files.delete(file);
}
}
// Fall through to add the backed-up file
case REMOVE:
case HARD_REPLACE: {
Path file = target.resolve(operation.getPath());
println(dryRun, MSG.patchRollbackFile(file));
if (!dryRun) {
Files.move(backup.resolve(operation.getPath()), target.resolve(operation.getPath()), StandardCopyOption.REPLACE_EXISTING);
}
}
break;
}
}
if (!dryRun) {
writeInstalledPatches(target, installedPatches);
}
println(dryRun, MSG.patchRollback(patchInfo));
}
private void println(boolean dryRun, String msg) {
if (dryRun) {
out.print(MSG.patchDryRun());
}
out.println(msg);
}
private Path getBackupPath(Path target, PatchInfo patchInfo) {
return target.resolve(PATCHES_DIR).resolve(patchInfo.getSourceVersion() + "_" + patchInfo.getTargetVersion());
}
private List<PatchInfo> getInstalledPatches(Path target) {
Path patchesFile = target.resolve(PATCHES_DIR).resolve(PATCHES_FILE);
try (InputStream is = Files.newInputStream(patchesFile, StandardOpenOption.READ)) {
Json read = Json.read(Util.read(is));
return read.asJsonList().stream().map(PatchInfo::fromJson).collect(Collectors.toList());
} catch (NoSuchFileException e) {
return new ArrayList<>();
} catch (IOException e) {
throw MSG.patchCannotRead(patchesFile, e);
}
}
private void writeInstalledPatches(Path target, List<PatchInfo> patches) {
try (OutputStream os = Files.newOutputStream(Files.createDirectories(target.resolve(PATCHES_DIR)).resolve(PATCHES_FILE), StandardOpenOption.WRITE, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
String json = Json.make(patches).toString();
os.write(json.getBytes(UTF_8));
} catch (IOException e) {
throw MSG.patchCannotWritePatchesFile(e);
}
}
private void createSinglePatch(String qualifier, Path source, Path target, Version targetVersion, Map<Path, ServerFile> targetFiles, FileSystem zipfs) throws IOException {
Version sourceVersion = getVersion(source);
// Ensure that the brand name coincides
String sourceBrand = sourceVersion.brandName();
String targetBrand = targetVersion.brandName();
if (!sourceBrand.equals(targetBrand)) {
throw MSG.patchIncompatibleProduct(sourceBrand, targetBrand);
}
if (sourceVersion.brandVersion().equals(targetVersion.brandVersion())) {
throw MSG.patchServerAndTargetMustBeDifferent(sourceVersion.brandVersion());
}
PatchInfo patchInfo = new PatchInfo(sourceBrand, sourceVersion.brandVersion(), targetVersion.brandVersion(), qualifier);
// Build a list of files in the old version
Map<Path, ServerFile> v1Files = getServerFiles(source);
// Compare the two file lists, generating a list of upgrade instructions
List<PatchOperation> operations = patchInfo.getOperations();
v1Files.forEach((k1, v1File) -> {
if (!targetFiles.containsKey(k1)) {
operations.add(PatchOperation.remove(v1File.getVersionedPath(), v1File.getDigest(), v1File.getPermissions()));
} else {
ServerFile targetFile = targetFiles.get(k1);
if (!v1File.getFilename().equals(targetFile.getFilename())) { // Different filename means upgrade
operations.add(PatchOperation.upgrade(v1File.getVersionedPath(), v1File.getDigest(), v1File.getPermissions(), targetFile.getVersionedPath(), targetFile.getDigest(), targetFile.getPermissions()));
addFileToZip(zipfs, target, targetFile);
} else if (!v1File.getDigest().equals(targetFile.getDigest())) {
// Check contents
operations.add(PatchOperation.replace(targetFile.isSoft(), targetFile.getVersionedPath(), v1File.getDigest(), v1File.getPermissions(), targetFile.getDigest(), targetFile.getPermissions()));
addFileToZip(zipfs, target, targetFile);
}
}
});
targetFiles.forEach((k2, targetFile) -> {
if (!v1Files.containsKey(k2)) {
operations.add(PatchOperation.add(targetFile.getVersionedPath(), targetFile.getDigest(), targetFile.getPermissions()));
addFileToZip(zipfs, target, targetFile);
}
});
// Write out the JSON patch file
Path patchPath = zipfs.getPath("patch-" + patchInfo.getSourceVersion() + "_" + patchInfo.getTargetVersion() + ".json");
try (OutputStream os = Files.newOutputStream(patchPath, StandardOpenOption.CREATE, StandardOpenOption.TRUNCATE_EXISTING)) {
String json = patchInfo.toJson().toPrettyString();
os.write(json.getBytes(UTF_8));
}
}
private Map<Path, ServerFile> getServerFiles(Path base) throws IOException {
Pattern IGNORE = Pattern.compile("^(\\.patches/|server/data/|server/log/|server/lib/).*$");
Pattern SOFT_REPLACE_PATTERN = Pattern.compile("^server/conf/.*$");
Map<Path, ServerFile> files = new TreeMap<>();
Files.walkFileTree(base, new SimpleFileVisitor<Path>() {
@Override
public FileVisitResult visitFile(Path oPath, BasicFileAttributes attrs) {
Path rPath = base.relativize(oPath);
String rPathName = rPath.toString();
if (!IGNORE.matcher(rPathName).matches()) {
ServerFile file = new ServerFile(rPath, sha256(oPath), getPermissions(oPath), SOFT_REPLACE_PATTERN.matcher(rPathName).matches());
files.put(file.getUnversionedPath(), file);
}
return FileVisitResult.CONTINUE;
}
});
return files;
}
private static String getPermissions(Path path) {
try {
return PosixFilePermissions.toString(Files.getPosixFilePermissions(path));
} catch (IOException e) {
throw new RuntimeException(e);
}
}
private List<PatchInfo> getPatchInfos(FileSystem zipfs) throws IOException {
List<Path> paths = Files.find(zipfs.getPath("/"), 1,
(p, a) -> a.isRegularFile() && p.getFileName().toString().startsWith("patch-") && p.getFileName().toString().endsWith(".json")
).collect(Collectors.toList());
List<PatchInfo> infos = new ArrayList<>(paths.size());
for (Path path : paths) {
try (InputStream is = Files.newInputStream(path, StandardOpenOption.READ)) {
Json json = Json.read(Util.read(is));
infos.add(PatchInfo.fromJson(json));
}
}
return infos;
}
private Version getVersion(Path base) throws IOException {
// Load the META-INF/infinispan-version.properties from the lib/infinispan-commons jar
Path lib = base.resolve("lib");
File[] commons = lib.toFile().listFiles((dir, name) -> name.startsWith("infinispan-commons-") && name.endsWith(".jar"));
if (commons == null || commons.length != 1) {
throw MSG.patchCannotFindCommons(lib);
}
URI jarUri = URI.create("jar:" + commons[0].toURI());
try (FileSystem zipfs = FileSystems.newFileSystem(jarUri, Collections.emptyMap()); InputStream in = Files.newInputStream(zipfs.getPath("META-INF", "infinispan-version.properties"))) {
return Version.from(in);
}
}
private FileSystem getPatchFile(Path patch, boolean create) throws IOException {
if (create && patch.toFile().exists()) {
throw MSG.patchFileAlreadyExists(patch);
}
URI jarUri = URI.create("jar:" + patch.toUri());
return FileSystems.newFileSystem(jarUri, create ? Collections.singletonMap("create", "true") : Collections.emptyMap());
}
private FileSystem getPatchFile(Path patch) throws IOException {
return getPatchFile(patch, false);
}
private void addFileToZip(FileSystem zipfs, Path basePath, ServerFile file) {
try {
Path target = zipfs.getPath(file.getVersionedPath().toString());
out.println(MSG.patchCreateAdd(target));
if (target.getParent() != null) {
Files.createDirectories(target.getParent());
}
Files.copy(basePath.resolve(file.getVersionedPath()), target, StandardCopyOption.REPLACE_EXISTING);
} catch (IOException e) {
throw MSG.patchCreateError(e);
}
}
}
| 19,702
| 43.0783
| 220
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/BackupCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* A {@link org.aesh.command.completer.OptionCompleter} for Backup files that are available on the server.
*
* @author Ryan Emerson
* @since 12.0
*/
public class BackupCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
String container = connection.getActiveContainer().getName();
return context.getConnection().getBackupNames(container);
}
}
| 678
| 28.521739
| 106
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ExposeCompleter.java
|
package org.infinispan.cli.completers;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class ExposeCompleter extends EnumCompleter {
public enum Expose {
LoadBalancer,
NodePort,
Route;
}
public ExposeCompleter() {
super(Expose.class);
}
}
| 319
| 15.842105
| 57
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/SiteCompleter.java
|
package org.infinispan.cli.completers;
import static org.infinispan.cli.completers.CacheCompleter.getCacheName;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
import org.aesh.command.Command;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class SiteCompleter extends ListCompleter {
@Override
protected Collection<String> getAvailableItems(ContextAwareCompleterInvocation invocation) throws IOException {
Context context = invocation.context;
Command<?> cmd = invocation.getCommand();
Connection connection = context.getConnection();
Optional<String> cacheName = getCacheName(context, cmd);
return cacheName.map(name -> getAvailableSites(connection, name))
.orElseGet(connection::getSitesView);
}
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
throw new IllegalStateException();
}
private static Collection<String> getAvailableSites(Connection connection, String cacheName) {
try {
return connection.getAvailableSites(connection.getActiveContainer().getName(), cacheName);
} catch (Exception e) {
return Collections.emptyList();
}
}
}
| 1,381
| 31.139535
| 114
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ContextAwareCompleterInvocation.java
|
package org.infinispan.cli.completers;
import java.util.Collection;
import java.util.List;
import org.aesh.command.Command;
import org.aesh.command.completer.CompleterInvocation;
import org.aesh.readline.AeshContext;
import org.aesh.readline.terminal.formatting.TerminalString;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ContextAwareCompleterInvocation implements CompleterInvocation {
private final CompleterInvocation delegate;
protected final Context context;
public ContextAwareCompleterInvocation(CompleterInvocation delegate, Context context) {
this.delegate = delegate;
this.context = context;
}
@Override
public String getGivenCompleteValue() {
return delegate.getGivenCompleteValue();
}
@Override
public Command getCommand() {
return delegate.getCommand();
}
@Override
public List<TerminalString> getCompleterValues() {
return delegate.getCompleterValues();
}
@Override
public void setCompleterValues(Collection<String> completerValues) {
delegate.setCompleterValues(completerValues);
}
@Override
public void setCompleterValuesTerminalString(List<TerminalString> completerValues) {
delegate.setCompleterValuesTerminalString(completerValues);
}
@Override
public void clearCompleterValues() {
delegate.clearCompleterValues();
}
@Override
public void addAllCompleterValues(Collection<String> completerValues) {
delegate.addAllCompleterValues(completerValues);
}
@Override
public void addCompleterValue(String value) {
delegate.addCompleterValue(value);
}
@Override
public void addCompleterValueTerminalString(TerminalString value) {
delegate.addCompleterValueTerminalString(value);
}
@Override
public boolean isAppendSpace() {
return delegate.isAppendSpace();
}
@Override
public void setAppendSpace(boolean appendSpace) {
delegate.setAppendSpace(appendSpace);
}
@Override
public void setIgnoreOffset(boolean ignoreOffset) {
delegate.setIgnoreOffset(ignoreOffset);
}
@Override
public boolean doIgnoreOffset() {
return delegate.doIgnoreOffset();
}
@Override
public void setOffset(int offset) {
delegate.setOffset(offset);
}
@Override
public int getOffset() {
return delegate.getOffset();
}
@Override
public void setIgnoreStartsWith(boolean ignoreStartsWith) {
delegate.setIgnoreStartsWith(ignoreStartsWith);
}
@Override
public boolean isIgnoreStartsWith() {
return delegate.isIgnoreStartsWith();
}
@Override
public AeshContext getAeshContext() {
return delegate.getAeshContext();
}
}
| 2,791
| 23.278261
| 90
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/AvailabilityCompleter.java
|
package org.infinispan.cli.completers;
/**
* @author Ryan Emerson
* @since 13.0
*/
public class AvailabilityCompleter extends EnumCompleter<AvailabilityCompleter.Availability> {
public enum Availability {
AVAILABLE,
DEGRADED_MODE,
}
public AvailabilityCompleter() {
super(AvailabilityCompleter.Availability.class);
}
}
| 354
| 19.882353
| 94
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/XSiteStateTransferModeCompleter.java
|
package org.infinispan.cli.completers;
import org.infinispan.configuration.cache.XSiteStateTransferMode;
/**
* An {@link EnumCompleter} implementation for {@link XSiteStateTransferMode}
*
* @author Pedro Ruivo
* @since 12.1
*/
public class XSiteStateTransferModeCompleter extends EnumCompleter<XSiteStateTransferMode> {
public XSiteStateTransferModeCompleter() {
super(XSiteStateTransferMode.class);
}
}
| 424
| 24
| 92
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/EncryptionCompleter.java
|
package org.infinispan.cli.completers;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class EncryptionCompleter extends EnumCompleter {
public enum Encryption {
None,
Secret,
Service;
}
public EncryptionCompleter() {
super(Encryption.class);
}
}
| 327
| 16.263158
| 57
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/DataSourceCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import org.infinispan.cli.Context;
/**
* A {@link org.aesh.command.completer.OptionCompleter} for data sources.
*
* @author Tristan Tarrant
* @since 13.0
*/
public class DataSourceCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
try {
return context.getConnection().getDataSourceNames();
} catch (IOException e) {
return Collections.emptyList();
}
}
}
| 601
| 23.08
| 77
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/EncodingCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.infinispan.cli.Context;
import org.infinispan.commons.dataconversion.MediaType;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class EncodingCompleter extends ListCompleter {
private static final List<String> ENCODINGS = Arrays.asList(
MediaType.TEXT_PLAIN_TYPE,
MediaType.APPLICATION_JSON_TYPE,
MediaType.APPLICATION_XML_TYPE,
MediaType.APPLICATION_OCTET_STREAM_TYPE
);
@Override
Collection<String> getAvailableItems(Context context) {
return ENCODINGS;
}
}
| 689
| 24.555556
| 63
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/LogAppenderCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class LogAppenderCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
return connection.getAvailableLogAppenders();
}
}
| 529
| 24.238095
| 77
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/MediaTypeCompleter.java
|
package org.infinispan.cli.completers;
/**
* @since 14.0
*/
public class MediaTypeCompleter extends EnumCompleter<MediaTypeCompleter.MediaType> {
public enum MediaType {
XML,
JSON,
YAML
}
public MediaTypeCompleter() {
super(MediaType.class);
}
}
| 286
| 15.882353
| 85
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/CounterTypeCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CounterTypeCompleter extends ListCompleter {
private static final List<String> COUNTER_TYPES = Arrays.asList(
"weak", "strong"
);
@Override
Collection<String> getAvailableItems(Context context) {
return COUNTER_TYPES;
}
}
| 502
| 20.869565
| 67
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/CdContextCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.aesh.command.completer.CompleterInvocation;
import org.aesh.command.completer.OptionCompleter;
import org.infinispan.cli.Context;
import org.infinispan.cli.resources.Resource;
import org.infinispan.cli.resources.RootResource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CdContextCompleter implements OptionCompleter<CompleterInvocation> {
@Override
public void complete(CompleterInvocation invocation) {
Context context = ((ContextAwareCompleterInvocation) invocation).context;
Resource resource = context.getConnection().getActiveResource();
String v = invocation.getGivenCompleteValue();
if (v == null || v.length() == 0) {
// no completions yet, add all of the local resource children
invocation.addAllCompleterValues(getChildrenNames(resource));
invocation.setAppendSpace(resource.isLeaf());
} else {
String[] parts = v.split("/");
if (parts.length == 0) {
resource = resource.findAncestor(RootResource.class);
invocation.addAllCompleterValues(getChildrenNames(resource));
invocation.setAppendSpace(resource.isLeaf());
} else {
int offset;
String last;
String prefix;
if (v.endsWith("/")) {
offset = 0;
last = "";
prefix = v;
} else {
offset = 1;
last = parts[parts.length - 1];
int lastSlash = v.lastIndexOf('/');
prefix = lastSlash < 0 ? "" : v.substring(0, lastSlash + 1);
}
for (int i = 0; i < parts.length - offset; i++) {
if (parts[i].isEmpty()) {
resource = resource.findAncestor(RootResource.class);
} else {
try {
resource = resource.getChild(parts[i]);
} catch (IOException e) {
// Ignore
}
}
}
Iterable<String> all = getChildrenNames(resource);
for (String item : all) {
if (item.startsWith(last)) {
invocation.addCompleterValue(prefix + item);
}
}
invocation.setAppendSpace(resource.isLeaf());
}
}
}
private Collection<String> getChildrenNames(Resource resource) {
try {
List<String> children = new ArrayList<>();
resource.getChildrenNames().forEach(children::add);
return children;
} catch (IOException e) {
return Collections.emptyList();
}
}
}
| 2,867
| 33.97561
| 81
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/HelpCompleter.java
|
package org.infinispan.cli.completers;
import java.util.ArrayList;
import java.util.List;
import org.aesh.command.completer.CompleterInvocation;
import org.aesh.command.completer.OptionCompleter;
import org.aesh.command.invocation.CommandInvocation;
import org.aesh.command.registry.CommandRegistry;
public class HelpCompleter implements OptionCompleter {
@Override
public void complete(CompleterInvocation invocation) {
List<String> completeValues = new ArrayList<>();
CommandRegistry<? extends CommandInvocation> registry = ((ContextAwareCompleterInvocation) invocation).context.getRegistry();
if (registry != null) {
for (String command : registry.getAllCommandNames()) {
if (command.startsWith(invocation.getGivenCompleteValue()))
completeValues.add(command);
}
invocation.setCompleterValues(completeValues);
}
}
}
| 909
| 35.4
| 131
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/LogLevelCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class LogLevelCompleter extends ListCompleter {
private static final List<String> LEVELS = Arrays.asList(
"OFF",
"TRACE",
"DEBUG",
"INFO",
"WARN",
"ERROR",
"FATAL",
"ALL"
);
@Override
Collection<String> getAvailableItems(Context context) {
return LEVELS;
}
}
| 596
| 18.9
| 60
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ConfigPropertyCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Collection;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class ConfigPropertyCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) {
return Context.Property.NAMES;
}
}
| 366
| 19.388889
| 60
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/TimeUnitCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class TimeUnitCompleter extends ListCompleter {
private static List<String> VALUES = Arrays.stream(TimeUnit.values()).map(TimeUnit::name).collect(Collectors.toList());
@Override
Collection<String> getAvailableItems(Context context) {
return VALUES;
}
}
| 589
| 24.652174
| 122
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ContainerCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Collection;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ContainerCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) {
return context.getConnection().getAvailableContainers();
}
}
| 386
| 21.764706
| 62
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/LoggersCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class LoggersCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
return connection.getAvailableLoggers();
}
}
| 520
| 23.809524
| 77
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/PrettyPrintCompleter.java
|
package org.infinispan.cli.completers;
import org.infinispan.cli.printers.PrettyPrinter;
public class PrettyPrintCompleter extends EnumCompleter<PrettyPrinter.PrettyPrintMode> {
public PrettyPrintCompleter() {
super(PrettyPrinter.PrettyPrintMode.class);
}
}
| 273
| 23.909091
| 88
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/CounterCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
import org.infinispan.cli.resources.ContainerResource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CounterCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
ContainerResource container = connection.getActiveResource().findAncestor(ContainerResource.class);
return container != null ? connection.getAvailableCounters(container.getName()) : Collections.emptyList();
}
}
| 776
| 32.782609
| 112
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ConnectorCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import org.infinispan.cli.Context;
/**
* A {@link org.aesh.command.completer.OptionCompleter} for protocol connectors.
*
* @author Tristan Tarrant
* @since 12.1
*/
public class ConnectorCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
try {
return context.getConnection().getConnectorNames();
} catch (IOException e) {
return Collections.emptyList();
}
}
}
| 606
| 23.28
| 80
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/CacheCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Collection;
import java.util.Optional;
import org.aesh.command.Command;
import org.infinispan.cli.Context;
import org.infinispan.cli.commands.CacheAwareCommand;
import org.infinispan.cli.connection.Connection;
import org.infinispan.cli.resources.CacheResource;
import org.infinispan.cli.resources.Resource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CacheCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) {
Connection connection = context.getConnection();
return context.getConnection().getAvailableCaches(connection.getActiveContainer().getName());
}
static Optional<String> getCacheName(Context context, Command<?> command) {
Resource resource = context.getConnection().getActiveResource();
if (command instanceof CacheAwareCommand) {
return ((CacheAwareCommand) command).getCacheName(resource);
}
return CacheResource.findCacheName(resource);
}
}
| 1,070
| 32.46875
| 99
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/BenchmarkModeCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.infinispan.cli.Context;
import org.openjdk.jmh.annotations.Mode;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class BenchmarkModeCompleter extends ListCompleter {
private static List<String> VALUES = Arrays.stream(Mode.values()).map(Mode::name).collect(Collectors.toList());
@Override
Collection<String> getAvailableItems(Context context) {
return VALUES;
}
}
| 589
| 24.652174
| 114
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/CacheConfigurationCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
import org.infinispan.cli.resources.ContainerResource;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CacheConfigurationCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) {
Connection connection = context.getConnection();
return connection.getAvailableCacheConfigurations(connection.getActiveResource().findAncestor(ContainerResource.class).getName());
}
}
| 628
| 30.45
| 136
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/CounterStorageCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CounterStorageCompleter extends ListCompleter {
private static final List<String> COUNTER_STORAGE_TYPES = Arrays.asList(
"VOLATILE", "PERSISTENT"
);
@Override
Collection<String> getAvailableItems(Context context) {
return COUNTER_STORAGE_TYPES;
}
}
| 529
| 22.043478
| 75
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/EnumCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.Set;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public abstract class EnumCompleter<E extends Enum<E>> extends ListCompleter {
private final Set<String> enumSet;
public EnumCompleter(Class<E> theEnum) {
EnumSet<E> all = EnumSet.allOf(theEnum);
this.enumSet = new HashSet<>(all.size());
all.forEach(e -> enumSet.add(e.name()));
}
@Override
Collection<String> getAvailableItems(Context context) {
return enumSet;
}
}
| 674
| 22.275862
| 78
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ListFormatCompleter.java
|
package org.infinispan.cli.completers;
import org.infinispan.cli.resources.Resource;
public class ListFormatCompleter extends EnumCompleter<Resource.ListFormat> {
public ListFormatCompleter() {
super(Resource.ListFormat.class);
}
}
| 247
| 21.545455
| 77
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/BenchmarkVerbosityModeCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import org.infinispan.cli.Context;
import org.openjdk.jmh.runner.options.VerboseMode;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.0
**/
public class BenchmarkVerbosityModeCompleter extends ListCompleter {
private static List<String> VALUES = Arrays.stream(VerboseMode.values()).map(VerboseMode::name).collect(Collectors.toList());
@Override
Collection<String> getAvailableItems(Context context) {
return VALUES;
}
}
| 622
| 26.086957
| 128
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ServerCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ServerCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
return connection.getAvailableServers(connection.getActiveContainer().getName());
}
}
| 559
| 27
| 87
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/RolesCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 14.0
**/
public class RolesCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
return connection.getRoles();
}
}
| 507
| 23.190476
| 77
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/EncryptionAlgorithmCompleter.java
|
package org.infinispan.cli.completers;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.user.UserTool;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class EncryptionAlgorithmCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) {
return UserTool.DEFAULT_ALGORITHMS;
}
}
| 417
| 21
| 65
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/TaskCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.1
**/
public class TaskCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
return connection.getAvailableTasks(connection.getActiveContainer().getName());
}
}
| 555
| 26.8
| 85
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/CacheConfigurationAttributeCompleter.java
|
package org.infinispan.cli.completers;
import static org.infinispan.cli.completers.CacheCompleter.getCacheName;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 13.0
**/
public class CacheConfigurationAttributeCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
throw new UnsupportedOperationException();
}
@Override
protected Collection<String> getAvailableItems(ContextAwareCompleterInvocation invocation) throws IOException {
Connection connection = invocation.context.getConnection();
return getCacheName(invocation.context, invocation.getCommand()).map(connection::getCacheConfigurationAttributes).orElse(Collections.emptyList());
}
}
| 943
| 32.714286
| 152
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/IpFilterRuleCompleter.java
|
package org.infinispan.cli.completers;
import org.infinispan.client.rest.IpFilterRule;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 12.1
**/
public class IpFilterRuleCompleter extends EnumCompleter<IpFilterRule.RuleType> {
public IpFilterRuleCompleter() {
super(IpFilterRule.RuleType.class);
}
}
| 339
| 21.666667
| 81
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ListCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import org.aesh.command.completer.CompleterInvocation;
import org.aesh.command.completer.OptionCompleter;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public abstract class ListCompleter implements OptionCompleter<ContextAwareCompleterInvocation> {
abstract Collection<String> getAvailableItems(Context context) throws IOException;
protected Collection<String> getAvailableItems(ContextAwareCompleterInvocation invocation) throws IOException {
return getAvailableItems(invocation.context);
}
@Override
public void complete(ContextAwareCompleterInvocation invocation) {
try {
Collection<String> all = getAvailableItems(invocation);
completeFromList(invocation, all);
} catch (IOException e) {
e.printStackTrace();
}
}
public void completeFromList(CompleterInvocation invocation, Collection<String> all) {
String v = invocation.getGivenCompleteValue();
if (v == null || v.length() == 0) {
invocation.addAllCompleterValues(all);
} else {
for (String item : all) {
if (item.startsWith(v)) {
invocation.addCompleterValue(item);
}
}
}
}
}
| 1,373
| 29.533333
| 114
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/SchemaCompleter.java
|
package org.infinispan.cli.completers;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import org.infinispan.cli.Context;
import org.infinispan.cli.connection.Connection;
import org.infinispan.cli.resources.ContainerResource;
/**
* A {@link org.aesh.command.completer.OptionCompleter} for proto schemas that are available on the server.
*
* @author Ryan Emerson
* @since 12.0
*/
public class SchemaCompleter extends ListCompleter {
@Override
Collection<String> getAvailableItems(Context context) throws IOException {
Connection connection = context.getConnection();
ContainerResource container = connection.getActiveResource().findAncestor(ContainerResource.class);
return container != null ? connection.getAvailableSchemas(container.getName()) : Collections.emptyList();
}
}
| 850
| 33.04
| 111
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/ContextAwareCompleterInvocationProvider.java
|
package org.infinispan.cli.completers;
import java.util.Objects;
import org.aesh.command.completer.CompleterInvocation;
import org.aesh.command.completer.CompleterInvocationProvider;
import org.infinispan.cli.Context;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ContextAwareCompleterInvocationProvider implements CompleterInvocationProvider {
private final Context context;
public ContextAwareCompleterInvocationProvider(Context context) {
Objects.requireNonNull(context);
this.context = context;
}
@Override
public CompleterInvocation enhanceCompleterInvocation(CompleterInvocation completerInvocation) {
return new ContextAwareCompleterInvocation(completerInvocation, context);
}
}
| 776
| 28.884615
| 99
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/completers/AuthorizationPermissionCompleter.java
|
package org.infinispan.cli.completers;
/**
* @since 14.0
*/
public class AuthorizationPermissionCompleter extends EnumCompleter<AuthorizationPermissionCompleter.AuthorizationPermission> {
public enum AuthorizationPermission {
LIFECYCLE,
READ,
WRITE,
EXEC,
LISTEN,
BULK_READ,
BULK_WRITE,
ADMIN,
CREATE,
MONITOR,
ALL,
ALL_READ,
ALL_WRITE,
}
public AuthorizationPermissionCompleter() {
super(AuthorizationPermissionCompleter.AuthorizationPermission.class);
}
}
| 558
| 19.703704
| 127
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/converters/NullableIntegerConverter.java
|
package org.infinispan.cli.converters;
import org.aesh.command.converter.Converter;
import org.aesh.command.converter.ConverterInvocation;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 11.0
**/
public class NullableIntegerConverter implements Converter<Integer, ConverterInvocation> {
@Override
public Integer convert(ConverterInvocation invocation) {
String input = invocation.getInput();
return input == null || input.isEmpty() ? null : Integer.parseInt(input);
}
}
| 518
| 29.529412
| 90
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/ContainersResource.java
|
package org.infinispan.cli.resources;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ContainersResource extends AbstractResource {
public static final String NAME = "containers";
ContainersResource(Resource parent) {
super(parent, NAME);
}
@Override
public Iterable<String> getChildrenNames() {
return getConnection().getAvailableContainers();
}
@Override
public Resource getChild(String name) {
if (Resource.PARENT.equals(name)) {
return parent;
} else if (getConnection().getAvailableContainers().contains(name)) {
return new ContainerResource(this, name);
} else {
throw Messages.MSG.noSuchResource(name);
}
}
}
| 802
| 24.09375
| 75
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/ContainerResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
import java.util.Arrays;
import java.util.Optional;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ContainerResource extends AbstractResource {
ContainerResource(ContainersResource parent, String name) {
super(parent, name);
}
@Override
public Iterable<String> getChildrenNames() {
return Arrays.asList(CachesResource.NAME, CountersResource.NAME, ConfigurationsResource.NAME, SchemasResource.NAME, TasksResource.NAME);
}
@Override
public Resource getChild(String name) {
switch (name) {
case Resource.PARENT:
return parent;
case CachesResource.NAME:
return new CachesResource(this);
case CountersResource.NAME:
return new CountersResource(this);
case ConfigurationsResource.NAME:
return new ConfigurationsResource(this);
case SchemasResource.NAME:
return new SchemasResource(this);
case TasksResource.NAME:
return new TasksResource(this);
default:
throw Messages.MSG.noSuchResource(name);
}
}
@Override
public String describe() throws IOException {
return getConnection().describeContainer(name);
}
public static Optional<String> findContainerName(Resource resource) {
return resource.optionalFindAncestor(ContainerResource.class).map(AbstractResource::getName);
}
}
| 1,554
| 28.903846
| 142
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/NodeResource.java
|
package org.infinispan.cli.resources;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class NodeResource extends AbstractResource {
public NodeResource(ClusterResource parent, String name) {
super(parent, name);
}
@Override
public boolean isLeaf() {
return true;
}
}
| 337
| 18.882353
| 61
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/ClusterResource.java
|
package org.infinispan.cli.resources;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ClusterResource extends AbstractResource {
static final String NAME = "cluster";
ClusterResource(Resource parent) {
super(parent, NAME);
}
public Iterable<String> getChildrenNames() {
return getConnection().getClusterNodes();
}
@Override
public Resource getChild(String name) {
if (Resource.PARENT.equals(name)) {
return parent;
} else if (getConnection().getClusterNodes().contains(name)) {
return new NodeResource(this, name);
} else {
throw Messages.MSG.noSuchResource(name);
}
}
}
| 754
| 23.354839
| 68
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/CountersResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CountersResource extends AbstractResource {
public static final String NAME = "counters";
protected CountersResource(Resource parent) {
super(parent, NAME);
}
@Override
public Iterable<String> getChildrenNames() throws IOException {
return getConnection().getAvailableCounters(getParent().getName());
}
@Override
public Resource getChild(String name) throws IOException {
if (Resource.PARENT.equals(name)) {
return parent;
} else if (getConnection().getAvailableCounters(getParent().getName()).contains(name)) {
return new CounterResource(this, name);
} else {
throw Messages.MSG.noSuchResource(name);
}
}
}
| 909
| 25.764706
| 94
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/RootResource.java
|
package org.infinispan.cli.resources;
import java.util.Arrays;
import org.infinispan.cli.connection.Connection;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class RootResource extends AbstractResource {
private final Connection connection;
RootResource(Connection connection) {
super(null, "");
this.connection = connection;
}
@Override
public Iterable<String> getChildrenNames() {
return Arrays.asList(ContainersResource.NAME, ClusterResource.NAME, ServerResource.NAME);
}
@Override
public Resource getChild(String name) {
switch (name) {
case ContainersResource.NAME:
return new ContainersResource(this);
case ClusterResource.NAME:
return new ClusterResource(this);
case ServerResource.NAME:
return new ServerResource(this);
default:
throw Messages.MSG.noSuchResource(name);
}
}
@Override
Connection getConnection() {
return connection;
}
}
| 1,094
| 23.886364
| 95
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/TaskResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.1
**/
public class TaskResource extends AbstractResource {
public TaskResource(TasksResource parent, String name) {
super(parent, name);
}
@Override
public boolean isLeaf() {
return true;
}
@Override
public String describe() throws IOException {
return getConnection().describeTask(getParent().getParent().getName(), name);
}
}
| 516
| 20.541667
| 83
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/ServerResource.java
|
package org.infinispan.cli.resources;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ServerResource extends AbstractResource {
public static final String NAME = "server";
ServerResource(Resource parent) {
super(parent, NAME);
}
}
| 295
| 20.142857
| 57
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/CounterResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CounterResource extends AbstractResource {
public CounterResource(CountersResource parent, String name) {
super(parent, name);
}
@Override
public Iterable<String> getChildrenNames() throws IOException {
return getConnection().getCounterValue(getParent().getParent().getName(), name);
}
@Override
public boolean isLeaf() {
return true;
}
@Override
public String describe() throws IOException {
return getConnection().describeCounter(getParent().getParent().getName(), name);
}
public static String counterName(Resource resource) {
return resource.findAncestor(CounterResource.class).getName();
}
}
| 833
| 24.272727
| 86
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/CacheResource.java
|
package org.infinispan.cli.resources;
import static org.infinispan.cli.util.TransformingIterable.SINGLETON_MAP_VALUE;
import java.io.IOException;
import java.util.Map;
import java.util.Optional;
import org.aesh.command.shell.Shell;
import org.infinispan.cli.logging.Messages;
import org.infinispan.cli.printers.CacheEntryRowPrinter;
import org.infinispan.cli.printers.PrettyPrinter;
import org.infinispan.cli.printers.PrettyRowPrinter;
import org.infinispan.cli.util.TransformingIterable;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CacheResource extends AbstractResource {
public CacheResource(CachesResource parent, String name) {
super(parent, name);
}
public Iterable<String> getChildrenNames(int limit) throws IOException {
Iterable<Map<String, String>> keys = getConnection().getCacheKeys(getParent().getParent().getName(), name, limit);
return new TransformingIterable<>(keys, SINGLETON_MAP_VALUE);
}
@Override
public void printChildren(ListFormat format, int limit, PrettyPrinter.PrettyPrintMode prettyPrintMode, Shell shell) throws IOException {
Iterable<Map<String, String>> it;
PrettyRowPrinter rowPrinter;
switch (format) {
case NAMES:
it = getConnection().getCacheKeys(getParent().getParent().getName(), name, limit);
rowPrinter = new CacheEntryRowPrinter(shell.size().getWidth(), 1);
break;
case VALUES:
it = getConnection().getCacheEntries(getParent().getParent().getName(), name, limit, false);
rowPrinter = new CacheEntryRowPrinter(shell.size().getWidth(), 2);
break;
case FULL:
it = getConnection().getCacheEntries(getParent().getParent().getName(), name, limit, true);
rowPrinter = new CacheEntryRowPrinter(shell.size().getWidth(), 7);
break;
default:
throw Messages.MSG.unsupportedListFormat(format);
}
try(PrettyPrinter printer = PrettyPrinter.forMode(prettyPrintMode, shell, rowPrinter)) {
printer.print(it);
}
}
@Override
public boolean isLeaf() {
return true;
}
@Override
public Resource getChild(String name) {
if (Resource.PARENT.equals(name)) {
return parent;
} else {
return new CacheKeyResource(this, name);
}
}
@Override
public String describe() throws IOException {
return getConnection().describeCache(getParent().getParent().getName(), name);
}
public static String cacheName(Resource resource) {
return resource.findAncestor(CacheResource.class).getName();
}
public static Optional<String> findCacheName(Resource resource) {
return resource.optionalFindAncestor(CacheResource.class).map(AbstractResource::getName);
}
}
| 2,855
| 33.409639
| 139
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/TasksResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.1
**/
public class TasksResource extends AbstractResource {
public static final String NAME = "tasks";
protected TasksResource(Resource parent) {
super(parent, NAME);
}
@Override
public Iterable<String> getChildrenNames() throws IOException {
return getConnection().getAvailableTasks(getParent().getName());
}
@Override
public Resource getChild(String name) throws IOException {
if (Resource.PARENT.equals(name)) {
return parent;
} else if (getConnection().getAvailableTasks(getParent().getName()).contains(name)) {
return new TaskResource(this, name);
} else {
throw Messages.MSG.noSuchResource(name);
}
}
@Override
public String describe() {
return NAME;
}
}
| 959
| 23.615385
| 91
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/CachesResource.java
|
package org.infinispan.cli.resources;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CachesResource extends AbstractResource {
public static final String NAME = "caches";
protected CachesResource(Resource parent) {
super(parent, NAME);
}
@Override
public Iterable<String> getChildrenNames() {
return getConnection().getAvailableCaches(getParent().getName());
}
@Override
public Resource getChild(String name) {
if (Resource.PARENT.equals(name)) {
return parent;
} else if (getConnection().getAvailableCaches(getParent().getName()).contains(name)) {
return new CacheResource(this, name);
} else {
throw Messages.MSG.noSuchResource(name);
}
}
}
| 830
| 24.96875
| 92
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/AbstractResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
import java.util.Collections;
import java.util.Iterator;
import java.util.Optional;
import org.aesh.command.shell.Shell;
import org.infinispan.cli.connection.Connection;
import org.infinispan.cli.logging.Messages;
import org.infinispan.cli.printers.DefaultRowPrinter;
import org.infinispan.cli.printers.PrettyPrinter;
import org.infinispan.cli.printers.PrettyRowPrinter;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public abstract class AbstractResource implements Resource {
final Resource parent;
final String name;
protected AbstractResource(Resource parent, String name) {
this.parent = parent;
this.name = name;
}
@Override
public String getName() {
return name;
}
@Override
public Resource getParent() {
return parent;
}
@Override
public Iterable<String> getChildrenNames() throws IOException {
return Collections.emptyList();
}
public void printChildren(ListFormat format, int limit, PrettyPrinter.PrettyPrintMode prettyPrintMode, Shell shell) throws IOException {
Iterator<String> it = getChildrenNames().iterator();
PrettyRowPrinter rowPrinter = new DefaultRowPrinter(shell.size().getWidth(), 1);
try(PrettyPrinter printer = PrettyPrinter.forMode(prettyPrintMode, shell, rowPrinter)) {
printer.print(it);
}
}
@Override
public Resource getChild(String name) throws IOException {
if (Resource.PARENT.equals(name) && parent != null) {
return parent;
} else {
throw Messages.MSG.noSuchResource(name);
}
}
@Override
public Resource getChild(String... name) throws IOException {
if (name.length == 1) {
return getChild(name[0]);
} else {
String[] children = new String[name.length - 1];
System.arraycopy(name, 1, children, 0, name.length - 1);
return getChild(name[0]).getChild(children);
}
}
@Override
public <T extends Resource> T findAncestor(Class<T> resourceClass) {
return optionalFindAncestor(resourceClass).orElseThrow(Messages.MSG::illegalContext);
}
@Override
public <T extends Resource> Optional<T> optionalFindAncestor(Class<T> resourceClass) {
if (resourceClass.isAssignableFrom(this.getClass())) {
return Optional.of(resourceClass.cast(this));
} else if (parent != null) {
return parent.optionalFindAncestor(resourceClass);
} else {
return Optional.empty();
}
}
@Override
public boolean isLeaf() {
return false;
}
@Override
public String describe() throws IOException {
return name;
}
Connection getConnection() {
return findAncestor(RootResource.class).getConnection();
}
@Override
public Resource getResource(String path) throws IOException {
if (path == null || Resource.THIS.equals(path)) {
return this;
} else if (Resource.PARENT.equals(path)) {
Resource parent = getParent();
if (parent != null) {
return parent;
} else {
throw Messages.MSG.illegalContext();
}
} else {
String[] parts = path.split("/");
if (parts.length == 0) {
return findAncestor(RootResource.class);
} else {
Resource resource = this;
for (String part : parts) {
if (part.isEmpty()) {
resource = resource.findAncestor(RootResource.class);
} else {
resource = resource.getChild(part);
}
}
return resource;
}
}
}
}
| 3,738
| 27.761538
| 139
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/Resource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
import java.util.Optional;
import org.aesh.command.shell.Shell;
import org.infinispan.cli.connection.Connection;
import org.infinispan.cli.printers.PrettyPrinter;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public interface Resource {
enum ListFormat {
NAMES,
VALUES,
FULL
}
String THIS = ".";
String PARENT = "..";
/**
* Returns the name of this resource
*/
String getName();
/**
* Returns the parent resource of this resource. This is null if the resource represents the root.
*/
Resource getParent();
/**
* Returns an iterable over the children of this resource
*/
Iterable<String> getChildrenNames() throws IOException;
void printChildren(ListFormat format, int limit, PrettyPrinter.PrettyPrintMode prettyPrintMode, Shell shell) throws IOException;
/**
* Returns a resource representing the named child
*/
Resource getChild(String name) throws IOException;
/**
* Returns a resource representing the named child
*/
Resource getChild(String... name) throws IOException;
/**
* Finds the resource of the specified type within the ancestors of this resource
*/
<T extends Resource> T findAncestor(Class<T> resourceClass);
/**
* Finds the resource of the specified type within the ancestors of this resource
*/
<T extends Resource> Optional<T> optionalFindAncestor(Class<T> resourceClass);
/**
* Returns whether this resource is a leaf resource (i.e. it has no children, or the children are not navigable)
*/
boolean isLeaf();
/**
* Returns a textual representation of this resource
*/
String describe() throws IOException;
/**
* Returns a root resource configured against the supplied configuration
*/
static Resource getRootResource(Connection connection) {
return new RootResource(connection);
}
Resource getResource(String path) throws IOException;
}
| 2,059
| 24.432099
| 131
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/SchemasResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
import org.infinispan.cli.logging.Messages;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class SchemasResource extends AbstractResource {
public static final String NAME = "schemas";
protected SchemasResource(Resource parent) {
super(parent, NAME);
}
@Override
public Iterable<String> getChildrenNames() throws IOException {
return getConnection().getAvailableSchemas(getParent().getName());
}
@Override
public Resource getChild(String name) {
if (Resource.PARENT.equals(name)) {
return parent;
} else {
throw Messages.MSG.noSuchResource(name);
}
}
@Override
public boolean isLeaf() {
return true;
}
@Override
public String describe() throws IOException {
return NAME;//TODO
}
}
| 902
| 20.5
| 72
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/ConfigurationsResource.java
|
package org.infinispan.cli.resources;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ConfigurationsResource extends AbstractResource {
static final String NAME = "configurations";
protected ConfigurationsResource(Resource parent) {
super(parent, NAME);
}
}
| 322
| 22.071429
| 62
|
java
|
null |
infinispan-main/cli/src/main/java/org/infinispan/cli/resources/CacheKeyResource.java
|
package org.infinispan.cli.resources;
import java.io.IOException;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class CacheKeyResource extends AbstractResource {
public CacheKeyResource(CacheResource parent, String name) {
super(parent, name);
}
@Override
public boolean isLeaf() {
return true;
}
@Override
public String describe() throws IOException {
return getConnection().describeKey(getParent().getParent().getName(), getParent().getName(), name);
}
}
| 546
| 21.791667
| 105
|
java
|
null |
infinispan-main/graalvm/core/src/test/java/org/infinispan/integrationtests/graalvm/core/EmbeddedTest.java
|
package org.infinispan.integrationtests.graalvm.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import java.util.ArrayList;
import java.util.List;
import org.infinispan.Cache;
import org.infinispan.commons.test.TestResourceTracker;
import org.infinispan.configuration.cache.CacheMode;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.junit.jupiter.api.Test;
public class EmbeddedTest {
@Test
public void programmaticCacheTest() throws Exception {
try (EmbeddedCacheManager cm = new DefaultCacheManager()) {
Cache<String, String> cache = cm.createCache("local-cache", new ConfigurationBuilder().build());
testCacheOperations(cache);
}
}
@Test
public void xmlConfigTest() throws Exception {
try (EmbeddedCacheManager cm = new DefaultCacheManager("embedded.xml")) {
for (String cacheName : cm.getCacheNames()) {
Cache<String, String> cache = cm.getCache(cacheName);
testCacheOperations(cache);
}
}
}
@Test
public void clusteredCacheTest() {
TestResourceTracker.setThreadTestName("clusteredCacheTest");
ConfigurationBuilder config = new ConfigurationBuilder();
config.clustering().cacheMode(CacheMode.DIST_SYNC);
List<EmbeddedCacheManager> cacheManagers = new ArrayList<>(3);
List<Cache<String, String>> caches = new ArrayList<>(3);
for (int i = 0; i < 3; i++) {
EmbeddedCacheManager cm = TestCacheManagerFactory.createClusteredCacheManager(config);
cacheManagers.add(cm);
caches.add(cm.getCache());
}
TestingUtil.blockUntilViewsReceived(30000, caches);
TestingUtil.waitForNoRebalance(caches);
Cache<String, String> cache = caches.get(0);
testCacheOperations(cache);
}
private void testCacheOperations(Cache<String, String> cache) {
String cacheName = cache.getName();
String key = "1";
cache.put(key, "1");
assertEquals(1, cache.size(), cacheName);
assertEquals("1", cache.get(key), cacheName);
assertEquals("1", cache.remove(key), cacheName);
assertNull(cache.get(key), cacheName);
}
}
| 2,449
| 34.507246
| 105
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/NativeMetadataProvider.java
|
package org.infinispan.graalvm;
import static org.infinispan.commons.configuration.io.xml.XmlPullParser.END_DOCUMENT;
import static org.infinispan.commons.configuration.io.xml.XmlPullParser.END_TAG;
import static org.infinispan.commons.configuration.io.xml.XmlPullParser.FEATURE_PROCESS_NAMESPACES;
import static org.infinispan.commons.configuration.io.xml.XmlPullParser.START_TAG;
import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Stream;
import org.graalvm.nativeimage.hosted.Feature;
import org.infinispan.commons.configuration.io.xml.MXParser;
import org.infinispan.commons.configuration.io.xml.XmlPullParser;
import org.infinispan.commons.configuration.io.xml.XmlPullParserException;
import org.infinispan.commons.graalvm.Bundle;
import org.infinispan.commons.graalvm.ClassLoaderFeatureAccess;
import org.infinispan.commons.graalvm.Jandex;
import org.infinispan.commons.graalvm.ReflectionProcessor;
import org.infinispan.commons.graalvm.ReflectiveClass;
import org.infinispan.commons.graalvm.Resource;
import org.infinispan.commons.marshall.SerializeWith;
import org.infinispan.configuration.serializing.SerializedWith;
import org.infinispan.marshall.exts.CollectionExternalizer;
import org.infinispan.marshall.exts.EnumExternalizer;
import org.infinispan.marshall.exts.EnumSetExternalizer;
import org.infinispan.marshall.exts.MapExternalizer;
import org.infinispan.notifications.Listener;
import org.jboss.jandex.IndexView;
import org.jgroups.Version;
import org.jgroups.conf.ClassConfigurator;
public class NativeMetadataProvider implements org.infinispan.commons.graalvm.NativeMetadataProvider {
static final Collection<Resource> resourceFiles = Resource.of(
"META-INF/services/org\\.infinispan\\.configuration\\.parsing\\.ConfigurationParser",
"META-INF/services/org\\.infinispan\\.factories\\.impl\\.ModuleMetadataBuilder",
"META-INF/infinispan-version\\.properties",
"org/infinispan/protostream/message-wrapping\\.proto",
"protostream/common-java-types\\.proto",
"protostream/common-java-container-types\\.proto",
"proto/generated/user\\.commons\\.proto",
"proto/generated/persistence\\.commons\\.proto",
"proto/generated/persistence\\.core\\.proto",
"proto/generated/global\\.commons\\.proto",
"default-configs/default-jgroups-udp\\.xml",
"default-configs/default-jgroups-tcp\\.xml",
"default-configs/default-jgroups-kubernetes\\.xml",
"default-configs/default-jgroups-ec2\\.xml",
"default-configs/default-jgroups-google\\.xml",
"default-configs/default-jgroups-azure\\.xml",
ClassConfigurator.MAGIC_NUMBER_FILE,
ClassConfigurator.PROTOCOL_ID_FILE,
Version.VERSION_FILE
);
static final Collection<Resource> resourceRegexps = Resource.of();
static final Collection<Bundle> bundles = Bundle.of(
"jg-messages",
"java.base:sun.security.util.Resources",
"com.sun.org.apache.xerces.internal.impl.msg.XMLMessages"
);
final Feature.FeatureAccess featureAccess;
final ReflectionProcessor reflection;
public NativeMetadataProvider() {
this(new ClassLoaderFeatureAccess(NativeMetadataProvider.class.getClassLoader()));
}
public NativeMetadataProvider(Feature.FeatureAccess featureAccess) {
this.featureAccess = featureAccess;
this.reflection = reflectionProcessor();
}
@Override
public Stream<ReflectiveClass> reflectiveClasses() {
return reflection.classes();
}
@Override
public Stream<Resource> includedResources() {
return Stream.of(
resourceFiles.stream(),
resourceRegexps.stream()
).flatMap(Function.identity());
}
@Override
public Stream<Bundle> bundles() {
return bundles.stream();
}
private ReflectionProcessor reflectionProcessor() {
IndexView index = Jandex.createIndex(
com.github.benmanes.caffeine.cache.Cache.class, // Caffeine
org.jgroups.stack.Protocol.class, // JGroups
org.infinispan.protostream.GeneratedSchema.class, // ProtoStream
org.infinispan.commons.CacheException.class, // Commons
org.infinispan.AdvancedCache.class // Core
);
ReflectionProcessor reflection = new ReflectionProcessor(featureAccess, index);
caffeine(reflection);
jgroups(reflection);
infinispan(reflection);
return reflection;
}
private void caffeine(ReflectionProcessor processor) {
processor.addClasses(
"com.github.benmanes.caffeine.cache.PDMS",
"com.github.benmanes.caffeine.cache.PSA",
"com.github.benmanes.caffeine.cache.PSMS",
"com.github.benmanes.caffeine.cache.PSW",
"com.github.benmanes.caffeine.cache.PSMW",
"com.github.benmanes.caffeine.cache.PSAMW",
"com.github.benmanes.caffeine.cache.PSAWMW",
"com.github.benmanes.caffeine.cache.PSWMS",
"com.github.benmanes.caffeine.cache.PSWMW",
"com.github.benmanes.caffeine.cache.SILMS",
"com.github.benmanes.caffeine.cache.SSA",
"com.github.benmanes.caffeine.cache.SSLA",
"com.github.benmanes.caffeine.cache.SSLMS",
"com.github.benmanes.caffeine.cache.SSLMW",
"com.github.benmanes.caffeine.cache.SSMS",
"com.github.benmanes.caffeine.cache.SSMSA",
"com.github.benmanes.caffeine.cache.SSMSAW",
"com.github.benmanes.caffeine.cache.SSMSW",
"com.github.benmanes.caffeine.cache.SSW"
);
}
private void jgroups(ReflectionProcessor processor) {
processor
.addClasses(
org.jgroups.blocks.RequestCorrelator.class,
org.jgroups.protocols.MsgStats.class,
org.jgroups.protocols.raft.AppendEntriesResponse.class,
org.jgroups.tests.perf.MPerf.class,
org.jgroups.util.Util.AddressScope.class,
org.jgroups.Version.class
)
.addClasses(true, true,
org.jgroups.protocols.MsgStats.class,
org.jgroups.protocols.raft.AppendEntriesRequest.class,
org.jgroups.stack.DiagnosticsHandler.class,
org.jgroups.util.ThreadPool.class
).addImplementations(false, false,
org.jgroups.conf.PropertyConverter.class,
org.jgroups.protocols.LocalTransport.class,
org.jgroups.stack.MessageProcessingPolicy.class
).addImplementations(true, false,
org.jgroups.protocols.Bundler.class,
org.jgroups.stack.Protocol.class
);
processor.addClasses(jgroupsClasses().toArray(new String[0]));
}
private Collection<String> jgroupsClasses() {
Set<String> classes = new HashSet<>();
try (InputStream source = org.jgroups.Message.class.getClassLoader().getResourceAsStream(ClassConfigurator.MAGIC_NUMBER_FILE)) {
MXParser reader = new MXParser();
reader.setFeature(FEATURE_PROCESS_NAMESPACES, false);
reader.setInput(source, null);
int eventType;
while ((eventType = reader.next()) != END_DOCUMENT) {
if (eventType == START_TAG) {
if (reader.getName().equals("magic-number-class-mapping")) {
parseJGroupsMagicNumbers(reader, classes);
}
}
}
} catch (IOException e) {
throw new RuntimeException(e);
}
return classes;
}
private void parseJGroupsMagicNumbers(XmlPullParser reader, Set<String> classes) throws XmlPullParserException, IOException {
int eventType;
while ((eventType = reader.nextTag()) != END_DOCUMENT) {
switch (eventType) {
case END_TAG: {
return;
}
case START_TAG: {
if (reader.getName().equals("class")) {
String clazz = reader.getAttributeValue(null, "name");
classes.add(clazz);
reader.next();
continue;
}
throw new IOException("Unexpected content");
}
default: {
throw new IOException("Unexpected content");
}
}
}
throw new IOException("Unexpected end of document");
}
private void infinispan(ReflectionProcessor processor) {
processor
.addClasses(
org.infinispan.CoreModuleImpl.class,
org.infinispan.distribution.ch.impl.HashFunctionPartitioner.class,
org.infinispan.distribution.ch.impl.CRC16HashFunctionPartitioner.class,
org.infinispan.notifications.cachelistener.annotation.CacheEntryCreated.class,
org.infinispan.notifications.cachelistener.annotation.CacheEntryExpired.class,
org.infinispan.notifications.cachelistener.annotation.CacheEntryModified.class,
org.infinispan.notifications.cachelistener.annotation.CacheEntryRemoved.class,
org.infinispan.remoting.transport.jgroups.JGroupsTransport.class,
org.infinispan.transaction.lookup.EmbeddedTransactionManagerLookup.class
)
.addImplementations(false, false,
org.jboss.logging.BasicLogger.class,
org.infinispan.commons.marshall.AbstractExternalizer.class,
org.infinispan.commons.marshall.AdvancedExternalizer.class,
org.infinispan.configuration.parsing.ConfigurationParser.class,
org.infinispan.configuration.cache.AbstractModuleConfigurationBuilder.class,
org.infinispan.configuration.cache.StoreConfigurationBuilder.class,
org.infinispan.configuration.serializing.ConfigurationSerializer.class,
org.infinispan.distribution.ch.ConsistentHashFactory.class,
org.infinispan.factories.impl.ModuleMetadataBuilder.class,
org.infinispan.persistence.spi.NonBlockingStore.class,
org.infinispan.persistence.spi.CacheLoader.class,
org.infinispan.persistence.spi.CacheWriter.class
)
.addImplementations(true, false,
org.infinispan.util.logging.events.Messages.class,
org.infinispan.interceptors.AsyncInterceptor.class
)
.addImplementation(false, true,
org.infinispan.configuration.cache.StoreConfiguration.class
)
.addClassesWithAnnotation(false, true, Listener.class)
.addClassFromAnnotationValue(false, false, SerializeWith.class)
.addClassFromAnnotationValue(false, false, SerializedWith.class)
.addClasses("org.infinispan.remoting.transport.jgroups.JGroupsTransport$ChannelCallbacks")
.addClasses(
// XML parsing
"com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl",
"com.sun.org.apache.xerces.internal.jaxp.datatype.DatatypeFactoryImpl",
"com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl",
"com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl"
);
CollectionExternalizer.getSupportedPrivateClasses().forEach(processor::addClasses);
MapExternalizer.getSupportedPrivateClasses().forEach(processor::addClasses);
EnumExternalizer.INSTANCE.getTypeClasses().forEach(processor::addClasses);
new EnumSetExternalizer().getTypeClasses().forEach(processor::addClasses);
}
}
| 11,930
| 44.365019
| 134
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/Feature.java
|
package org.infinispan.graalvm;
import org.infinispan.commons.graalvm.ReflectiveClass;
public class Feature implements org.graalvm.nativeimage.hosted.Feature {
public void beforeAnalysis(org.graalvm.nativeimage.hosted.Feature.BeforeAnalysisAccess beforeAnalysis) {
new NativeMetadataProvider(beforeAnalysis)
.reflectiveClasses()
.forEach(ReflectiveClass::register);
}
@Override
public String getDescription() {
return "Infinispan Embedded static reflection registrations for GraalVM";
}
}
| 544
| 29.277778
| 107
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/substitutions/graal/SubstituteReflectionBasedClasses.java
|
package org.infinispan.graalvm.substitutions.graal;
import org.infinispan.commons.util.Util;
import org.infinispan.transaction.lookup.JBossStandaloneJTAManagerLookup;
import com.oracle.svm.core.annotate.Alias;
import com.oracle.svm.core.annotate.Substitute;
import com.oracle.svm.core.annotate.TargetClass;
public class SubstituteReflectionBasedClasses {
}
@TargetClass(Util.class)
final class SubstituteUtil {
@Substitute
public static <T> T getInstance(String classname, ClassLoader cl) {
if (classname == null)
throw new IllegalArgumentException("Cannot load null class!");
switch (classname) {
case "org.infinispan.transaction.lookup.JBossStandaloneJTAManagerLookup":
return (T) new JBossStandaloneJTAManagerLookup();
default:
Class<T> clazz = loadClass(classname, cl);
return getInstance(clazz);
}
}
@Alias
public static <T> Class<T> loadClass(String classname, ClassLoader cl) {
return null;
}
@Alias
public static <T> T getInstance(Class<T> clazz) {
return null;
}
}
| 1,140
| 29.026316
| 85
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/substitutions/graal/JChannelSubstitutions.java
|
package org.infinispan.graalvm.substitutions.graal;
import org.jgroups.Address;
import com.oracle.svm.core.annotate.Substitute;
import com.oracle.svm.core.annotate.TargetClass;
/**
* These substitutions need to be revisited on each new Quarkus/GraalVM release, as some methods may become
* supported.
*
* @author Bela Ban
* @since 1.0.0
*/
class JChannelSubstitutions {
}
@TargetClass(className = "org.jgroups.protocols.VERIFY_SUSPECT")
final class Target_org_jgroups_protocols_VERIFY_SUSPECT {
@Substitute
protected void verifySuspectWithICMP(Address suspected_mbr) {
throw Util.unsupportedOperationException("VERIFY_SUSPECT Protocol");
}
}
| 673
| 24.923077
| 107
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/substitutions/graal/SubstituteJGroups.java
|
package org.infinispan.graalvm.substitutions.graal;
import com.oracle.svm.core.annotate.Alias;
import com.oracle.svm.core.annotate.RecomputeFieldValue;
import com.oracle.svm.core.annotate.Substitute;
import com.oracle.svm.core.annotate.TargetClass;
import org.jgroups.JChannel;
import org.jgroups.protocols.DELAY;
import org.jgroups.util.Util;
import java.util.Random;
public class SubstituteJGroups {
}
@TargetClass(DELAY.class)
final class SubstitueDELAY {
@Alias
// Force it to null - so it can be reinitialized
@RecomputeFieldValue(kind = RecomputeFieldValue.Kind.Reset)
protected static volatile Random randomNumberGenerator;
}
// DISCARD protocol uses swing classes
@TargetClass(className = "org.jgroups.protocols.DISCARD")
final class SubstituteDiscardProtocol {
@Substitute
public void startGui() {
// do nothing
}
@Substitute
public void stopGui() {
// do nothing
}
@Substitute
public void start() throws Exception {
// should call super.start() but the "super" Protocol.start() does nothing,
// so this empty impl is OK
}
@Substitute
public void stop() {
// should call super.stop() but the "super" Protocol.stop() does nothing,
// so this empty impl is OK
}
}
@TargetClass(Util.class)
final class SubstituteJgroupsUtil {
@Substitute
public static void registerChannel(JChannel channel, String name) {
// do nothing
}
}
| 1,474
| 23.583333
| 83
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/substitutions/graal/FixJMXClasses.java
|
package org.infinispan.graalvm.substitutions.graal;
import javax.management.MBeanServer;
import javax.management.ObjectName;
import org.infinispan.commons.configuration.io.ConfigurationReader;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.configuration.global.GlobalJmxStatisticsConfiguration;
import org.infinispan.configuration.parsing.CacheParser;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.configuration.parsing.Element;
import org.infinispan.configuration.parsing.Parser;
import org.infinispan.factories.GlobalComponentRegistry;
import com.oracle.svm.core.annotate.Substitute;
import com.oracle.svm.core.annotate.TargetClass;
public class FixJMXClasses {
}
@TargetClass(GlobalComponentRegistry.class)
final class SubstituteGlobalComponentRegistry {
@Substitute
private boolean isMBeanServerRunning() {
return false;
}
@Substitute
protected synchronized void addShutdownHook() {
// Don't install any shutdown hook
}
}
@TargetClass(Parser.class)
final class SubstituteParser {
@Substitute
private void parseJmx(ConfigurationReader reader, ConfigurationBuilderHolder holder) {
// Ignore JMX configuration - but we need to skip to next element
CacheParser.parseProperties(reader, Element.JMX);
}
}
@TargetClass(GlobalConfiguration.class)
final class SubstituteGlobalConfiguration {
@Substitute
public boolean statistics() {
return false;
}
}
@TargetClass(GlobalJmxStatisticsConfiguration.class)
final class SubstituteGlobalJmxStatisticsConfiguration {
@Substitute
public boolean enabled() {
return false;
}
}
@TargetClass(className = "org.infinispan.jmx.AbstractJmxRegistration")
final class SubstituteAbstractJmxRegistration {
@Substitute
public void start() {
// Do nothing
}
@Substitute
public void stop() {
// Do nothing
}
@Substitute
public final String getDomain() {
return "";
}
@Substitute
public final String getGroupName() {
return "";
}
@Substitute
public final MBeanServer getMBeanServer() {
return null;
}
@Substitute
public ObjectName registerExternalMBean(Object managedComponent, String groupName) throws Exception {
return null;
}
@Substitute
public void registerMBean(Object managedComponent) throws Exception {
// Do nothing
}
@Substitute
public void registerMBean(Object managedComponent, String groupName) throws Exception {
// Do nothing
}
@Substitute
public void unregisterMBean(ObjectName objectName) throws Exception {
// Do nothing
}
}
| 2,760
| 25.04717
| 105
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/substitutions/graal/SubstituteTransactionClasses.java
|
package org.infinispan.graalvm.substitutions.graal;
import org.infinispan.commons.tx.lookup.TransactionManagerLookup;
import org.infinispan.configuration.global.GlobalConfiguration;
import org.infinispan.transaction.lookup.JBossStandaloneJTAManagerLookup;
import com.oracle.svm.core.annotate.Substitute;
import com.oracle.svm.core.annotate.TargetClass;
import jakarta.transaction.TransactionManager;
import jakarta.transaction.UserTransaction;
public class SubstituteTransactionClasses {
}
@TargetClass(JBossStandaloneJTAManagerLookup.class)
@Substitute
final class SubstituteJBossStandaloneJTAManagerLookup implements TransactionManagerLookup {
@Substitute
public SubstituteJBossStandaloneJTAManagerLookup() {
}
@Substitute
public void init(GlobalConfiguration globalCfg) {
}
@Substitute
public void init(ClassLoader configuration) {
}
@Override
@Substitute
public TransactionManager getTransactionManager() {
return com.arjuna.ats.jta.TransactionManager.transactionManager();
}
@Substitute
public UserTransaction getUserTransaction() {
return com.arjuna.ats.jta.UserTransaction.userTransaction();
}
@Substitute
public String toString() {
return "JBossStandaloneJTAManagerLookup";
}
}
| 1,296
| 26.595745
| 91
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/substitutions/graal/SubstituteCallerId.java
|
package org.infinispan.graalvm.substitutions.graal;
import org.infinispan.commons.jdkspecific.CallerId;
import com.oracle.svm.core.annotate.Substitute;
import com.oracle.svm.core.annotate.TargetClass;
import org.infinispan.commons.util.Version;
/**
* Both variations using a security manager or using Reflection class require loading up JNI
*/
@TargetClass(CallerId.class)
@Substitute
public final class SubstituteCallerId {
@Substitute
public static Class<?> getCallerClass(int n) {
// Can't figure out how to make sure security is working properly - so just passing back a class that is known to be good
return Version.class;
}
}
| 666
| 29.318182
| 129
|
java
|
null |
infinispan-main/graalvm/core/src/main/java/org/infinispan/graalvm/substitutions/graal/Util.java
|
package org.infinispan.graalvm.substitutions.graal;
public class Util {
public static UnsupportedOperationException unsupportedOperationException(String feature) {
return unsupportedOperationException(feature, "");
}
public static UnsupportedOperationException unsupportedOperationException(String feature, String explanation) {
return new UnsupportedOperationException(String.format("'%s'is not supported in native runtime!%s", feature, explanation));
}
}
| 483
| 39.333333
| 129
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/NativeMetadataWriter.java
|
package org.infinispan.commons.graalvm;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
public class NativeMetadataWriter {
public static void main(String[] args) throws Exception {
if (args.length == 0)
throw new IllegalArgumentException(String.format("FQN of '%s' implementation must be provided as the first arg", NativeMetadataProvider.class));
NativeMetadataProvider metadata = ((Class<NativeMetadataProvider>) Class.forName(args[0])).getConstructor().newInstance();
String rootDir = args.length > 1 ? args[1] : "";
Files.createDirectories(Paths.get(rootDir));
Json reflection = array(metadata.reflectiveClasses());
Json resource = Json.object()
.set("resources",
Json.object().set("includes", array(metadata.includedResources()))
)
.set("bundles",
array(metadata.bundles())
);
Files.writeString(Paths.get(rootDir, "reflection-config.json"), reflection.toPrettyString());
Files.writeString(Paths.get(rootDir, "resource-config.json"), resource.toPrettyString());
}
private static Json array(Stream<? extends JsonSerialization> stream) {
return Json.make(
stream
.map(JsonSerialization::toJson)
.collect(Collectors.toList())
);
}
}
| 1,565
| 36.285714
| 153
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/ReflectionProcessor.java
|
package org.infinispan.commons.graalvm;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.graalvm.nativeimage.hosted.Feature;
import org.jboss.jandex.AnnotationInstance;
import org.jboss.jandex.AnnotationTarget;
import org.jboss.jandex.ClassInfo;
import org.jboss.jandex.DotName;
import org.jboss.jandex.IndexView;
public class ReflectionProcessor {
final Feature.FeatureAccess featureAccess;
final IndexView index;
final List<ReflectiveClass> reflectiveClasses;
public ReflectionProcessor(Feature.FeatureAccess featureAccess, IndexView index) {
this.featureAccess = featureAccess;
this.index = index;
this.reflectiveClasses = new ArrayList<>();
}
public ReflectionProcessor addClasses(Class<?>... classes) {
return addClasses(false, false, classes);
}
public ReflectionProcessor addClasses(boolean fields, boolean methods, Class<?>... classes) {
reflectiveClasses.addAll(
Arrays.stream(classes)
.map(c -> ReflectiveClass.of(c, fields, methods))
.collect(Collectors.toList())
);
return this;
}
public ReflectionProcessor addClasses(String... classes) {
return addClasses(false, false, classes);
}
public ReflectionProcessor addClasses(boolean fields, boolean methods, String... classes) {
reflectiveClasses.addAll(
Arrays.stream(classes)
.map(featureAccess::findClassByName)
.map(c -> ReflectiveClass.of(c, fields, methods))
.collect(Collectors.toList())
);
return this;
}
public ReflectionProcessor addClassesWithAnnotation(boolean fields, boolean methods, Class<?> annotation) {
return forEachAnnotation(annotation, instance -> {
AnnotationTarget target = instance.target();
if (target.kind() == AnnotationTarget.Kind.CLASS) {
DotName targetName = target.asClass().name();
addClasses(fields, methods, targetName.toString());
}
});
}
public ReflectionProcessor addClassFromAnnotationValue(boolean fields, boolean methods, Class<?> annotation) {
return forEachAnnotation(annotation, instance -> {
String className = instance.value().asString();
addClasses(fields, methods, className);
});
}
public ReflectionProcessor forEachAnnotation(Class<?> annotation, Consumer<AnnotationInstance> consumer) {
if (!annotation.isAnnotation())
throw new IllegalArgumentException("Provided class must be an annotation");
index.getAnnotations(
DotName.createSimple(annotation.getName())
).forEach(consumer);
return this;
}
public ReflectionProcessor addImplementation(boolean fields, boolean methods, String className) {
return addImplementations(fields, methods, featureAccess.findClassByName(className));
}
public ReflectionProcessor addImplementation(boolean fields, boolean methods, Class<?> clazz) {
Collection<ClassInfo> classInfos;
if (clazz.isInterface()) {
classInfos = index.getAllKnownImplementors(DotName.createSimple(clazz.getName()));
} else {
classInfos = index.getAllKnownSubclasses(DotName.createSimple(clazz.getName()));
}
classInfos.stream()
.map(ClassInfo::toString)
.forEach(c -> addClasses(fields, methods, c));
return this;
}
public ReflectionProcessor addImplementations(boolean fields, boolean methods, String... classes) {
for (String clazz : classes)
addImplementation(fields, methods, clazz);
return this;
}
public ReflectionProcessor addImplementations(boolean fields, boolean methods, Class<?>... classes) {
for (Class<?> clazz : classes)
addImplementation(fields, methods, clazz);
return this;
}
public Stream<ReflectiveClass> classes() {
return reflectiveClasses.stream();
}
}
| 4,120
| 33.630252
| 113
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/ClassLoaderFeatureAccess.java
|
package org.infinispan.commons.graalvm;
import java.nio.file.Path;
import java.util.List;
import org.graalvm.nativeimage.hosted.Feature;
public class ClassLoaderFeatureAccess implements Feature.FeatureAccess {
private final ClassLoader cl;
public ClassLoaderFeatureAccess(ClassLoader cl) {
this.cl = cl;
}
@Override
public Class<?> findClassByName(String className) {
try {
return Class.forName(className, false, cl);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
}
@Override
public List<Path> getApplicationClassPath() {
throw new IllegalStateException();
}
@Override
public List<Path> getApplicationModulePath() {
throw new IllegalStateException();
}
@Override
public ClassLoader getApplicationClassLoader() {
return cl;
}
}
| 865
| 20.65
| 72
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/Bundle.java
|
package org.infinispan.commons.graalvm;
import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Collectors;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
public class Bundle implements JsonSerialization {
public static Collection<Bundle> of(String... bundleName) {
return Arrays.stream(bundleName)
.map(Bundle::new)
.collect(Collectors.toList());
}
private final String name;
public Bundle(String name) {
this.name = name;
}
@Override
public Json toJson() {
return Json.object().set("name", name);
}
}
| 684
| 22.62069
| 72
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/NativeMetadataProvider.java
|
package org.infinispan.commons.graalvm;
import java.util.stream.Stream;
public interface NativeMetadataProvider {
default Stream<ReflectiveClass> reflectiveClasses() {
return Stream.empty();
}
default Stream<Resource> includedResources() {
return Stream.empty();
}
default Stream<Bundle> bundles() {
return Stream.empty();
}
}
| 366
| 20.588235
| 56
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/ReflectiveClass.java
|
package org.infinispan.commons.graalvm;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import org.graalvm.nativeimage.hosted.RuntimeReflection;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
public class ReflectiveClass implements JsonSerialization {
final Class<?> clazz;
final Constructor<?>[] constructors;
final Field[] fields;
final Method[] methods;
public static ReflectiveClass of(Class<?> clazz) {
return ReflectiveClass.of(clazz, false, false);
}
public static ReflectiveClass of(Class<?> clazz, boolean allFields, boolean allMethods) {
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
Field[] fields = allFields ? getAllFields(clazz) : new Field[0];
Method[] methods = allMethods ? getAllMethods(clazz) : new Method[0];
return new ReflectiveClass(clazz, constructors, fields, methods);
}
private static Field[] getAllFields(Class<?> type) {
List<Field> fields = new ArrayList<>();
fields.addAll(Arrays.asList(type.getDeclaredFields()));
return fields.toArray(new Field[0]);
}
private static Method[] getAllMethods(Class<?> type) {
List<Method> methods = new ArrayList<>();
methods.addAll(Arrays.asList(type.getDeclaredMethods()));
return methods.toArray(new Method[0]);
}
public ReflectiveClass(Class<?> clazz, Constructor<?>[] constructors, Field[] fields, Method[] methods) {
this.clazz = clazz;
this.constructors = constructors;
this.fields = fields;
this.methods = methods;
}
public void register() {
RuntimeReflection.register(clazz);
RuntimeReflection.register(constructors);
RuntimeReflection.register(fields);
RuntimeReflection.register(methods);
}
public Json toJson() {
Json j = Json.object();
j.set("name", clazz.getName());
if (fields.length > 0) {
j.set("fields", Json.make(
Arrays.stream(fields)
.map(f -> Json.object().set("name", f.getName()))
.collect(Collectors.toList())
));
}
if (constructors.length > 0 || methods.length > 0) {
Json methodArray = Json.array();
for (Constructor<?> c : constructors) {
methodArray.add(
Json.object()
.set("name", "<init>")
.set("parameterTypes", Json.make(
Arrays.stream(c.getParameterTypes())
.map(Class::getName)
.collect(Collectors.toList())
))
);
}
for (Method m : methods) {
methodArray.add(
Json.object()
.set("name", m.getName())
.set("parameterTypes", Json.make(
Arrays.stream(m.getParameterTypes())
.map(Class::getName)
.collect(Collectors.toList())
))
);
}
j.set("methods", methodArray);
}
return j;
}
}
| 3,432
| 33.33
| 108
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/Resource.java
|
package org.infinispan.commons.graalvm;
import java.util.Arrays;
import java.util.Collection;
import java.util.stream.Collectors;
import org.infinispan.commons.dataconversion.internal.Json;
import org.infinispan.commons.dataconversion.internal.JsonSerialization;
public class Resource implements JsonSerialization {
public static Collection<Resource> of(String... files) {
return Arrays.stream(files)
.map(Resource::new)
.collect(Collectors.toList());
}
final String pattern;
public Resource(String pattern) {
this.pattern = pattern;
}
@Override
public Json toJson() {
return Json.object().set("pattern", pattern);
}
}
| 692
| 22.896552
| 72
|
java
|
null |
infinispan-main/graalvm/commons/src/main/java/org/infinispan/commons/graalvm/Jandex.java
|
package org.infinispan.commons.graalvm;
import java.io.File;
import java.io.IOException;
import java.security.CodeSource;
import java.util.Arrays;
import org.jboss.jandex.CompositeIndex;
import org.jboss.jandex.IndexView;
import org.jboss.jandex.Indexer;
import org.jboss.jandex.JarIndexer;
public class Jandex {
public static IndexView createIndex(File jar) {
Indexer indexer = new Indexer();
try {
return JarIndexer.createJarIndex(jar, indexer, false, false, false).getIndex();
} catch (IOException e) {
throw new IllegalStateException(String.format("Unable to create Jandex index for '%s'", jar), e);
}
}
public static IndexView createIndex(CodeSource codeSource) {
String jarPath = codeSource.getLocation().getFile();
return createIndex(new File(jarPath));
}
public static IndexView createIndex(Class<?>... classes) {
return CompositeIndex.create(
Arrays.stream(classes)
.map(c -> c.getProtectionDomain().getCodeSource())
.map(Jandex::createIndex)
.toArray(IndexView[]::new)
);
}
}
| 1,142
| 29.891892
| 106
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/TestsModule.java
|
package org.infinispan.tools;
import org.infinispan.factories.annotations.InfinispanModule;
/**
* {@code InfinispanModule} annotation is required for component annotation processing
*/
@InfinispanModule(name = "tools-tests")
public class TestsModule implements org.infinispan.lifecycle.ModuleLifecycle {
}
| 310
| 27.272727
| 86
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/customs/CustomTransport.java
|
package org.infinispan.tools.customs;
import org.infinispan.remoting.transport.jgroups.JGroupsTransport;
/**
* Custom Transport class for testing the transport tag parsing.
*
* @author amanukya
*/
public class CustomTransport extends JGroupsTransport {
}
| 262
| 19.230769
| 66
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/AbstractReaderTest.java
|
package org.infinispan.tools.store.migrator;
import static org.infinispan.tools.store.migrator.Element.CACHE_NAME;
import static org.infinispan.tools.store.migrator.Element.CONTEXT_INITIALIZERS;
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.SEGMENT_COUNT;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
import static org.infinispan.tools.store.migrator.Element.TARGET;
import static org.infinispan.tools.store.migrator.Element.VERSION;
import static org.infinispan.tools.store.migrator.TestUtil.propKey;
import static org.testng.AssertJUnit.assertEquals;
import static org.testng.AssertJUnit.assertNotNull;
import java.util.Properties;
import org.infinispan.Cache;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.test.fwk.TestCacheManagerFactory;
import org.testng.AssertJUnit;
import org.testng.annotations.Test;
@Test(testName = "org.infinispan.tools.store.migrator.AbstractReaderTest", groups = "functional")
public abstract class AbstractReaderTest extends AbstractInfinispanTest {
private static final String TEST_CACHE_NAME = "reader-test";
protected int majorVersion = 8;
protected int sourceSegments;
protected int targetSegments;
public <T extends AbstractReaderTest> T majorVersion(int majorVersion) {
this.majorVersion = majorVersion;
return (T) this;
}
public <T extends AbstractReaderTest> T sourceSegments(int segmentCount) {
this.sourceSegments = segmentCount;
return (T) this;
}
public <T extends AbstractReaderTest> T targetSegments(int segmentCount) {
this.targetSegments = segmentCount;
return (T) this;
}
@Override
protected String parameters() {
return String.format("[version=%d,sourceSegments%d,targetSegments=%d]", majorVersion, sourceSegments, targetSegments);
}
/**
* Method meant to be overriden to add store configuration. The default implementation already handles configuring
* the segments for the hash and thus the store only needs to enable segmenting on the store if applicable.
* @return builder that should make the target config
*/
protected ConfigurationBuilder getTargetCacheConfig() {
ConfigurationBuilder builder = new ConfigurationBuilder();
if (targetSegments > 0) {
builder.clustering().hash().numSegments(targetSegments);
}
return builder;
}
protected void configureStoreProperties(Properties properties, Element type) {
properties.put(propKey(type, CACHE_NAME), TEST_CACHE_NAME);
if (type == SOURCE) {
if (majorVersion < 10) {
properties.put(propKey(type, MARSHALLER, EXTERNALIZERS), 256 + ":" + TestUtil.TestObjectExternalizer.class.getName());
} else {
properties.put(propKey(type, MARSHALLER, CONTEXT_INITIALIZERS), TestUtil.SCI.INSTANCE.getClass().getName());
}
if (sourceSegments > 0)
properties.put(propKey(type, SEGMENT_COUNT), Integer.toString(sourceSegments));
} else {
properties.put(propKey(type, MARSHALLER, CONTEXT_INITIALIZERS), TestUtil.SCI.INSTANCE.getClass().getName());
}
properties.put(propKey(type, VERSION), type == SOURCE ? String.valueOf(majorVersion): Version.getMajor());
if (type == TARGET && targetSegments > 0) {
properties.put(propKey(type, SEGMENT_COUNT), String.valueOf(targetSegments));
}
}
@Test
public void readerCompatibilityTest() throws Exception {
Properties properties = new Properties();
configureStoreProperties(properties, SOURCE);
configureStoreProperties(properties, TARGET);
new StoreMigrator(properties).run();
GlobalConfigurationBuilder globalConfig = new GlobalConfigurationBuilder();
globalConfig.serialization().addContextInitializer(TestUtil.SCI.INSTANCE);
globalConfig.defaultCacheName(TEST_CACHE_NAME);
// Create a new cache instance, with the required externalizers, to ensure that the new RocksDbStore can be
// loaded and contains all of the expected values.
EmbeddedCacheManager manager = TestCacheManagerFactory.createCacheManager(globalConfig, getTargetCacheConfig());
try {
Cache<String, Object> cache = manager.getCache(TEST_CACHE_NAME);
for (String key : TestUtil.TEST_MAP.keySet()) {
Object stored = cache.get(key);
assertNotNull(String.format("Key=%s", key), stored);
Object expected = TestUtil.TEST_MAP.get(key);
assertNotNull(String.format("Key=%s", key), stored);
assertEquals(expected, stored);
}
// Ensure that all of the unsupported classes are not written to the target store
TestUtil.TEST_MAP_UNSUPPORTED.keySet().stream()
.map(cache::get)
.forEach(AssertJUnit::assertNull);
} finally {
manager.stop();
}
}
}
| 5,283
| 41.95935
| 130
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/TestUtil.java
|
package org.infinispan.tools.store.migrator;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.infinispan.commons.io.ByteBufferImpl;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.MarshallUtil;
import org.infinispan.container.entries.ImmortalCacheEntry;
import org.infinispan.container.entries.ImmortalCacheValue;
import org.infinispan.container.entries.MortalCacheEntry;
import org.infinispan.container.entries.MortalCacheValue;
import org.infinispan.container.entries.TransientCacheEntry;
import org.infinispan.container.entries.TransientCacheValue;
import org.infinispan.container.entries.TransientMortalCacheEntry;
import org.infinispan.container.entries.TransientMortalCacheValue;
import org.infinispan.container.entries.metadata.MetadataImmortalCacheEntry;
import org.infinispan.container.entries.metadata.MetadataImmortalCacheValue;
import org.infinispan.container.entries.metadata.MetadataMortalCacheEntry;
import org.infinispan.container.entries.metadata.MetadataMortalCacheValue;
import org.infinispan.container.entries.metadata.MetadataTransientCacheEntry;
import org.infinispan.container.entries.metadata.MetadataTransientCacheValue;
import org.infinispan.container.entries.metadata.MetadataTransientMortalCacheEntry;
import org.infinispan.container.entries.metadata.MetadataTransientMortalCacheValue;
import org.infinispan.container.versioning.NumericVersion;
import org.infinispan.container.versioning.SimpleClusteredVersion;
import org.infinispan.metadata.EmbeddedMetadata;
import org.infinispan.metadata.Metadata;
import org.infinispan.metadata.impl.InternalMetadataImpl;
import org.infinispan.protostream.SerializationContextInitializer;
import org.infinispan.protostream.annotations.AutoProtoSchemaBuilder;
import org.infinispan.protostream.annotations.ProtoFactory;
import org.infinispan.protostream.annotations.ProtoField;
import org.infinispan.test.TestDataSCI;
import org.infinispan.test.data.Key;
import org.infinispan.test.data.Person;
import org.infinispan.util.KeyValuePair;
public class TestUtil {
public static final Map<String, Object> TEST_MAP = new HashMap<>();
static final Map<String, Object> TEST_MAP_UNSUPPORTED = new HashMap<>();
static {
TEST_MAP_UNSUPPORTED.put("List", Arrays.asList(new Person("Alan Shearer"), new Person("Nolberto Solano")));
TEST_MAP_UNSUPPORTED.put("SingletonList", Collections.singletonList(new Key("Key")));
TEST_MAP_UNSUPPORTED.put("SingletonMap", Collections.singletonMap("Key", "Value"));
TEST_MAP_UNSUPPORTED.put("SingletonSet", Collections.singleton(new Key("Key")));
Metadata metadata = new EmbeddedMetadata.Builder().version(new NumericVersion(1)).build();
TEST_MAP.put("EmbeddedMetadata", metadata);
TEST_MAP.put("SimpleClusteredVersion", new SimpleClusteredVersion(1, 1));
TEST_MAP.put("CustomExternalizer", new TestObject(1, "Test"));
// Put implementation classes that are not serializable by the persistence marshaller
TEST_MAP_UNSUPPORTED.put("KeyValuePair", new KeyValuePair<>("Key", "Value"));
byte[] bytes = "Test".getBytes();
TEST_MAP_UNSUPPORTED.put("ByteBufferImpl", ByteBufferImpl.create(bytes));
InternalMetadataImpl internalMetadata = new InternalMetadataImpl(metadata, 1, 1);
TEST_MAP_UNSUPPORTED.put("InternalMetadataImpl", internalMetadata);
TEST_MAP_UNSUPPORTED.put("ImmortalCacheEntry", new ImmortalCacheEntry("Key", "Value"));
TEST_MAP_UNSUPPORTED.put("MortalCacheEntry", new MortalCacheEntry("Key", "Value", 1, 1));
TEST_MAP_UNSUPPORTED.put("TransientCacheEntry", new TransientCacheEntry("Key", "Value", 1, 1));
TEST_MAP_UNSUPPORTED.put("TransientMortalCacheEntry", new TransientMortalCacheEntry("Key", "Value", 1, 1, 1));
TEST_MAP_UNSUPPORTED.put("ImmortalCacheValue", new ImmortalCacheValue("Value"));
TEST_MAP_UNSUPPORTED.put("MortalCacheValue", new MortalCacheValue("Value", 1, 1));
TEST_MAP_UNSUPPORTED.put("TransientCacheValue", new TransientCacheValue("Value", 1, 1));
TEST_MAP_UNSUPPORTED.put("TransientMortalCacheValue", new TransientMortalCacheValue("Value", 1, 1, 1, 1));
TEST_MAP_UNSUPPORTED.put("MetadataImmortalCacheEntry", new MetadataImmortalCacheEntry("Key", "Value", metadata));
TEST_MAP_UNSUPPORTED.put("MetadataMortalCacheEntry", new MetadataMortalCacheEntry("Key", "Value", metadata, 1));
TEST_MAP_UNSUPPORTED.put("MetadataTransientCacheEntry", new MetadataTransientCacheEntry("Key", "Value", metadata, 1));
TEST_MAP_UNSUPPORTED.put("MetadataTransientMortalCacheEntry", new MetadataTransientMortalCacheEntry("Key", "Value", metadata, 1));
TEST_MAP_UNSUPPORTED.put("MetadataImmortalCacheValue", new MetadataImmortalCacheValue("Value", metadata));
TEST_MAP_UNSUPPORTED.put("MetadataMortalCacheValue", new MetadataMortalCacheValue("Value", metadata, 1));
TEST_MAP_UNSUPPORTED.put("MetadataTransientCacheValue", new MetadataTransientCacheValue("Value", metadata, 1));
TEST_MAP_UNSUPPORTED.put("MetadataTransientMortalCacheValue", new MetadataTransientMortalCacheValue("Value", metadata, 1, 1));
}
public static class TestObject {
@ProtoField(number = 1, defaultValue = "0")
int id;
@ProtoField(2)
String someString;
TestObject() {
}
@ProtoFactory
TestObject(int id, String someString) {
this.id = id;
this.someString = someString;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TestObject that = (TestObject) o;
if (id != that.id) return false;
return someString != null ? someString.equals(that.someString) : that.someString == null;
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + (someString != null ? someString.hashCode() : 0);
return result;
}
}
public static class TestObjectExternalizer implements AdvancedExternalizer<TestObject> {
@Override
public Set<Class<? extends TestObject>> getTypeClasses() {
return Collections.singleton(TestObject.class);
}
@Override
public Integer getId() {
return 256;
}
@Override
public void writeObject(ObjectOutput objectOutput, TestObject testObject) throws IOException {
objectOutput.writeInt(testObject.id);
MarshallUtil.marshallString(testObject.someString, objectOutput);
}
@Override
public TestObject readObject(ObjectInput objectInput) throws IOException, ClassNotFoundException {
TestObject testObject = new TestObject();
testObject.id = objectInput.readInt();
testObject.someString = MarshallUtil.unmarshallString(objectInput);
return testObject;
}
}
public static String propKey(Element... elements) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < elements.length; i++) {
sb.append(elements[i].toString());
if (i != elements.length - 1) sb.append(".");
}
return sb.toString();
}
@AutoProtoSchemaBuilder(
dependsOn = TestDataSCI.class,
includeClasses = TestObject.class,
schemaFileName = "test.tools.proto",
schemaFilePath = "proto/generated",
schemaPackageName = "org.infinispan.test.tools",
service = false
)
interface SCI extends SerializationContextInitializer {
SCI INSTANCE = new SCIImpl();
}
}
| 7,781
| 45.047337
| 136
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/MigratorConfigurationTest.java
|
package org.infinispan.tools.store.migrator;
import static org.infinispan.tools.store.migrator.Element.ALLOW_LIST;
import static org.infinispan.tools.store.migrator.Element.BINARY;
import static org.infinispan.tools.store.migrator.Element.CACHE_NAME;
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.CONNECTION_POOL;
import static org.infinispan.tools.store.migrator.Element.CONNECTION_URL;
import static org.infinispan.tools.store.migrator.Element.CONTEXT_INITIALIZERS;
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.EXTERNALIZERS;
import static org.infinispan.tools.store.migrator.Element.ID;
import static org.infinispan.tools.store.migrator.Element.MARSHALLER;
import static org.infinispan.tools.store.migrator.Element.NAME;
import static org.infinispan.tools.store.migrator.Element.REGEXPS;
import static org.infinispan.tools.store.migrator.Element.SEGMENT;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
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.TARGET;
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.VERSION;
import static org.infinispan.tools.store.migrator.StoreType.JDBC_MIXED;
import static org.infinispan.tools.store.migrator.TestUtil.propKey;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;
import java.util.Arrays;
import java.util.Collections;
import java.util.Properties;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.configuration.ClassAllowList;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.JavaSerializationMarshaller;
import org.infinispan.commons.marshall.MarshallUtil;
import org.infinispan.commons.marshall.Marshaller;
import org.infinispan.commons.test.Exceptions;
import org.infinispan.commons.test.ThreadLeakChecker;
import org.infinispan.commons.util.Version;
import org.infinispan.configuration.cache.Configuration;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.global.AllowListConfiguration;
import org.infinispan.configuration.global.GlobalConfigurationBuilder;
import org.infinispan.jboss.marshalling.commons.CheckedClassResolver;
import org.infinispan.jboss.marshalling.commons.GenericJBossMarshaller;
import org.infinispan.marshall.core.impl.DelegatingUserMarshaller;
import org.infinispan.marshall.persistence.PersistenceMarshaller;
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.impl.table.TableManagerFactory;
import org.infinispan.test.TestingUtil;
import org.infinispan.test.data.Person;
import org.infinispan.tools.store.migrator.jdbc.JdbcConfigurationUtil;
import org.infinispan.tools.store.migrator.marshaller.SerializationConfigUtil;
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;
import org.jboss.marshalling.MarshallingConfiguration;
import org.testng.annotations.BeforeMethod;
import org.testng.annotations.Test;
/**
* @author Ryan Emerson
* @since 9.0
*/
@Test(testName = "tools.MigratorConfigurationTest", groups = "functional")
public class MigratorConfigurationTest {
private static final String DEFAULT_CACHE_NAME = "testCache";
private static final AtomicInteger externalizerReadCount = new AtomicInteger();
private static final AtomicInteger externalizerWriteCount = new AtomicInteger();
@BeforeMethod
public void init() {
// Ignore all threads, SerializationConfigUtil.getMarshaller() starts a cache manager and doesn't stop it
ThreadLeakChecker.ignoreThreadsContaining("");
externalizerReadCount.set(0);
externalizerWriteCount.set(0);
}
public void testAllowListLoadedForTargetStores() {
Properties properties = createBaseProperties(TARGET);
properties.put(propKey(TARGET, MARSHALLER, CLASS), JavaSerializationMarshaller.class.getName());
properties.put(propKey(TARGET, MARSHALLER, ALLOW_LIST, CLASSES), "org.example.Person,org.example.Animal");
properties.put(propKey(TARGET, MARSHALLER, ALLOW_LIST, REGEXPS), "org.another.example.*");
GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder();
StoreProperties storeProps = new StoreProperties(TARGET, properties);
SerializationConfigUtil.configureSerialization(storeProps, builder.serialization());
AllowListConfiguration allowList = builder.build().serialization().allowList();
assertEquals(allowList.getClasses(), Set.of("org.example.Person", "org.example.Animal"));
assertEquals(allowList.getRegexps(), Set.of("org.another.example.*"));
}
public void testCustomMarshallerLoadedLegacy() {
Properties properties = createBaseProperties();
properties.put(propKey(SOURCE, VERSION), String.valueOf(8));
properties.put(propKey(SOURCE, MARSHALLER, CLASS), GenericJBossMarshaller.class.getName());
properties.put(propKey(SOURCE, MARSHALLER, ALLOW_LIST, CLASSES), "org.example.Person,org.example.Animal");
properties.put(propKey(SOURCE, MARSHALLER, ALLOW_LIST, REGEXPS), "org.another.example.*");
StoreProperties props = new StoreProperties(SOURCE, properties);
Marshaller jBossMarshaller = SerializationConfigUtil.getMarshaller(props);
assertNotNull(jBossMarshaller);
assertTrue(jBossMarshaller instanceof GenericJBossMarshaller);
MarshallingConfiguration config = TestingUtil.extractField(jBossMarshaller, "baseCfg");
CheckedClassResolver classResolver = (CheckedClassResolver) config.getClassResolver();
ClassAllowList allowList = TestingUtil.extractField(classResolver, "classAllowList");
assertTrue(allowList.isSafeClass("org.example.Person"));
assertTrue(allowList.isSafeClass("org.example.Animal"));
assertTrue(allowList.isSafeClass("org.another.example.Person"));
}
public void testCustomMarshallerLoaded() {
Properties properties = createBaseProperties();
properties.put(propKey(SOURCE, MARSHALLER, CLASS), GenericJBossMarshaller.class.getName());
properties.put(propKey(SOURCE, MARSHALLER, ALLOW_LIST, CLASSES), "org.example.Person,org.example.Animal");
properties.put(propKey(SOURCE, MARSHALLER, ALLOW_LIST, REGEXPS), "org.another.example.*");
StoreProperties props = new StoreProperties(SOURCE, properties);
Marshaller marshaller = SerializationConfigUtil.getMarshaller(props);
assertNotNull(marshaller);
assertTrue(marshaller instanceof PersistenceMarshaller);
PersistenceMarshaller pm = (PersistenceMarshaller) marshaller;
DelegatingUserMarshaller userMarshaller = (DelegatingUserMarshaller) pm.getUserMarshaller();
assertTrue(userMarshaller.getDelegate() instanceof GenericJBossMarshaller);
GenericJBossMarshaller jBossMarshaller = (GenericJBossMarshaller) userMarshaller.getDelegate();
MarshallingConfiguration config = TestingUtil.extractField(jBossMarshaller, "baseCfg");
CheckedClassResolver classResolver = (CheckedClassResolver) config.getClassResolver();
ClassAllowList allowList = TestingUtil.extractField(classResolver, "classAllowList");
assertTrue(allowList.isSafeClass("org.example.Person"));
assertTrue(allowList.isSafeClass("org.example.Animal"));
assertTrue(allowList.isSafeClass("org.another.example.Person"));
}
public void testInfinipsan8MarshallerAndExternalizersLoaded() throws Exception {
String externalizers = String.format("%d:%s", 1, PersonExternalizer.class.getName());
Properties properties = createBaseProperties();
properties.put(propKey(SOURCE, VERSION), String.valueOf(8));
properties.put(propKey(SOURCE, MARSHALLER, EXTERNALIZERS), externalizers);
StoreProperties props = new StoreProperties(SOURCE, properties);
Marshaller marshaller = SerializationConfigUtil.getMarshaller(props);
assertNotNull(marshaller);
assertTrue(marshaller instanceof Infinispan8Marshaller);
byte[] bytes = new byte[] {3, 1, -2, 3, -1, 1, 1};
Object object = marshaller.objectFromByteBuffer(bytes);
assertNotNull(object);
assertTrue(object instanceof Person);
assertEquals(1, externalizerReadCount.get());
}
public void testInfinispan9MarshallerLoadedAndExternalizersLoaded() throws Exception {
String externalizers = String.format("%d:%s", 1, PersonExternalizer.class.getName());
Properties properties = createBaseProperties();
properties.put(propKey(SOURCE, VERSION), String.valueOf(9));
properties.put(propKey(SOURCE, MARSHALLER, EXTERNALIZERS), externalizers);
StoreProperties props = new StoreProperties(SOURCE, properties);
Marshaller marshaller = SerializationConfigUtil.getMarshaller(props);
assertNotNull(marshaller);
assertTrue(marshaller instanceof Infinispan9Marshaller);
byte[] bytes = new byte[] {3, 0, 0, 0, 1, 1};
Object object = marshaller.objectFromByteBuffer(bytes);
assertNotNull(object);
assertTrue(object instanceof Person);
assertEquals(1, externalizerReadCount.get());
}
public void testCurrentMarshallerLoadedAndSCILoaded() throws Exception {
Properties properties = createBaseProperties();
properties.put(propKey(SOURCE, MARSHALLER, CONTEXT_INITIALIZERS), TestUtil.SCI.INSTANCE.getClass().getName());
StoreProperties props = new StoreProperties(SOURCE, properties);
Marshaller marshaller = SerializationConfigUtil.getMarshaller(props);
assertNotNull(marshaller);
assertTrue(marshaller instanceof PersistenceMarshaller);
byte[] bytes = marshaller.objectToByteBuffer(new Person(Person.class.getName()));
Person person = (Person) marshaller.objectFromByteBuffer(bytes);
assertNotNull(person);
assertEquals(Person.class.getName(), person.getName());
}
public void testExceptionOnMarshallerType() {
Properties properties = createBaseProperties();
properties.put(propKey(SOURCE, MARSHALLER, TYPE), "CURRENT");
Exceptions.expectException(CacheConfigurationException.class, () -> new StoreProperties(SOURCE, properties));
}
public void testCorrectMarshallerLoadedForVersion() {
assertTrue(getMarshallerForVersion(8, SOURCE) instanceof Infinispan8Marshaller);
assertTrue(getMarshallerForVersion(9, SOURCE) instanceof Infinispan9Marshaller);
assertTrue(getMarshallerForVersion(10, SOURCE) instanceof Infinispan10Marshaller);
assertTrue(getMarshallerForVersion(11, SOURCE) instanceof Infinispan10Marshaller);
assertTrue(getMarshallerForVersion(12, SOURCE) instanceof PersistenceMarshaller);
assertTrue(getMarshallerForVersion(13, SOURCE) instanceof PersistenceMarshaller);
Exceptions.expectException(CacheConfigurationException.class, () -> getMarshallerForVersion(8, TARGET));
Exceptions.expectException(CacheConfigurationException.class, () -> getMarshallerForVersion(9, TARGET));
Exceptions.expectException(CacheConfigurationException.class, () -> getMarshallerForVersion(10, TARGET));
Exceptions.expectException(CacheConfigurationException.class, () -> getMarshallerForVersion(11, TARGET));
Exceptions.expectException(CacheConfigurationException.class, () -> getMarshallerForVersion(12, TARGET));
assertNull(getMarshallerForVersion(Integer.parseInt(Version.getMajor()), TARGET));
}
private Marshaller getMarshallerForVersion(int version, Element storeType) {
Properties properties = createBaseProperties(storeType);
properties.put(propKey(storeType, VERSION), String.valueOf(version));
StoreProperties props = new StoreProperties(storeType, properties);
return SerializationConfigUtil.getMarshaller(props);
}
public void testDbPropertiesLoaded() {
Properties properties = createBaseProperties();
properties.putAll(createBaseProperties(TARGET));
Element[] storeTypes = new Element[] {SOURCE, TARGET};
for (Element storeType : storeTypes) {
properties.put(propKey(storeType, DB, DISABLE_INDEXING), "true");
properties.put(propKey(storeType, DB, DISABLE_UPSERT), "true");
for (Element store : Arrays.asList(STRING, BINARY)) {
properties.put(propKey(storeType, TABLE, store, TABLE_NAME_PREFIX), "mock_table_name");
properties.put(propKey(storeType, TABLE, store, ID, NAME), "mock_id_column_name");
properties.put(propKey(storeType, TABLE, store, ID, TYPE), "mock_id_column_type");
properties.put(propKey(storeType, TABLE, store, DATA, NAME), "mock_data_column_name");
properties.put(propKey(storeType, TABLE, store, DATA, TYPE), "mock_data_column_type");
properties.put(propKey(storeType, TABLE, store, TIMESTAMP, NAME), "mock_timestamp_column_name");
properties.put(propKey(storeType, TABLE, store, TIMESTAMP, TYPE), "mock_timestamp_column_type");
properties.put(propKey(storeType, TABLE, store, SEGMENT, NAME), "mock_segment_column_name");
properties.put(propKey(storeType, TABLE, store, SEGMENT, TYPE), "mock_segment_column_type");
}
}
for (Element storeType : storeTypes) {
StoreProperties props = new StoreProperties(storeType, properties);
JdbcStringBasedStoreConfigurationBuilder builder = new ConfigurationBuilder().persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
Configuration cacheConfig = JdbcConfigurationUtil.configureStore(props, builder).build();
JdbcStringBasedStoreConfiguration config = (JdbcStringBasedStoreConfiguration) cacheConfig.persistence().stores().get(0);
assertNull(config.dbMajorVersion());
assertNull(config.dbMinorVersion());
assertTrue(Boolean.parseBoolean(config.properties().getProperty(TableManagerFactory.INDEXING_DISABLED)));
assertTrue(Boolean.parseBoolean(config.properties().getProperty(TableManagerFactory.UPSERT_DISABLED)));
}
}
private Properties createBaseProperties() {
return createBaseProperties(SOURCE);
}
private Properties createBaseProperties(Element orientation) {
Properties properties = new Properties();
properties.put(propKey(orientation, CACHE_NAME), DEFAULT_CACHE_NAME);
properties.put(propKey(orientation, TYPE), JDBC_MIXED.toString());
properties.put(propKey(orientation, DIALECT), DatabaseType.H2.toString());
properties.put(propKey(orientation, CONNECTION_POOL, CONNECTION_URL), "jdbc:postgresql:postgres");
properties.put(propKey(orientation, CONNECTION_POOL, DRIVER_CLASS), "org.postgresql.Driver");
return properties;
}
public static class PersonExternalizer implements AdvancedExternalizer<Person> {
@Override
public Set<Class<? extends Person>> getTypeClasses() {
return Collections.singleton(Person.class);
}
@Override
public void writeObject(ObjectOutput output, Person object) throws IOException {
externalizerWriteCount.incrementAndGet();
MarshallUtil.marshallString(object.getName(), output);
}
@Override
public Integer getId() {
return 1;
}
@Override
public Person readObject(ObjectInput input) throws IOException {
externalizerReadCount.incrementAndGet();
return new Person(MarshallUtil.unmarshallString(input));
}
}
}
| 16,912
| 54.452459
| 130
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/marshaller/LegacyMarshallerTest.java
|
package org.infinispan.tools.store.migrator.marshaller;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNotNull;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.marshall.StreamingMarshaller;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.tools.store.migrator.TestUtil;
import org.infinispan.tools.store.migrator.marshaller.infinispan8.Infinispan8Marshaller;
import org.infinispan.tools.store.migrator.marshaller.infinispan9.Infinispan9Marshaller;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
/**
* Tests to ensure that the configured legacy marshaller can correctly unmarshall bytes from previous versions. Note,
* instructions on how to generate the bin file used in this test are found in the comments at the bottom of the test.
*/
@Test(testName = "org.infinispan.tools.store.migrator.marshaller.LegacyMarshallerTest", groups = "functional")
public class LegacyMarshallerTest extends AbstractInfinispanTest {
private int majorVersion;
private StreamingMarshaller marshaller;
private Map<String, byte[]> byteMap;
@Factory
public Object[] factory() {
return new Object[] {
new LegacyMarshallerTest().majorVersion(8),
new LegacyMarshallerTest().majorVersion(9)
};
}
@Override
protected String parameters() {
return "[" + majorVersion + "]";
}
private LegacyMarshallerTest majorVersion(int majorVersion) {
this.majorVersion = majorVersion;
return this;
}
@BeforeClass(alwaysRun = true)
public void beforeTest() throws Exception {
Map<Integer, AdvancedExternalizer> userExts = new HashMap<>();
userExts.put(256, new TestUtil.TestObjectExternalizer());
this.marshaller = majorVersion == 8 ? new Infinispan8Marshaller(userExts) : new Infinispan9Marshaller(userExts);
String filename = String.format("src/test/resources/infinispan%d/marshalled_bytes.bin", majorVersion);
Path path = new File(filename).toPath();
byte[] bytes = Files.readAllBytes(path);
byteMap = (Map<String, byte[]>) marshaller.objectFromByteBuffer(bytes);
}
public void testUnmarshalling() throws Exception {
for (Map.Entry<String, Object> entry : TestUtil.TEST_MAP.entrySet())
unmarshallAndAssertEquality(entry.getKey(), entry.getValue());
}
private void unmarshallAndAssertEquality(String key, Object expectedObj) throws Exception {
byte[] bytes = byteMap.get(key);
assertNotNull(bytes);
Object readObj = marshaller.objectFromByteBuffer(bytes);
assertEquals(readObj, expectedObj);
}
/**
* Below is the program to generate the marshalled_bytes_<major-version></major-version>.x.bin file.
* It utilises the {@link TestObject} and {@link TestObjectExternalizer} classes defined above.
*/
/*
public class ByteOutputGenerator {
public static void main(String[] args) throws Exception {
GlobalConfiguration globalConfig = new GlobalConfigurationBuilder()
.serialization().addAdvancedExternalizer(new TestObjectExternalizer()).build();
PersistenceConfigurationBuilder pb = new ConfigurationBuilder().persistence();
pb.addStore(LevelDBStoreConfigurationBuilder.class);
pb.addStore(SingleFileStoreConfigurationBuilder.class);
pb.addStore(SoftIndexFileStoreConfigurationBuilder.class);
Configuration config = pb.build();
EmbeddedCacheManager manager = new DefaultCacheManager(globalConfig, config);
ComponentRegistry registry = manager.getCache().getAdvancedCache().getComponentRegistry();
StreamingMarshaller marshaller = registry.getCacheMarshaller();
// Write to stores
generateOutput(new CacheStoreOutput(manager.getCache("RocksDBReaderTest")));
// Binary file
ByteOutputMap outputMap = new ByteOutputMap(marshaller);
generateOutput(outputMap);
Files.write(Paths.get("target/marshalled_bytes.bin"), outputMap.getBytes());
}
private static void generateOutput(Output output) throws Exception {
output.put("List", Arrays.asList(new Person("Alan Shearer"), new Person("Nolberto Solano")));
output.put("SingletonList", Collections.singletonList(new Key("Key", false)));
output.put("SingletonMap", Collections.singletonMap("Key", "Value"));
output.put("SingletonSet", Collections.singleton(new Key("Key", false)));
output.put("KeyValuePair", new KeyValuePair<>("Key", "Value"));
output.put("ImmortalCacheEntry", new ImmortalCacheEntry("Key", "Value"));
output.put("MortalCacheEntry", new MortalCacheEntry("Key", "Value", 1, 1));
output.put("TransientCacheEntry", new TransientCacheEntry("Key", "Value", 1, 1));
output.put("TransientMortalCacheEntry", new TransientMortalCacheEntry("Key", "Value", 1, 1, 1));
output.put("ImmortalCacheValue", new ImmortalCacheValue("Value"));
output.put("MortalCacheValue", new MortalCacheValue("Value", 1, 1));
output.put("TransientCacheValue", new TransientCacheValue("Value", 1, 1));
output.put("TransientMortalCacheValue", new TransientMortalCacheValue("Value", 1, 1, 1));
Metadata metadata = new EmbeddedMetadata.Builder().version(new NumericVersion(1)).build();
output.put("EmbeddedMetadata", metadata);
output.put("SimpleClusteredVersion", new SimpleClusteredVersion(1, 1));
output.put("MetadataImmortalCacheEntry", new MetadataImmortalCacheEntry("Key", "Value", metadata));
output.put("MetadataMortalCacheEntry", new MetadataMortalCacheEntry("Key", "Value", metadata, 1));
output.put("MetadataTransientCacheEntry", new MetadataTransientCacheEntry("Key", "Value", metadata, 1));
output.put("MetadataTransientMortalCacheEntry", new MetadataTransientMortalCacheEntry("Key", "Value", metadata, 1));
output.put("MetadataImmortalCacheValue", new MetadataImmortalCacheValue("Value", metadata));
output.put("MetadataMortalCacheValue", new MetadataMortalCacheValue("Value", metadata, 1));
output.put("MetadataTransientCacheValue", new MetadataTransientCacheValue("Value", metadata, 1));
output.put("MetadataTransientMortalCacheValue", new MetadataTransientMortalCacheValue("Value", metadata, 1, 1));
byte[] bytes = "Test".getBytes();
output.put("ByteBufferImpl", new ByteBufferImpl(bytes, 0, bytes.length));
output.put("KeyValuePair", new KeyValuePair<>("Key", "Value"));
InternalMetadataImpl internalMetadata = new InternalMetadataImpl(metadata, 1, 1);
output.put("InternalMetadataImpl", internalMetadata);
output.put("CustomExternalizer", new TestObject(1, "Test"));
}
interface Output {
void put(String key, Object object) throws Exception;
}
private static class CacheStoreOutput implements Output {
final Cache cache;
public CacheStoreOutput(Cache cache) {
this.cache = cache;
}
@Override
public void put(String key, Object object) throws Exception {
cache.put(key, object);
}
}
private static class ByteOutputMap implements Output {
final Map<String, byte[]> outputMap = new HashMap<>();
final StreamingMarshaller marshaller;
ByteOutputMap(StreamingMarshaller marshaller) {
this.marshaller = marshaller;
}
@Override
public void put(String key, Object object) throws Exception {
outputMap.put(key, marshaller.objectToByteBuffer(object));
}
byte[] getBytes() throws Exception {
return marshaller.objectToByteBuffer(outputMap);
}
}
private static class TestObject {
int id;
String someString;
TestObject() {
}
TestObject(int id, String someString) {
this.id = id;
this.someString = someString;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
TestObject that = (TestObject) o;
if (id != that.id) return false;
return someString != null ? someString.equals(that.someString) : that.someString == null;
}
@Override
public int hashCode() {
int result = id;
result = 31 * result + (someString != null ? someString.hashCode() : 0);
return result;
}
}
public static class TestObjectExternalizer implements AdvancedExternalizer<TestObject> {
@Override
public Set<Class<? extends TestObject>> getTypeClasses() {
return Collections.singleton(TestObject.class);
}
@Override
public Integer getId() {
return 256;
}
@Override
public void writeObject(ObjectOutput objectOutput, TestObject testObject) throws IOException {
objectOutput.writeInt(testObject.id);
MarshallUtil.marshallString(testObject.someString, objectOutput);
}
@Override
public TestObject readObject(ObjectInput objectInput) throws IOException {
TestObject testObject = new TestObject();
testObject.id = objectInput.readInt();
testObject.someString = MarshallUtil.unmarshallString(objectInput);
return testObject;
}
}
}
*/
}
| 9,481
| 38.67364
| 122
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/file/SoftIndexFileStoreReaderTest.java
|
package org.infinispan.tools.store.migrator.file;
import static org.infinispan.tools.store.migrator.Element.INDEX_LOCATION;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
import static org.infinispan.tools.store.migrator.Element.TYPE;
import static org.infinispan.tools.store.migrator.TestUtil.propKey;
import java.util.Properties;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.sifs.configuration.SoftIndexFileStoreConfigurationBuilder;
import org.infinispan.tools.store.migrator.AbstractReaderTest;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreType;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
@Test(testName = "tools.store.migrator.file.SoftIndexFileStoreReaderTest", groups = "functional")
public class SoftIndexFileStoreReaderTest extends AbstractReaderTest {
public String getSrcDirectory() {
return String.format("target/test-classes/infinispan%d/softindex/", majorVersion);
}
public String getTargetDataDirectory() {
return String.format("%s/target-softindex/data/%d/", getSrcDirectory(), targetSegments);
}
public String getTargetIndexDirectory() {
return String.format("%s/target-softindex/index/%d/", getSrcDirectory(), targetSegments);
}
@Factory
public Object[] factory() {
return new Object[] {
new SoftIndexFileStoreReaderTest().targetSegments(59),
new SoftIndexFileStoreReaderTest().majorVersion(9).targetSegments(59),
};
}
@Override
public ConfigurationBuilder getTargetCacheConfig() {
ConfigurationBuilder builder = super.getTargetCacheConfig();
builder.persistence()
.addStore(SoftIndexFileStoreConfigurationBuilder.class)
// Have to append additional name for segment, since SoftIndex creates files named by just numbers
// so if write to the same location with segmented vs not segmented, they will clash
.dataLocation(getTargetDataDirectory())
.indexLocation(getTargetIndexDirectory())
.preload(true).ignoreModifications(true).segmented(targetSegments > 0);
return builder;
}
@Override
protected void configureStoreProperties(Properties properties, Element type) {
super.configureStoreProperties(properties, type);
properties.put(propKey(type, TYPE), StoreType.SOFT_INDEX_FILE_STORE.toString());
if (type == SOURCE) {
properties.put(propKey(type, LOCATION), getSrcDirectory());
} else {
properties.put(propKey(type, LOCATION), getTargetDataDirectory());
properties.put(propKey(type, INDEX_LOCATION), getTargetIndexDirectory());
}
}
}
| 2,836
| 41.343284
| 110
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/file/SingleFileStoreReaderTest.java
|
package org.infinispan.tools.store.migrator.file;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
import static org.infinispan.tools.store.migrator.Element.TYPE;
import static org.infinispan.tools.store.migrator.TestUtil.propKey;
import java.nio.file.Path;
import java.util.Properties;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.SingleFileStoreConfigurationBuilder;
import org.infinispan.tools.store.migrator.AbstractReaderTest;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreType;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
@Test(testName = "tools.store.migrator.file.SingleFileStoreReaderTest", groups = "functional")
public class SingleFileStoreReaderTest extends AbstractReaderTest {
@Factory
public Object[] factory() {
return new Object[] {
new SingleFileStoreReaderTest(),
new SingleFileStoreReaderTest().majorVersion(9),
new SingleFileStoreReaderTest().majorVersion(9).targetSegments(59),
new SingleFileStoreReaderTest().majorVersion(10),
new SingleFileStoreReaderTest().majorVersion(10).sourceSegments(4),
new SingleFileStoreReaderTest().majorVersion(11),
new SingleFileStoreReaderTest().majorVersion(11).sourceSegments(4),
new SingleFileStoreReaderTest().majorVersion(12),
new SingleFileStoreReaderTest().majorVersion(12).sourceSegments(4),
new SingleFileStoreReaderTest().targetSegments(59),
};
}
@Override
public ConfigurationBuilder getTargetCacheConfig() {
ConfigurationBuilder builder = super.getTargetCacheConfig();
builder.persistence()
.addStore(SingleFileStoreConfigurationBuilder.class).location(getTargetDir())
.preload(true).ignoreModifications(true).segmented(targetSegments > 0);
return builder;
}
@Override
protected void configureStoreProperties(Properties properties, Element type) {
super.configureStoreProperties(properties, type);
properties.put(propKey(type, TYPE), StoreType.SINGLE_FILE_STORE.toString());
properties.put(propKey(type, LOCATION), type == SOURCE ? getSourceDir() : getTargetDir());
}
private String getSourceDir() {
String root = String.format("target/test-classes/infinispan%d/singlefilestore/", majorVersion);
if (sourceSegments == 0)
return root;
return Path.of(root).resolve("segmented").toString();
}
private String getTargetDir() {
return getSourceDir() + "/target-sfs";
}
}
| 2,736
| 40.469697
| 101
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/jdbc/JdbcReaderTest.java
|
package org.infinispan.tools.store.migrator.jdbc;
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.DIALECT;
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.LOCATION;
import static org.infinispan.tools.store.migrator.Element.NAME;
import static org.infinispan.tools.store.migrator.Element.SEGMENT;
import static org.infinispan.tools.store.migrator.Element.SEGMENT_COUNT;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
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.TARGET;
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 static org.infinispan.tools.store.migrator.StoreType.JDBC_STRING;
import static org.infinispan.tools.store.migrator.StoreType.SINGLE_FILE_STORE;
import static org.infinispan.tools.store.migrator.TestUtil.propKey;
import static org.testng.AssertJUnit.assertEquals;
import java.util.Properties;
import java.util.stream.IntStream;
import org.infinispan.Cache;
import org.infinispan.commons.test.CommonsTestingUtil;
import org.infinispan.commons.util.Util;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.test.AbstractInfinispanTest;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreMigrator;
import org.testng.annotations.AfterClass;
import org.testng.annotations.Test;
/**
* @author Ryan Emerson
* @since 14.0
*/
@Test(testName = "org.infinispan.tools.store.migrator.marshaller.jdbc.JdbcReaderTest", groups = "functional")
public class JdbcReaderTest extends AbstractInfinispanTest {
private static final int NUM_ENTRIES = 100;
private static final String CACHE_NAME = "jdbc-cache";
private static final String JDBC_URL = "jdbc:h2:mem:JdbcReaderTest;DB_CLOSE_DELAY=-1;DB_CLOSE_ON_EXIT=FALSE";
private static final String SFS_LOCATION = CommonsTestingUtil.tmpDirectory(JdbcReaderTest.class);
@AfterClass
public void cleanup() {
Util.recursiveFileRemove(SFS_LOCATION);
}
@Test
public void jdbcReaderTest() throws Exception {
// Initialize h2 JDBC database with entries
ConfigurationBuilder builder = new ConfigurationBuilder();
JdbcStringBasedStoreConfigurationBuilder jdbcB = builder.persistence()
.addStore(JdbcStringBasedStoreConfigurationBuilder.class);
jdbcB.table()
.createOnStart(true)
.dropOnExit(false)
.tableNamePrefix("prefix")
.idColumnName("ID_COLUMN").idColumnType("VARCHAR(255)")
.dataColumnName("DATA_COLUMN").dataColumnType("BINARY VARYING")
.timestampColumnName("TIMESTAMP_COLUMN").timestampColumnType("BIGINT")
.segmented(false);
jdbcB.connectionPool()
.driverClass(org.h2.Driver.class)
.connectionUrl(JDBC_URL)
.username("sa");
try (EmbeddedCacheManager cm = new DefaultCacheManager()) {
Cache<Integer, Integer> cache = cm.createCache(CACHE_NAME, builder.build());
IntStream.range(0, NUM_ENTRIES).forEach(i -> cache.put(i, i));
}
// Migrate JDBC store to SFS
Properties properties = new Properties();
properties.put(propKey(SOURCE, Element.CACHE_NAME), CACHE_NAME);
properties.put(propKey(SOURCE, TYPE), JDBC_STRING.toString());
properties.put(propKey(SOURCE, DIALECT), "h2");
properties.put(propKey(SOURCE, CONNECTION_POOL, CONNECTION_URL), JDBC_URL);
properties.put(propKey(SOURCE, CONNECTION_POOL, DRIVER_CLASS), org.h2.Driver.class.getName());
properties.put(propKey(SOURCE, CONNECTION_POOL, USERNAME), "sa");
properties.put(propKey(SOURCE, TABLE, STRING, TABLE_NAME_PREFIX), "prefix");
properties.put(propKey(SOURCE, TABLE, STRING, ID, NAME), "ID_COLUMN");
properties.put(propKey(SOURCE, TABLE, STRING, ID, TYPE), "VARCHAR(255)");
properties.put(propKey(SOURCE, TABLE, STRING, DATA, NAME), "DATA_COLUMN");
properties.put(propKey(SOURCE, TABLE, STRING, DATA, TYPE), "BINARY VARYING");
properties.put(propKey(SOURCE, TABLE, STRING, SEGMENT, NAME), "SEGMENT_COLUMN");
properties.put(propKey(SOURCE, TABLE, STRING, SEGMENT, TYPE), "BIGINT");
properties.put(propKey(SOURCE, TABLE, STRING, TIMESTAMP, NAME), "TIMESTAMP_COLUMN");
properties.put(propKey(SOURCE, TABLE, STRING, TIMESTAMP, TYPE), "BIGINT");
properties.put(propKey(SOURCE, SEGMENT_COUNT), "256");
properties.put(propKey(TARGET, TYPE), SINGLE_FILE_STORE.toString());
properties.put(propKey(TARGET, Element.CACHE_NAME), CACHE_NAME);
properties.put(propKey(TARGET, LOCATION), SFS_LOCATION);
new StoreMigrator(properties).run();
// Assert that SFS contains expected number of entries
builder = new ConfigurationBuilder();
builder.persistence().addSingleFileStore().location(SFS_LOCATION);
try (EmbeddedCacheManager cm = new DefaultCacheManager()) {
Cache<Integer, Integer> cache = cm.createCache(CACHE_NAME, builder.build());
assertEquals(NUM_ENTRIES, cache.size());
IntStream.range(0, NUM_ENTRIES).forEach(i -> assertEquals(i, (int) cache.get(i)));
}
}
}
| 6,032
| 50.127119
| 112
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/store/migrator/rocksdb/RocksDBReaderTest.java
|
package org.infinispan.tools.store.migrator.rocksdb;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
import static org.infinispan.tools.store.migrator.Element.TYPE;
import static org.infinispan.tools.store.migrator.TestUtil.propKey;
import java.util.Properties;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.persistence.rocksdb.configuration.RocksDBStoreConfigurationBuilder;
import org.infinispan.tools.store.migrator.AbstractReaderTest;
import org.infinispan.tools.store.migrator.Element;
import org.infinispan.tools.store.migrator.StoreType;
import org.testng.annotations.Factory;
import org.testng.annotations.Test;
@Test(testName = "tools.store.migrator.rocksdb.RocksDBReaderTest", groups = "functional")
public class RocksDBReaderTest extends AbstractReaderTest {
private String getSourceDir() {
return String.format("target/test-classes/infinispan%d/leveldbstore/", majorVersion);
}
private String getTargetDirectory() {
return String.format("%s/target/%d/", getSourceDir(), targetSegments);
}
@Factory
public Object[] factory() {
return new Object[] {
new RocksDBReaderTest(),
new RocksDBReaderTest().targetSegments(59),
new RocksDBReaderTest().majorVersion(9),
new RocksDBReaderTest().majorVersion(9).targetSegments(59),
};
}
public ConfigurationBuilder getTargetCacheConfig() {
ConfigurationBuilder builder = super.getTargetCacheConfig();
String targetDir = getTargetDirectory();
builder.persistence()
.addStore(RocksDBStoreConfigurationBuilder.class).location(targetDir).expiredLocation(targetDir + "expired")
.preload(true).ignoreModifications(true).segmented(targetSegments > 0);
return builder;
}
@Override
protected void configureStoreProperties(Properties properties, Element type) {
super.configureStoreProperties(properties, type);
properties.put(propKey(type, TYPE), StoreType.ROCKSDB.toString());
properties.put(propKey(type, LOCATION), type == SOURCE ? getSourceDir() : getTargetDirectory());
}
}
| 2,227
| 39.509091
| 120
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/tools/licenses/LicenseMergerTest.java
|
package org.infinispan.tools.licenses;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;
import java.io.ByteArrayOutputStream;
import java.nio.charset.StandardCharsets;
import org.testng.annotations.Test;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
@Test(testName = "org.infinispan.tools.licenses.LicenseMergerTest", groups = "functional")
public class LicenseMergerTest {
public void testMergeLicenses() throws Exception {
LicenseMerger merger = new LicenseMerger();
merger.loadLicense(getClass().getClassLoader().getResource("licenses/artifact1-1.0.0.xml").getFile());
merger.loadLicense(getClass().getClassLoader().getResource("licenses/artifact2-1.0.0.xml").getFile());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
merger.write(false, baos);
String out = baos.toString(StandardCharsets.UTF_8.name());
assertTrue(out.contains("artifact1"));
assertTrue(out.contains("artifact2"));
assertTrue(out.contains("artifact3"));
}
public void testMergeLicensesInclusive() throws Exception {
LicenseMerger merger = new LicenseMerger();
merger.loadLicense(getClass().getClassLoader().getResource("licenses/artifact1-1.0.0.xml").getFile());
merger.loadLicense(getClass().getClassLoader().getResource("licenses/artifact2-1.0.0.xml").getFile());
ByteArrayOutputStream baos = new ByteArrayOutputStream();
merger.write(true, baos);
String out = baos.toString(StandardCharsets.UTF_8.name());
assertTrue(out.contains("artifact1"));
assertTrue(out.contains("artifact2"));
assertFalse(out.contains("artifact3"));
}
}
| 1,727
| 38.272727
| 108
|
java
|
null |
infinispan-main/tools/src/test/java/org/infinispan/test/fwk/TestNameVerifier.java
|
package org.infinispan.test.fwk;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileFilter;
import java.io.FileReader;
import java.io.FilenameFilter;
import java.io.PrintWriter;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.testng.annotations.Test;
/**
* Class that tests that test names are correctly set for each test.
*
* @author Mircea.Markus@jboss.com
*/
@Test(groups = "manual", testName = "test.fwk.TestNameVerifier")
public class TestNameVerifier {
String dir = Paths.get("src", "test", "java", "org", "infinispan").toString();
Pattern packageLinePattern = Pattern.compile("package org.infinispan[^;]*");
Pattern classLinePattern = Pattern.compile("(abstract\\s*)??(public\\s*)(abstract\\s*)??class [^\\s]*");
Pattern atAnnotationPattern = Pattern.compile("^\\s*@Test[^)]*");
Pattern testNamePattern = Pattern.compile("testName\\s*=\\s*\"[^\"]*\"");
String fileCache;
FilenameFilter javaFilter = new FilenameFilter() {
public boolean accept(File dir, String name) {
return !dir.getAbsolutePath().contains("testng") && name.endsWith(".java");
}
};
FileFilter onlyDirs = new FileFilter() {
public boolean accept(File pathname) {
return pathname.isDirectory() && !pathname.getName().equals("target");
}
};
@Test(groups = "manual", description = "Do not enable this unless you want your files to be updated with test names!!!")
public void process() throws Exception {
File[] javaFiles = getAllJavaFiles();
for (File file : javaFiles) {
if (needsUpdate(file)) {
System.out.println("Updating file: " + file.getAbsolutePath());
updateFile(file);
}
}
}
private void updateFile(File file) throws Exception {
String javaString = fileCache;
String testName = getTestName(javaString, file.getName());
String testNameStr = ", testName = \"" + testName + "\"";
javaString = replaceAtTestAnnotation(javaString, testNameStr);
persistNewFile(file, javaString);
}
private void persistNewFile(File file, String javaString) throws Exception {
if (file.delete()) {
System.out.println("!!!!!!!!!! error processing file " + file.getName());
return;
}
file.createNewFile();
PrintWriter writter = new PrintWriter(file);
writter.append(javaString);
writter.close();
}
private String replaceAtTestAnnotation(String javaString, String testNameStr) {
Matcher matcher = atAnnotationPattern.matcher(javaString);
boolean found = matcher.find();
assert found : javaString;
String theMatch = matcher.group();
return matcher.replaceFirst(theMatch + testNameStr);
}
private String getTestName(String javaString, String filename) {
String classNamePart = getClassNamePart(javaString, filename);
//abstract classes do not require test names
if (classNamePart.indexOf("abstract") >= 0) return null;
classNamePart = classNamePart.substring("public class ".length());
String packagePart = getPackagePart(javaString, filename);
//if the test is in org.infinispan package then make sure no . is prepended
String packagePrepend = ((packagePart != null) && (packagePart.length() > 0)) ? packagePart + "." : "";
return packagePrepend + classNamePart;
}
private String getClassNamePart(String javaString, String filename) {
Matcher matcher = classLinePattern.matcher(javaString);
boolean found = matcher.find();
assert found : "could not determine class name for file: " + filename;
return matcher.group();
}
private String getPackagePart(String javaString, String filename) {
Matcher matcher = packageLinePattern.matcher(javaString);
boolean found = matcher.find();
assert found : "Could not determine package name for file: " + filename;
String theMatch = matcher.group();
String partial = theMatch.substring("package org.infinispan".length());
if (partial.trim().length() == 0) return partial.trim();
return partial.substring(1);//drop the leading dot.
}
private boolean needsUpdate(File file) throws Exception {
String javaFileStr = getFileAsString(file);
if (javaFileStr.indexOf(" testName = \"") > 0) return false;
int atTestIndex = javaFileStr.indexOf("@Test");
int classDeclarationIndex = javaFileStr.indexOf("public class");
return atTestIndex > 0 && atTestIndex < classDeclarationIndex;
}
private String getFileAsString(File file) throws Exception {
StringBuilder builder = new StringBuilder();
BufferedReader fileReader = new BufferedReader(new FileReader(file));
String line;
while ((line = fileReader.readLine()) != null) {
builder.append(line + "\n");
}
this.fileCache = builder.toString();
return fileCache;
}
// Loop through the list of module names and pass it to the getFilesFromModule()
private File[] getAllJavaFiles() {
List<File> listOfFiles = getFiles();
return listOfFiles.toArray(new File[listOfFiles.size()]);
}
private void addJavaFiles(File file, ArrayList<File> result) {
assert file.isDirectory();
File[] javaFiles = file.listFiles(javaFilter);
// printFiles(javaFiles);
result.addAll(Arrays.asList(javaFiles));
for (File dir : file.listFiles(onlyDirs)) {
addJavaFiles(dir, result);
}
}
public void verifyTestName() throws Exception {
File[] javaFiles = getAllJavaFiles();
StringBuilder errorMessage = new StringBuilder("Following test class(es) do not have an appropriate test names: \n");
boolean hasErrors = false;
for (File file : javaFiles) {
String expectedName = incorrectTestName(file);
if (expectedName != null) {
errorMessage.append(file.getAbsoluteFile()).append(" (Expected test name '").append(expectedName).append("', was '").append(existingTestName(file)).append("'\n");
hasErrors = true;
}
}
assert !hasErrors : errorMessage.append("The rules for writing unit tests are described on http://www.jboss.org/community/wiki/ParallelTestSuite");
}
private String incorrectTestName(File file) throws Exception {
String fileAsStr = getFileAsString(file);
boolean containsTestAnnotation = atAnnotationPattern.matcher(fileAsStr).find();
if (!containsTestAnnotation) return null;
String expectedTestName = getTestName(fileAsStr, file.getName());
if (expectedTestName == null) return null; //this happens when the class is abstract
String existingTestName = existingTestName(file);
if (existingTestName == null || !existingTestName.equals(expectedTestName)) return expectedTestName;
return null;
}
private String existingTestName(File file) throws Exception {
String fileAsStr = getFileAsString(file);
boolean containsTestAnnotation = atAnnotationPattern.matcher(fileAsStr).find();
if (!containsTestAnnotation) return null;
String expectedTestName = getTestName(fileAsStr, file.getName());
if (expectedTestName == null) return null; //this happens when the class is abstract
Matcher matcher = this.testNamePattern.matcher(fileAsStr);
if (!matcher.find()) return expectedTestName;
String name = matcher.group().trim();
int firstIndexOfQuote = name.indexOf('"');
return name.substring(firstIndexOfQuote + 1, name.length() - 1);
}
private List<File> getFiles() {
File file = new File(".");
assert file.isDirectory();
ArrayList<File> result = new ArrayList<File>();
addJavaFiles(file, result);
return result;
}
}
| 7,911
| 38.168317
| 174
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/ToolUtils.java
|
package org.infinispan.tools;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.util.LinkedList;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import javax.xml.transform.OutputKeys;
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 org.w3c.dom.Document;
import org.w3c.dom.Node;
/**
* @author Tristan Tarrant <tristan@infinispan.org>
* @since 10.0
**/
public class ToolUtils {
public static final String EMPTY = "";
public static String getBaseFileName(String absoluteFileName) {
int slash = absoluteFileName.lastIndexOf(File.separatorChar);
int dot = absoluteFileName.lastIndexOf('.');
return absoluteFileName.substring(slash + 1, dot);
}
public static void printDocument(Document doc, OutputStream out) throws TransformerException {
TransformerFactory tf = TransformerFactory.newInstance();
Transformer transformer = tf.newTransformer();
transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "no");
transformer.setOutputProperty(OutputKeys.METHOD, "xml");
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
transformer.transform(new DOMSource(doc),
new StreamResult(new OutputStreamWriter(out, StandardCharsets.UTF_8)));
}
/**
* Given a parent {@link Node}, it search all the children and returns the first one to match the {@code tagName}.
*
* @param parent The parent {@link Node}.
* @param tagName The tag name to search for.
* @return The {@link Node} of the first child with {@code tagName} or {@code null} if it does not exist.
*/
public static Optional<Node> findFirstChildByTagName(Node parent, String tagName) {
for (Node child = parent.getFirstChild(); child != null; ) {
if (tagName.equals(child.getLocalName())) {
return Optional.of(child);
}
child = child.getNextSibling();
}
return Optional.empty();
}
/**
* Similar to {@link #findFirstChildByTagName(Node, String)} but it uses a {@code fullPath} to search the first child
* that matches it.
*
* @param parent The parent {@link Node}.
* @param fullPath The path where to search for the child.
* @return The {@link Optional} with the {@link Node} instance if found. Otherwise, an empty {@link Optional}.
*/
public static Optional<Node> findFirstChildByPath(Node parent, String fullPath) {
String[] paths = fullPath.split("/", 2);
for (Node child = parent.getFirstChild(); child != null; ) {
if (paths[0].equals(child.getLocalName())) {
return paths.length == 2 ?
findFirstChildByPath(child, paths[1]) :
Optional.of(child);
}
child = child.getNextSibling();
}
return Optional.empty();
}
/**
* Parses the "licenses.xml" files generated by the Wildfly licenses-plugin (maven projects) or license-reporter
* (nodejs projects).
*
* @param document The {@link Document} to parse.
* @return A {@link List} with all the {@link Dependency} found.
*/
public static List<Dependency> parseXMLDependencies(Document document) {
List<Dependency> dependencyList = new LinkedList<>();
Node dependencies = document.getElementsByTagName("dependencies").item(0);
for (Node dependency = dependencies.getFirstChild(); dependency != null; ) {
if ("dependency".equals(dependency.getLocalName())) {
Optional<Node> groupIdNode = findFirstChildByTagName(dependency, "groupId");
if (!groupIdNode.isPresent()) {
groupIdNode = findFirstChildByTagName(dependency, "packageName");
}
//groupId/packageName must be present all the time
//noinspection OptionalGetWithoutIsPresent
String groupId = groupIdNode.map(ToolUtils::textFromNode).get();
String artifactId = findFirstChildByTagName(dependency, "artifactId")
.map(ToolUtils::textFromNode)
.orElse(EMPTY);
String version = findFirstChildByTagName(dependency, "version")
.map(ToolUtils::textFromNode)
.orElse(EMPTY);
// Only include artifact if not in inclusive mode or if it's one of the included jars
dependencyList.add(new Dependency(groupId, artifactId, version, dependency));
}
dependency = dependency.getNextSibling();
}
return dependencyList;
}
/**
* Trims all the empty lines from a file.
*
* @param file The {@link File} to trim.
* @throws IOException If an i/o error occurs.
*/
public static void removeEmptyLinesFromFile(File file) throws IOException {
//it assumes a small file!
List<String> lines = Files.lines(file.toPath())
.filter(s -> !s.trim().isEmpty())
.collect(Collectors.toList());
try (FileWriter writer = new FileWriter(file)) {
for (String line : lines) {
writer.write(line);
writer.write(System.lineSeparator());
}
}
}
/**
* @return the text context trimmed of {@link Node}
*/
public static String textFromNode(Node node) {
assert node != null;
return node.getTextContent().trim();
}
}
| 5,839
| 37.421053
| 120
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/Dependency.java
|
package org.infinispan.tools;
import java.util.Objects;
import org.w3c.dom.Node;
/**
* Dependency from licenses.xml file.
* <p>
* It contains the group/artifact/version and the corresponding XML {@link Node}.
* <p>
* Note: the artifact is "empty" for NodeJS dependencies.
*
* @author Pedro Ruivo
* @since 12.0
*/
public class Dependency {
private final String group;
private final String artifact;
private final String version;
private final Node node;
Dependency(String group, String artifact, String version, Node node) {
this.group = group;
this.artifact = artifact;
this.version = version;
this.node = node;
}
public String getGroup() {
return group;
}
public String getArtifact() {
return artifact;
}
public String getVersion() {
return version;
}
public Node getNode() {
return node;
}
public String getId() {
return String.format("%s:%s", group, artifact);
}
@Override
public String toString() {
return "Dependency{" +
"group='" + group + '\'' +
", artifact='" + artifact + '\'' +
", version='" + version + '\'' +
'}';
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Dependency that = (Dependency) o;
return group.equals(that.group) &&
artifact.equals(that.artifact) &&
version.equals(that.version) &&
node.equals(that.node);
}
@Override
public int hashCode() {
return Objects.hash(group, artifact, version, node);
}
}
| 1,719
| 20.772152
| 81
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/StoreType.java
|
package org.infinispan.tools.store.migrator;
/**
* @author Ryan Emerson
* @since 9.0
*/
public enum StoreType {
JDBC_BINARY,
JDBC_MIXED,
JDBC_STRING,
LEVELDB,
ROCKSDB,
SINGLE_FILE_STORE,
SOFT_INDEX_FILE_STORE
}
| 236
| 13.8125
| 44
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/StoreProperties.java
|
package org.infinispan.tools.store.migrator;
import static org.infinispan.tools.store.migrator.Element.CACHE_NAME;
import static org.infinispan.tools.store.migrator.Element.MARSHALLER;
import static org.infinispan.tools.store.migrator.Element.SEGMENT_COUNT;
import static org.infinispan.tools.store.migrator.Element.TARGET;
import static org.infinispan.tools.store.migrator.Element.TYPE;
import static org.infinispan.tools.store.migrator.Element.VERSION;
import java.util.Properties;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.commons.util.Version;
public class StoreProperties{
private final Element root;
private final Properties properties;
private final StoreType storeType;
private final String cacheName;
private final int majorVersion;
public StoreProperties(StoreProperties properties) {
this.root = properties.root;
this.storeType = properties.storeType;
this.cacheName = properties.cacheName();
this.majorVersion = properties.majorVersion();
Properties clone = new Properties(properties.properties.size());
clone.putAll(properties.properties);
this.properties = clone;
}
public StoreProperties(Element root, Properties properties) {
this.root = root;
this.properties = properties;
validate();
this.storeType = StoreType.valueOf(get(TYPE).toUpperCase());
this.cacheName = get(CACHE_NAME);
this.majorVersion = majorVersion();
}
private int majorVersion() {
String version = get(VERSION);
if (version != null)
return Integer.parseInt(version);
return Integer.parseInt(Version.getMajor());
}
public boolean isTargetStore() {
return root == TARGET;
}
public int getMajorVersion() {
return majorVersion;
}
public boolean isCurrentMajorVersion() {
return Integer.parseInt(Version.getMajor()) == majorVersion;
}
public String cacheName() {
return cacheName;
}
public StoreType storeType() {
return storeType;
}
public boolean isSegmented() {
String segmentCount = get(SEGMENT_COUNT);
if (segmentCount == null)
return false;
return Integer.parseInt(segmentCount) > 0;
}
public void put(String value, Element... elements) {
properties.put(key(elements), value);
}
public String get(Element... elements) {
return properties.getProperty(key(elements));
}
public String key(Element... elements) {
StringBuilder sb = new StringBuilder(root.toString().toLowerCase());
sb.append(".");
for (int i = 0; i < elements.length; i++) {
sb.append(elements[i].toString());
if (i != elements.length - 1) sb.append(".");
}
return sb.toString();
}
public void required(String... required) {
for (String prop : required) {
if (properties.get(prop) == null) {
String msg = String.format("The property %s must be specified.", prop);
throw new CacheConfigurationException(msg);
}
}
}
public void required(Element... required) {
for (Element prop : required) {
if (properties.get(key(prop)) == null) {
String msg = String.format("The property '%s' must be specified.", key(prop));
throw new CacheConfigurationException(msg);
}
}
}
private void validate() {
required(TYPE);
required(CACHE_NAME);
if (get(MARSHALLER, TYPE) != null) {
throw new CacheConfigurationException(String.format("Property '%s' has been removed, please specify %s instead.",
key(MARSHALLER, TYPE), key(VERSION)));
}
}
}
| 3,712
| 28.943548
| 122
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/Element.java
|
package org.infinispan.tools.store.migrator;
/**
* @author Ryan Emerson
* @since 9.0
*/
public enum Element {
ALLOW_LIST("allow-list"),
BATCH("batch"),
BINARY("binary"),
CACHE_NAME("cache_name"),
CLASS("class"),
CLASSES("classes"),
COMPRESSION("compression"),
CONNECTION_URL("connection_url"),
CONNECTION_POOL("connection_pool"),
CONTEXT_INITIALIZERS("context-initializers"),
DATA("data"),
DB("db"),
DIALECT("dialect"),
DISABLE_INDEXING("disable_indexing"),
DISABLE_UPSERT("disable_upsert"),
DRIVER_CLASS("driver_class"),
EXTERNALIZERS("externalizers"),
ID("id"),
INDEX_LOCATION("index_location"),
KEY_TO_STRING_MAPPER("key_to_string_mapper"),
LOCATION("location"),
MAJOR_VERSION("major_version"),
MINOR_VERSION("minor_version"),
MARSHALLER("marshaller"),
NAME("name"),
PASSWORD("password"),
REGEXPS("regexps"),
SOURCE("source"),
SEGMENT("segment"),
SEGMENT_COUNT("segment_count"),
SIZE("size"),
STRING("string"),
TARGET("target"),
TABLE("table"),
TABLE_NAME_PREFIX("table_name_prefix"),
TIMESTAMP("timestamp"),
TYPE("type"),
USERNAME("username"),
VERSION("version");
private final String name;
Element(final String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
}
| 1,353
| 21.566667
| 48
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/SegmentedFileStoreReader.java
|
package org.infinispan.tools.store.migrator;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import static org.infinispan.tools.store.migrator.Element.SEGMENT_COUNT;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.infinispan.persistence.spi.MarshallableEntry;
public class SegmentedFileStoreReader implements StoreIterator {
final int numSegments;
final Function<StoreProperties, StoreIterator> storeFactory;
final List<StoreIterator> storeIterators;
public SegmentedFileStoreReader(StoreProperties properties, Function<StoreProperties, StoreIterator> storeFactory) {
properties.required(SEGMENT_COUNT);
this.numSegments = Integer.parseInt(properties.get(SEGMENT_COUNT));
this.storeFactory = storeFactory;
Path root = Path.of(properties.get(LOCATION));
this.storeIterators = new ArrayList<>(numSegments);
for (int i = 0; i < numSegments; i++) {
StoreProperties p = new StoreProperties(properties);
String segment = root.resolve(Integer.toString(i)).toString();
p.put(segment, LOCATION);
StoreIterator it = storeFactory.apply(p);
storeIterators.add(it);
}
}
@Override
public void close() throws Exception {
for (StoreIterator it : storeIterators)
it.close();
}
@Override
public Iterator<MarshallableEntry> iterator() {
return new SegmentedStoreIterator();
}
class SegmentedStoreIterator implements Iterator<MarshallableEntry> {
int currentSegment;
List<Iterator<MarshallableEntry>> entryIterators = storeIterators.stream()
.map(Iterable::iterator)
.collect(Collectors.toList());
@Override
public boolean hasNext() {
int nextSegment = currentSegment;
while (nextSegment < numSegments) {
if (entryIterators.get(nextSegment).hasNext())
return true;
nextSegment++;
}
return false;
}
@Override
public MarshallableEntry next() {
while (currentSegment < numSegments) {
Iterator<MarshallableEntry> it = entryIterators.get(currentSegment);
if (it.hasNext()) {
return it.next();
}
currentSegment++;
}
throw new NoSuchElementException();
}
}
}
| 2,532
| 29.890244
| 119
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/StoreIteratorFactory.java
|
package org.infinispan.tools.store.migrator;
import static org.infinispan.tools.store.migrator.Element.SOURCE;
import static org.infinispan.tools.store.migrator.StoreType.SINGLE_FILE_STORE;
import java.util.Properties;
import org.infinispan.tools.store.migrator.file.SingleFileStoreReader;
import org.infinispan.tools.store.migrator.file.SoftIndexFileStoreIterator;
import org.infinispan.tools.store.migrator.jdbc.JdbcStoreReader;
import org.infinispan.tools.store.migrator.rocksdb.RocksDBReader;
class StoreIteratorFactory {
static StoreIterator get(Properties properties) {
StoreProperties props = new StoreProperties(SOURCE, properties);
StoreType type = props.storeType();
switch (type) {
case JDBC_BINARY:
case JDBC_MIXED:
case JDBC_STRING:
return new JdbcStoreReader(props);
}
if (props.isSegmented()) {
if (SINGLE_FILE_STORE == type)
return new SegmentedFileStoreReader(props, SingleFileStoreReader::new);
throw new IllegalArgumentException(String.format("Segmented %s source store not supported", type));
}
switch (type) {
case LEVELDB:
case ROCKSDB:
return new RocksDBReader(props);
case SINGLE_FILE_STORE:
return new SingleFileStoreReader(props);
case SOFT_INDEX_FILE_STORE:
return new SoftIndexFileStoreIterator(props);
}
return null;
}
}
| 1,459
| 32.181818
| 108
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/StoreMigrator.java
|
package org.infinispan.tools.store.migrator;
import static org.infinispan.tools.store.migrator.Element.BATCH;
import static org.infinispan.tools.store.migrator.Element.SIZE;
import java.io.FileReader;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import java.util.stream.Collectors;
import jakarta.transaction.Status;
import jakarta.transaction.TransactionManager;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.io.ByteBufferImpl;
import org.infinispan.commons.marshall.AdvancedExternalizer;
import org.infinispan.commons.util.Version;
import org.infinispan.container.entries.ImmortalCacheEntry;
import org.infinispan.container.entries.ImmortalCacheValue;
import org.infinispan.container.entries.InternalCacheEntry;
import org.infinispan.container.entries.InternalCacheValue;
import org.infinispan.container.entries.MortalCacheEntry;
import org.infinispan.container.entries.MortalCacheValue;
import org.infinispan.container.entries.TransientCacheEntry;
import org.infinispan.container.entries.TransientCacheValue;
import org.infinispan.container.entries.TransientMortalCacheEntry;
import org.infinispan.container.entries.TransientMortalCacheValue;
import org.infinispan.container.entries.metadata.MetadataImmortalCacheEntry;
import org.infinispan.container.entries.metadata.MetadataImmortalCacheValue;
import org.infinispan.container.entries.metadata.MetadataMortalCacheEntry;
import org.infinispan.container.entries.metadata.MetadataMortalCacheValue;
import org.infinispan.container.entries.metadata.MetadataTransientCacheEntry;
import org.infinispan.container.entries.metadata.MetadataTransientCacheValue;
import org.infinispan.container.entries.metadata.MetadataTransientMortalCacheEntry;
import org.infinispan.container.entries.metadata.MetadataTransientMortalCacheValue;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.metadata.impl.InternalMetadataImpl;
import org.infinispan.persistence.spi.MarshallableEntry;
import org.infinispan.util.KeyValuePair;
/**
* @author Ryan Emerson
* @since 9.0
*/
public class StoreMigrator {
private static final int DEFAULT_BATCH_SIZE = 1;
// A list of all internal classes that were previously marshallable, but we no longer provide
// guarantees over byte compatibility in future versions
private static final Set<Class<?>> INTERNAL_BLACKLIST = new HashSet<>();
static {
INTERNAL_BLACKLIST.add(ArrayList.class);
INTERNAL_BLACKLIST.add(Collections.singletonList(1).getClass());
INTERNAL_BLACKLIST.add(Collections.singletonMap(1,1).getClass());
INTERNAL_BLACKLIST.add(Collections.singleton(1).getClass());
INTERNAL_BLACKLIST.add(ByteBufferImpl.class);
INTERNAL_BLACKLIST.add(KeyValuePair.class);
INTERNAL_BLACKLIST.add(InternalCacheEntry.class);
INTERNAL_BLACKLIST.add(InternalCacheValue.class);
INTERNAL_BLACKLIST.add(InternalMetadataImpl.class);
INTERNAL_BLACKLIST.add(ImmortalCacheEntry.class);
INTERNAL_BLACKLIST.add(MortalCacheEntry.class);
INTERNAL_BLACKLIST.add(TransientCacheEntry.class);
INTERNAL_BLACKLIST.add(TransientMortalCacheEntry.class);
INTERNAL_BLACKLIST.add(ImmortalCacheValue.class);
INTERNAL_BLACKLIST.add(MortalCacheValue.class);
INTERNAL_BLACKLIST.add(TransientCacheValue.class);
INTERNAL_BLACKLIST.add(TransientMortalCacheValue.class);
INTERNAL_BLACKLIST.add(MetadataImmortalCacheEntry.class);
INTERNAL_BLACKLIST.add(MetadataMortalCacheEntry.class);
INTERNAL_BLACKLIST.add(MetadataTransientCacheEntry.class);
INTERNAL_BLACKLIST.add(MetadataTransientMortalCacheEntry.class);
INTERNAL_BLACKLIST.add(MetadataImmortalCacheValue.class);
INTERNAL_BLACKLIST.add(MetadataMortalCacheValue.class);
INTERNAL_BLACKLIST.add(MetadataTransientCacheValue.class);
INTERNAL_BLACKLIST.add(MetadataTransientMortalCacheValue.class);
}
private final Properties properties;
public StoreMigrator(Properties properties) {
this.properties = properties;
}
public void run() throws Exception {
run(false);
}
public void run(boolean output) throws Exception {
String batchSizeProp = properties.getProperty(BATCH + "." + SIZE);
int batchLimit = batchSizeProp != null ? Integer.parseInt(batchSizeProp) : DEFAULT_BATCH_SIZE;
try (EmbeddedCacheManager manager = TargetStoreFactory.getCacheManager(properties);
StoreIterator sourceReader = StoreIteratorFactory.get(properties)) {
Map<Integer, AdvancedExternalizer<?>> externalizers = manager.getCacheManagerConfiguration().serialization().advancedExternalizers();
Set<Class> externalizerClasses = externalizers.values().stream()
.flatMap(e -> e.getTypeClasses().stream())
.collect(Collectors.toSet());
AdvancedCache targetCache = TargetStoreFactory.getTargetCache(manager, properties);
// Txs used so that writes to the DB are batched. Migrator will always operate locally Tx overhead should be negligible
TransactionManager tm = targetCache.getTransactionManager();
int txBatchSize = 0;
for (MarshallableEntry entry : sourceReader) {
if (warnAndIgnoreInternalClasses(entry.getKey(), externalizerClasses, output) ||
warnAndIgnoreInternalClasses(entry.getValue(), externalizerClasses, output))
continue;
if (txBatchSize == 0)
tm.begin();
targetCache.put(entry.getKey(), entry.getValue());
txBatchSize++;
if (txBatchSize == batchLimit) {
txBatchSize = 0;
tm.commit();
}
}
if (tm.getStatus() == Status.STATUS_ACTIVE) tm.commit();
}
}
public static void main(String[] args) throws Exception {
if (args.length != 1) {
version(System.out);
System.out.println("Usage: StoreMigrator migrator.properties");
System.exit(1);
}
Properties properties = new Properties();
properties.load(new FileReader(args[0]));
new StoreMigrator(properties).run(true);
}
private static void version(PrintStream out) {
out.printf("%s Store Migrator %s%n", Version.getBrandName(), Version.getBrandVersion());
out.println("Copyright (C) Red Hat Inc. and/or its affiliates and other contributors");
out.println("License Apache License, v. 2.0. http://www.apache.org/licenses/LICENSE-2.0");
}
private boolean warnAndIgnoreInternalClasses(Object o, Set<Class> extClass, boolean output) {
Class clazz = o.getClass();
boolean isBlackListed = !extClass.contains(clazz) && !clazz.isPrimitive() && INTERNAL_BLACKLIST.stream().anyMatch(c -> c.isAssignableFrom(clazz));
if (isBlackListed) {
if (output) {
System.err.println(String.format("Ignoring entry with class %s as this is an internal Infinispan class that" +
"should not be used by users. If you really require this class, it's possible to explicitly provide the" +
"associated AdvancedExternalizer via the property 'target.marshaller.externalizers=Externalizer.class`", o.getClass()));
}
return true;
}
return false;
}
}
| 7,419
| 45.086957
| 152
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/TargetStoreFactory.java
|
package org.infinispan.tools.store.migrator;
import static org.infinispan.tools.store.migrator.Element.COMPRESSION;
import static org.infinispan.tools.store.migrator.Element.INDEX_LOCATION;
import static org.infinispan.tools.store.migrator.Element.LOCATION;
import static org.infinispan.tools.store.migrator.Element.SEGMENT_COUNT;
import static org.infinispan.tools.store.migrator.Element.TARGET;
import static org.infinispan.tools.store.migrator.Element.TYPE;
import java.util.Properties;
import org.infinispan.AdvancedCache;
import org.infinispan.commons.CacheConfigurationException;
import org.infinispan.configuration.cache.ConfigurationBuilder;
import org.infinispan.configuration.cache.PersistenceConfigurationBuilder;
import org.infinispan.configuration.cache.SingleFileStoreConfigurationBuilder;
import org.infinispan.configuration.cache.StoreConfigurationBuilder;
import org.infinispan.configuration.parsing.ConfigurationBuilderHolder;
import org.infinispan.context.Flag;
import org.infinispan.manager.DefaultCacheManager;
import org.infinispan.manager.EmbeddedCacheManager;
import org.infinispan.persistence.jdbc.configuration.JdbcStringBasedStoreConfigurationBuilder;
import org.infinispan.persistence.rocksdb.configuration.CompressionType;
import org.infinispan.persistence.rocksdb.configuration.RocksDBStoreConfigurationBuilder;
import org.infinispan.persistence.sifs.configuration.SoftIndexFileStoreConfigurationBuilder;
import org.infinispan.tools.store.migrator.jdbc.JdbcConfigurationUtil;
import org.infinispan.tools.store.migrator.marshaller.SerializationConfigUtil;
import org.infinispan.transaction.TransactionMode;
import org.infinispan.transaction.lookup.EmbeddedTransactionManagerLookup;
class TargetStoreFactory {
private static final String DEFAULT_CACHE_NAME = StoreMigrator.class.getName();
static EmbeddedCacheManager getCacheManager(Properties properties) {
ConfigurationBuilderHolder holder = new ConfigurationBuilderHolder();
holder.getGlobalConfigurationBuilder().defaultCacheName(DEFAULT_CACHE_NAME);
StoreProperties props = new StoreProperties(TARGET, properties);
SerializationConfigUtil.configureSerialization(props, holder.getGlobalConfigurationBuilder().serialization());
holder.getNamedConfigurationBuilders().put(DEFAULT_CACHE_NAME, new ConfigurationBuilder());
return new DefaultCacheManager(holder, true);
}
static AdvancedCache getTargetCache(EmbeddedCacheManager manager, Properties properties) {
StoreProperties props = new StoreProperties(TARGET, properties);
ConfigurationBuilder configBuilder = new ConfigurationBuilder();
String segmentCountString = props.get(SEGMENT_COUNT);
// 0 means not enabled
int segmentCount = 0;
if (segmentCountString != null) {
segmentCount = Integer.parseInt(segmentCountString);
if (segmentCount < 0) {
throw new IllegalArgumentException("Segment count must be > 0");
}
}
if (segmentCount > 0) {
configBuilder.clustering().hash().numSegments(segmentCount);
}
configBuilder.persistence().addStore(getInitializedStoreBuilder(props))
.purgeOnStartup(true)
.segmented(segmentCount > 0);
configBuilder.invocationBatching().transaction()
.transactionMode(TransactionMode.TRANSACTIONAL)
.transactionManagerLookup(new EmbeddedTransactionManagerLookup());
String cacheName = props.cacheName();
manager.defineConfiguration(cacheName, configBuilder.build());
return manager.getCache(cacheName).getAdvancedCache().withFlags(Flag.SKIP_CACHE_LOAD);
}
private static StoreConfigurationBuilder getInitializedStoreBuilder(StoreProperties props) {
PersistenceConfigurationBuilder persistenceBuilder = new ConfigurationBuilder().persistence();
StoreType storeType = StoreType.valueOf(props.get(TYPE).toUpperCase());
switch (storeType) {
case LEVELDB:
case JDBC_BINARY:
case JDBC_MIXED:
throw new CacheConfigurationException(String.format("%s cannot be a target store as it no longer exists", storeType));
case JDBC_STRING:
return JdbcConfigurationUtil.configureStore(props, new JdbcStringBasedStoreConfigurationBuilder(persistenceBuilder));
case ROCKSDB:
props.required(LOCATION);
String location = props.get(LOCATION);
RocksDBStoreConfigurationBuilder builder = new RocksDBStoreConfigurationBuilder(persistenceBuilder);
builder.location(location).expiredLocation(location + "-expired-");
String compressionType = props.get(COMPRESSION);
if (compressionType != null)
builder.compressionType(CompressionType.valueOf(compressionType.toUpperCase()));
return builder;
case SINGLE_FILE_STORE:
props.required(LOCATION);
return new SingleFileStoreConfigurationBuilder(persistenceBuilder).location(props.get(LOCATION));
case SOFT_INDEX_FILE_STORE:
props.required(LOCATION);
props.required(INDEX_LOCATION);
return new SoftIndexFileStoreConfigurationBuilder(persistenceBuilder)
.dataLocation(props.get(LOCATION)).indexLocation(props.get(INDEX_LOCATION));
default:
throw new CacheConfigurationException(String.format("Unknown store type '%s'", storeType));
}
}
}
| 5,471
| 49.666667
| 130
|
java
|
null |
infinispan-main/tools/src/main/java/org/infinispan/tools/store/migrator/StoreIterator.java
|
package org.infinispan.tools.store.migrator;
import org.infinispan.persistence.spi.MarshallableEntry;
public interface StoreIterator extends Iterable<MarshallableEntry>, AutoCloseable {
}
| 190
| 26.285714
| 83
|
java
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.