Introduce migrate-h2-caches command
Introduce SSH command to migrate existing persistent H2 caches to
chronicle-map.
Feature: Issue 13989
Change-Id: I16125daf91fe7afcd632dfa417610e93c8aacfea
diff --git a/BUILD b/BUILD
index 52f23ec..7859dc2 100644
--- a/BUILD
+++ b/BUILD
@@ -50,6 +50,9 @@
deps = [
":cache-chroniclemap__plugin",
":chroniclemap-test-lib",
+ "//java/com/google/gerrit/server/cache/h2",
+ "//java/com/google/gerrit/server/cache/serialize",
+ "//proto:cache_java_proto",
],
)
diff --git a/README.md b/README.md
index 2befb1a..da6108d 100644
--- a/README.md
+++ b/README.md
@@ -23,4 +23,8 @@
```
For further information and supported options, refer to [config](config.md)
-documentation.
\ No newline at end of file
+documentation.
+
+## Migration from H2 caches
+
+You can check how to migrate from H2 to chronicle-map [here](./migration.md).
\ No newline at end of file
diff --git a/migration.md b/migration.md
new file mode 100644
index 0000000..e182d85
--- /dev/null
+++ b/migration.md
@@ -0,0 +1,89 @@
+## Migration from H2 Caches
+
+This module provides an SSH command to help converting existing cache from H2 to
+chronicle-map, which requires the `Administrate Server` capability to be
+executed.
+
+The migration must be executed _before_ switching to use chronicle-map, while
+Gerrit cache is still backed by H2.
+
+The migration can be run online without any disruption of the Gerrit server.
+However note that since the migration perform many, sequential reads from the H2
+database, it will participate to the overall database load, so you should test
+accordingly.
+
+The migration should be performed as follows:
+
+* Copy `cache-chroniclemap.jar` file in the `plugins/` directory.
+* Wait for the pluginLoader to load the new plugin. You will see an entry in
+the `error_log`:
+
+```
+INFO com.google.gerrit.server.plugins.PluginLoader : Loaded plugin cache-chroniclemap
+```
+
+* You can now run the migration
+
+```bash
+ssh -p 29418 admin@<gerrit-server> cache-chroniclemap migrate-h2-caches \
+ [--max-bloat-factor FACTOR] \
+ [--size-multiplier MULTIPLIER]
+```
+
+This might require some time, depending on the size of the H2 caches and it will
+terminate with the output of the configuration that should be places in
+`etc/gerrit.config`in order to leverage the newly created caches correctly.
+
+For example:
+
+```Migrating H2 caches to Chronicle-Map...
+ * Size multiplier: 1
+ * Max Bloat Factor: 1
+ [diff]: 100% (216/216)
+ [persisted_projects]: 100% (3/3)
+ [diff_summary]: 100% (216/216)
+ [accounts]: 100% (2/2)
+ [mergeability]: 100% (2444/2444)
+ Complete!
+
+ ****************************
+ ** Chronicle-map template **
+ ****************************
+
+ [cache "diff"]
+ maxEntries = 216
+ avgKeySize = 188
+ avgValueSize = 796
+ maxBloatFactor = 1
+ [cache "persisted_projects"]
+ maxEntries = 3
+ avgKeySize = 80
+ avgValueSize = 4087
+ maxBloatFactor = 1
+ [cache "diff_summary"]
+ maxEntries = 216
+ avgKeySize = 192
+ avgValueSize = 254
+ maxBloatFactor = 1
+ [cache "accounts"]
+ maxEntries = 2
+ avgKeySize = 52
+ avgValueSize = 194
+ maxBloatFactor = 1
+ [cache "mergeability"]
+ maxEntries = 2444
+ avgKeySize = 150
+ avgValueSize = 20
+ maxBloatFactor = 1
+```
+
+Optionally the SSH command can receive the following additional arguments:
+
+* --max-bloat-factor (-m) FACTOR
+
+maximum number of times chronicle-map cache is allowed to grow in size.
+*default:3*
+
+* --size-multiplier (-s) MULTIPLIER
+Multiplicative factor for the number of entries allowed in chronicle-map.
+*default:3*
\ No newline at end of file
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheConfig.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheConfig.java
index 2fc54d3..6cdc8a7 100644
--- a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheConfig.java
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheConfig.java
@@ -43,6 +43,16 @@
@Assisted File persistedFile,
@Nullable @Assisted("ExpireAfterWrite") Duration expireAfterWrite,
@Nullable @Assisted("RefreshAfterWrite") Duration refreshAfterWrite);
+
+ ChronicleMapCacheConfig createWithValues(
+ @Assisted("ConfigKey") String configKey,
+ @Assisted File persistedFile,
+ @Nullable @Assisted("ExpireAfterWrite") Duration expireAfterWrite,
+ @Nullable @Assisted("RefreshAfterWrite") Duration refreshAfterWrite,
+ @Assisted("maxEntries") long maxEntries,
+ @Assisted("avgKeySize") long avgKeySize,
+ @Assisted("avgValueSize") long avgValueSize,
+ @Assisted("maxBloatFactor") int maxBloatFactor);
}
@AssistedInject
@@ -52,14 +62,37 @@
@Assisted File persistedFile,
@Nullable @Assisted("ExpireAfterWrite") Duration expireAfterWrite,
@Nullable @Assisted("RefreshAfterWrite") Duration refreshAfterWrite) {
+
+ this(
+ cfg,
+ configKey,
+ persistedFile,
+ expireAfterWrite,
+ refreshAfterWrite,
+ cfg.getLong("cache", configKey, "maxEntries", Defaults.maxEntriesFor(configKey)),
+ cfg.getLong("cache", configKey, "avgKeySize", Defaults.averageKeySizeFor(configKey)),
+ cfg.getLong("cache", configKey, "avgValueSize", Defaults.avgValueSizeFor(configKey)),
+ cfg.getInt("cache", configKey, "maxBloatFactor", Defaults.maxBloatFactorFor(configKey)));
+ }
+
+ @AssistedInject
+ ChronicleMapCacheConfig(
+ @GerritServerConfig Config cfg,
+ @Assisted("ConfigKey") String configKey,
+ @Assisted File persistedFile,
+ @Nullable @Assisted("ExpireAfterWrite") Duration expireAfterWrite,
+ @Nullable @Assisted("RefreshAfterWrite") Duration refreshAfterWrite,
+ @Assisted("maxEntries") long maxEntries,
+ @Assisted("avgKeySize") long avgKeySize,
+ @Assisted("avgValueSize") long avgValueSize,
+ @Assisted("maxBloatFactor") int maxBloatFactor) {
this.persistedFile = persistedFile;
- this.maxEntries =
- cfg.getLong("cache", configKey, "maxEntries", Defaults.maxEntriesFor(configKey));
- this.averageKeySize =
- cfg.getLong("cache", configKey, "avgKeySize", Defaults.averageKeySizeFor(configKey));
- this.averageValueSize =
- cfg.getLong("cache", configKey, "avgValueSize", Defaults.avgValueSizeFor(configKey));
+ this.maxEntries = maxEntries;
+ this.averageKeySize = avgKeySize;
+ this.averageValueSize = avgValueSize;
+ this.maxBloatFactor = maxBloatFactor;
+
this.expireAfterWrite =
Duration.ofSeconds(
ConfigUtil.getTimeUnit(
@@ -74,9 +107,6 @@
toSeconds(refreshAfterWrite),
SECONDS));
- this.maxBloatFactor =
- cfg.getInt("cache", configKey, "maxBloatFactor", Defaults.maxBloatFactorFor(configKey));
-
this.percentageFreeSpaceEvictionThreshold =
cfg.getInt(
"cache",
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
index 999775d..e85e553 100644
--- a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/ChronicleMapCacheImpl.java
@@ -23,6 +23,7 @@
import com.google.gerrit.server.cache.PersistentCacheDef;
import com.google.gerrit.server.util.time.TimeUtil;
import java.io.IOException;
+import java.sql.Timestamp;
import java.time.Duration;
import java.time.Instant;
import java.util.concurrent.Callable;
@@ -229,6 +230,12 @@
return v;
}
+ @SuppressWarnings("unchecked")
+ public void putUnchecked(Object key, Object value, Timestamp created) {
+ TimedValue<?> wrapped = new TimedValue<>(value, created.toInstant().toEpochMilli());
+ store.put((K) key, (TimedValue<V>) wrapped);
+ }
+
@Override
public void put(K key, V val) {
TimedValue<V> wrapped = new TimedValue<>(val);
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/MigrateH2Caches.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/MigrateH2Caches.java
new file mode 100644
index 0000000..e36d1e0
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/MigrateH2Caches.java
@@ -0,0 +1,216 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.googlesource.gerrit.modules.cache.chroniclemap;
+
+import com.google.gerrit.common.data.GlobalCapability;
+import com.google.gerrit.extensions.annotations.RequiresCapability;
+import com.google.gerrit.metrics.DisabledMetricMaker;
+import com.google.gerrit.server.cache.PersistentCacheDef;
+import com.google.gerrit.server.cache.serialize.CacheSerializer;
+import com.google.gerrit.server.cache.serialize.StringCacheSerializer;
+import com.google.gerrit.server.config.GerritServerConfig;
+import com.google.gerrit.server.config.SitePaths;
+import com.google.gerrit.sshd.CommandMetaData;
+import com.google.inject.Binding;
+import com.google.inject.Inject;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.googlesource.gerrit.modules.cache.chroniclemap.command.H2AggregateData;
+import com.googlesource.gerrit.modules.cache.chroniclemap.command.H2CacheSshCommand;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Timestamp;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import org.eclipse.jgit.lib.Config;
+import org.eclipse.jgit.lib.TextProgressMonitor;
+import org.h2.Driver;
+import org.kohsuke.args4j.Option;
+
+@RequiresCapability(GlobalCapability.ADMINISTRATE_SERVER)
+@CommandMetaData(name = "migrate-h2-caches", description = "Migrate H2 caches to Chronicle-Map")
+public class MigrateH2Caches extends H2CacheSshCommand {
+
+ private final Injector injector;
+ private final ChronicleMapCacheConfig.Factory configFactory;
+
+ protected static int DEFAULT_SIZE_MULTIPLIER = 3;
+ protected static int DEFAULT_MAX_BLOAT_FACTOR = 3;
+
+ @Option(
+ name = "--size-multiplier",
+ aliases = {"-s"},
+ metaVar = "MULTIPLIER",
+ usage = "Multiplicative factor for the number of entries allowed in chronicle-map")
+ private int sizeMultiplier = DEFAULT_SIZE_MULTIPLIER;
+
+ @Option(
+ name = "--max-bloat-factor",
+ aliases = {"-m"},
+ metaVar = "FACTOR",
+ usage = "maximum number of times chronicle-map cache is allowed to grow in size")
+ private int maxBloatFactor = DEFAULT_MAX_BLOAT_FACTOR;
+
+ @Inject
+ MigrateH2Caches(
+ @GerritServerConfig Config cfg,
+ SitePaths site,
+ Injector injector,
+ ChronicleMapCacheConfig.Factory configFactory) {
+ this.injector = injector;
+ this.configFactory = configFactory;
+ this.site = site;
+ this.gerritConfig = cfg;
+ }
+
+ @Override
+ protected void run() throws Exception {
+ Optional<Path> cacheDir = getCacheDir();
+
+ if (!cacheDir.isPresent()) {
+ throw die("Cannot run migration, cache directory is not configured");
+ }
+
+ stdout.println("Migrating H2 caches to Chronicle-Map...");
+ stdout.println("* Size multiplier: " + sizeMultiplier);
+ stdout.println("* Max Bloat Factor: " + maxBloatFactor);
+ Set<PersistentCacheDef<?, ?>> cacheDefs = getAllBoundPersistentCacheDefs();
+
+ Config outputChronicleMapConfig = new Config();
+
+ for (PersistentCacheDef<?, ?> in : cacheDefs) {
+ Optional<Path> h2CacheFile = getH2CacheFile(cacheDir.get(), in.name());
+
+ if (h2CacheFile.isPresent()) {
+ H2AggregateData stats = getStats(h2CacheFile.get());
+
+ if (!stats.isEmpty()) {
+ ChronicleMapCacheImpl<?, ?> chronicleMapCache =
+ new ChronicleMapCacheImpl<>(
+ in,
+ makeChronicleMapConfig(
+ configFactory, cacheDir.get(), in, stats, sizeMultiplier, maxBloatFactor),
+ null,
+ new DisabledMetricMaker());
+ doMigrate(h2CacheFile.get(), in, chronicleMapCache, stats.size());
+ chronicleMapCache.close();
+ appendBloatedConfig(outputChronicleMapConfig, stats);
+ }
+ }
+ }
+ stdout.println("Complete!");
+ stdout.println();
+ stdout.println("****************************");
+ stdout.println("** Chronicle-map template **");
+ stdout.println("****************************");
+ stdout.println();
+ stdout.println(outputChronicleMapConfig.toText());
+ }
+
+ protected static ChronicleMapCacheConfig makeChronicleMapConfig(
+ ChronicleMapCacheConfig.Factory configFactory,
+ Path cacheDir,
+ PersistentCacheDef<?, ?> in,
+ H2AggregateData stats,
+ int sizeMultiplier,
+ int maxBloatFactor) {
+ return configFactory.createWithValues(
+ in.configKey(),
+ ChronicleMapCacheFactory.fileName(cacheDir, in.name(), in.version()),
+ in.expireAfterWrite(),
+ in.refreshAfterWrite(),
+ stats.size() * sizeMultiplier,
+ stats.avgKeySize(),
+ stats.avgValueSize(),
+ maxBloatFactor);
+ }
+
+ private void doMigrate(
+ Path h2File,
+ PersistentCacheDef<?, ?> in,
+ ChronicleMapCacheImpl<?, ?> chronicleMapCache,
+ long totalEntries)
+ throws UnloggedFailure {
+
+ TextProgressMonitor cacheProgress = new TextProgressMonitor(stdout);
+ cacheProgress.beginTask(String.format("[%s]", in.name()), (int) totalEntries);
+
+ String url = jdbcUrl(h2File);
+ try (Connection conn = Driver.load().connect(url, null)) {
+ PreparedStatement preparedStatement =
+ conn.prepareStatement("SELECT k, v, created FROM data WHERE version=?");
+ preparedStatement.setInt(1, in.version());
+
+ try (ResultSet r = preparedStatement.executeQuery()) {
+ while (r.next()) {
+ Object key = in.keySerializer().deserialize(getBytes(r, 1, in.keySerializer()));
+ Object value = in.valueSerializer().deserialize(getBytes(r, 2, in.valueSerializer()));
+ Timestamp created = r.getTimestamp(3);
+ chronicleMapCache.putUnchecked(key, value, created);
+ cacheProgress.update(1);
+ }
+ }
+
+ } catch (Exception e) {
+ String message = String.format("FATAL: error migrating %s H2 cache", in.name());
+ logger.atSevere().withCause(e).log(message);
+ stderr.println(message);
+ throw die(e);
+ }
+ cacheProgress.endTask();
+ }
+
+ private Set<PersistentCacheDef<?, ?>> getAllBoundPersistentCacheDefs() {
+ Set<PersistentCacheDef<?, ?>> cacheDefs = new HashSet<>();
+ for (Map.Entry<Key<?>, Binding<?>> entry : injector.getParent().getAllBindings().entrySet()) {
+ final Class<?> rawType = entry.getKey().getTypeLiteral().getRawType();
+ if ("PersistentCacheDef".equals(rawType.getSimpleName())) {
+ cacheDefs.add((PersistentCacheDef<?, ?>) entry.getValue().getProvider().get());
+ }
+ }
+ return cacheDefs;
+ }
+
+ private byte[] getBytes(ResultSet r, int columnIndex, CacheSerializer<?> serializer)
+ throws SQLException {
+ return (serializer instanceof StringCacheSerializer)
+ ? r.getString(columnIndex).getBytes()
+ : r.getBytes(columnIndex);
+ }
+
+ private Optional<Path> getH2CacheFile(Path cacheDir, String name) {
+ Path h2CacheFile = cacheDir.resolve(String.format("%s.%s", name, H2_SUFFIX));
+ if (Files.exists(h2CacheFile)) {
+ return Optional.of(h2CacheFile);
+ }
+ return Optional.empty();
+ }
+
+ private void appendBloatedConfig(Config config, H2AggregateData stats) {
+ appendToConfig(
+ config,
+ H2AggregateData.create(
+ stats.cacheName(),
+ stats.size() * sizeMultiplier,
+ stats.avgKeySize(),
+ stats.avgValueSize()));
+ config.setLong("cache", stats.cacheName(), "maxBloatFactor", maxBloatFactor);
+ }
+}
diff --git a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/command/SSHCommandModule.java b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/command/SSHCommandModule.java
index 038c177..a1cd840 100644
--- a/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/command/SSHCommandModule.java
+++ b/src/main/java/com/googlesource/gerrit/modules/cache/chroniclemap/command/SSHCommandModule.java
@@ -14,10 +14,14 @@
package com.googlesource.gerrit.modules.cache.chroniclemap.command;
import com.google.gerrit.sshd.PluginCommandModule;
+import com.googlesource.gerrit.modules.cache.chroniclemap.ChronicleMapCacheConfig;
+import com.googlesource.gerrit.modules.cache.chroniclemap.MigrateH2Caches;
public class SSHCommandModule extends PluginCommandModule {
@Override
protected void configureCommands() {
+ factory(ChronicleMapCacheConfig.Factory.class);
command("analyze-h2-caches").to(AnalyzeH2Caches.class);
+ command("migrate-h2-caches").to(MigrateH2Caches.class);
}
}
diff --git a/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/MigrateH2CachesIT.java b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/MigrateH2CachesIT.java
new file mode 100644
index 0000000..2c82131
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/modules/cache/chroniclemap/MigrateH2CachesIT.java
@@ -0,0 +1,227 @@
+// Copyright (C) 2021 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.modules.cache.chroniclemap;
+
+import static com.google.common.truth.Truth.assertThat;
+import static com.googlesource.gerrit.modules.cache.chroniclemap.MigrateH2Caches.DEFAULT_MAX_BLOAT_FACTOR;
+import static com.googlesource.gerrit.modules.cache.chroniclemap.MigrateH2Caches.DEFAULT_SIZE_MULTIPLIER;
+import static com.googlesource.gerrit.modules.cache.chroniclemap.command.H2CacheSshCommand.H2_SUFFIX;
+
+import com.google.common.base.Joiner;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.gerrit.acceptance.LightweightPluginDaemonTest;
+import com.google.gerrit.acceptance.Sandboxed;
+import com.google.gerrit.acceptance.TestPlugin;
+import com.google.gerrit.acceptance.UseLocalDisk;
+import com.google.gerrit.acceptance.UseSsh;
+import com.google.gerrit.acceptance.WaitUtil;
+import com.google.gerrit.entities.CachedProjectConfig;
+import com.google.gerrit.entities.Project;
+import com.google.gerrit.entities.RefNames;
+import com.google.gerrit.metrics.DisabledMetricMaker;
+import com.google.gerrit.server.account.CachedAccountDetails;
+import com.google.gerrit.server.cache.PersistentCacheDef;
+import com.google.gerrit.server.cache.h2.H2CacheImpl;
+import com.google.gerrit.server.cache.proto.Cache;
+import com.google.gerrit.server.cache.serialize.ObjectIdConverter;
+import com.google.gerrit.server.config.SitePaths;
+import com.google.gerrit.server.git.GitRepositoryManager;
+import com.google.gerrit.sshd.BaseCommand;
+import com.google.inject.Binding;
+import com.google.inject.Inject;
+import com.google.inject.Key;
+import com.googlesource.gerrit.modules.cache.chroniclemap.command.H2CacheSshCommand;
+import java.io.IOException;
+import java.lang.annotation.Annotation;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.Map;
+import org.eclipse.jgit.lib.Repository;
+import org.junit.Before;
+import org.junit.Test;
+
+@Sandboxed
+@UseSsh
+@TestPlugin(
+ name = "cache-chroniclemap",
+ sshModule = "com.googlesource.gerrit.modules.cache.chroniclemap.command.SSHCommandModule")
+public class MigrateH2CachesIT extends LightweightPluginDaemonTest {
+ private final Duration LOAD_CACHE_WAIT_TIMEOUT = Duration.ofSeconds(4);
+ private String ACCOUNTS_CACHE_NAME = "accounts";
+ private String PERSISTED_PROJECTS_CACHE_NAME = "persisted_projects";
+
+ @Inject protected GitRepositoryManager repoManager;
+ @Inject private SitePaths sitePaths;
+
+ private ChronicleMapCacheConfig.Factory chronicleMapCacheConfigFactory;
+
+ private String cmd = Joiner.on(" ").join("cache-chroniclemap", "migrate-h2-caches");
+
+ @Before
+ public void setUp() {
+ chronicleMapCacheConfigFactory =
+ plugin.getSshInjector().getInstance(ChronicleMapCacheConfig.Factory.class);
+ }
+
+ @Test
+ @UseLocalDisk
+ public void shouldRunAndCompleteSuccessfullyWhenCacheDirectoryIsDefined() throws Exception {
+ String result = adminSshSession.exec(cmd);
+ adminSshSession.assertSuccess();
+ assertThat(result).contains("Complete");
+ }
+
+ @Test
+ @UseLocalDisk
+ public void shouldOutputChronicleMapBloatedConfiguration() throws Exception {
+ waitForCacheToLoad(ACCOUNTS_CACHE_NAME);
+ waitForCacheToLoad(PERSISTED_PROJECTS_CACHE_NAME);
+
+ String result = adminSshSession.exec(cmd);
+ adminSshSession.assertSuccess();
+
+ assertThat(result)
+ .contains(
+ "[cache \""
+ + ACCOUNTS_CACHE_NAME
+ + "\"]\n"
+ + "\tmaxEntries = "
+ + H2CacheFor(ACCOUNTS_CACHE_NAME).diskStats().size() * DEFAULT_SIZE_MULTIPLIER);
+
+ assertThat(result)
+ .contains(
+ "[cache \""
+ + PERSISTED_PROJECTS_CACHE_NAME
+ + "\"]\n"
+ + "\tmaxEntries = "
+ + H2CacheFor(PERSISTED_PROJECTS_CACHE_NAME).diskStats().size()
+ * DEFAULT_SIZE_MULTIPLIER);
+ }
+
+ @Test
+ public void shouldFailWhenCacheDirectoryIsNotDefined() throws Exception {
+ adminSshSession.exec(cmd);
+ adminSshSession.assertFailure("fatal: Cannot run migration, cache directory is not configured");
+ }
+
+ @Test
+ public void shouldFailWhenUserHasNoAdminServerCapability() throws Exception {
+ userSshSession.exec(cmd);
+ userSshSession.assertFailure("administrateServer for plugin cache-chroniclemap not permitted");
+ }
+
+ @Test
+ @UseLocalDisk
+ public void shouldMigrateAccountsCache() throws Exception {
+ waitForCacheToLoad(ACCOUNTS_CACHE_NAME);
+
+ adminSshSession.exec(cmd);
+ adminSshSession.assertSuccess();
+
+ ChronicleMapCacheImpl<CachedAccountDetails.Key, CachedAccountDetails> chronicleMapCache =
+ chronicleCacheFor(ACCOUNTS_CACHE_NAME);
+ H2CacheImpl<CachedAccountDetails.Key, CachedAccountDetails> h2Cache =
+ H2CacheFor(ACCOUNTS_CACHE_NAME);
+
+ assertThat(chronicleMapCache.diskStats().size()).isEqualTo(h2Cache.diskStats().size());
+ }
+
+ @Test
+ @UseLocalDisk
+ public void shouldMigratePersistentProjects() throws Exception {
+ waitForCacheToLoad(PERSISTED_PROJECTS_CACHE_NAME);
+
+ adminSshSession.exec(cmd);
+ adminSshSession.assertSuccess();
+
+ H2CacheImpl<Cache.ProjectCacheKeyProto, CachedProjectConfig> h2Cache =
+ H2CacheFor(PERSISTED_PROJECTS_CACHE_NAME);
+ ChronicleMapCacheImpl<Cache.ProjectCacheKeyProto, CachedProjectConfig> chronicleMapCache =
+ chronicleCacheFor(PERSISTED_PROJECTS_CACHE_NAME);
+
+ Cache.ProjectCacheKeyProto allUsersProto = projectCacheKey(allUsers);
+ Cache.ProjectCacheKeyProto allProjectsProto = projectCacheKey(allProjects);
+
+ assertThat(chronicleMapCache.get(allUsersProto)).isEqualTo(h2Cache.get(allUsersProto));
+ assertThat(chronicleMapCache.get(allProjectsProto)).isEqualTo(h2Cache.get(allProjectsProto));
+ }
+
+ private Cache.ProjectCacheKeyProto projectCacheKey(Project.NameKey key) throws IOException {
+ try (Repository git = repoManager.openRepository(key)) {
+ return Cache.ProjectCacheKeyProto.newBuilder()
+ .setProject(key.get())
+ .setRevision(
+ ObjectIdConverter.create()
+ .toByteString(git.exactRef(RefNames.REFS_CONFIG).getObjectId()))
+ .build();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private <K, V> PersistentCacheDef<K, V> getPersistentCacheDef(String named) {
+ return findClassBoundWithName(PersistentCacheDef.class, named);
+ }
+
+ @SuppressWarnings("unchecked")
+ private <K, V> H2CacheImpl<K, V> H2CacheFor(String named) {
+ return (H2CacheImpl<K, V>) findClassBoundWithName(LoadingCache.class, named);
+ }
+
+ @SuppressWarnings("unchecked")
+ private <K, V> CacheLoader<K, V> cacheLoaderFor(String named) {
+ return findClassBoundWithName(CacheLoader.class, named);
+ }
+
+ private <T> T findClassBoundWithName(Class<T> clazz, String named) {
+ return plugin.getSysInjector().getAllBindings().entrySet().stream()
+ .filter(entry -> isClassBoundWithName(entry, clazz.getSimpleName(), named))
+ .findFirst()
+ .map(entry -> clazz.cast(entry.getValue().getProvider().get()))
+ .get();
+ }
+
+ private boolean isClassBoundWithName(
+ Map.Entry<Key<?>, Binding<?>> entry, String classNameMatch, String named) {
+ String className = entry.getKey().getTypeLiteral().getRawType().getSimpleName();
+ Annotation annotation = entry.getKey().getAnnotation();
+ return className.equals(classNameMatch)
+ && annotation != null
+ && annotation.toString().endsWith(String.format("Named(value=\"%s\")", named));
+ }
+
+ private <K, V> ChronicleMapCacheImpl<K, V> chronicleCacheFor(String cacheName)
+ throws BaseCommand.UnloggedFailure, IOException {
+ Path cacheDirectory = sitePaths.resolve(cfg.getString("cache", null, "directory"));
+
+ PersistentCacheDef<K, V> persistentDef = getPersistentCacheDef(cacheName);
+ ChronicleMapCacheConfig config =
+ MigrateH2Caches.makeChronicleMapConfig(
+ chronicleMapCacheConfigFactory,
+ cacheDirectory,
+ persistentDef,
+ H2CacheSshCommand.getStats(
+ cacheDirectory.resolve(String.format("%s.%s", cacheName, H2_SUFFIX))),
+ DEFAULT_SIZE_MULTIPLIER,
+ DEFAULT_MAX_BLOAT_FACTOR);
+
+ return new ChronicleMapCacheImpl<>(
+ persistentDef, config, cacheLoaderFor(cacheName), new DisabledMetricMaker());
+ }
+
+ private void waitForCacheToLoad(String cacheName) throws InterruptedException {
+ WaitUtil.waitUntil(() -> H2CacheFor(cacheName).diskStats().size() > 0, LOAD_CACHE_WAIT_TIMEOUT);
+ }
+}
