DfsBlockCacheConfig: support configurations for dfs cache tables per extensions

Parse configurations for tables containing a set of extensions,
defined in [core "dfs.*"] sections.

Parse configurations for cache tables according to configurations
defined in [core "dfs.*"] git config sections for sets of
extensions. The current [core "dfs"] is the default to any
extension not listed in any other table.

Configuration falls back to the defaults defined in the
DfsBlockCacheConfig.java file when not set on each cache
table configuration.

Sample format for individual cache tables:
In this example:
1. PACK types would go to the "default" table
2. INDEX and BITMAP_INDEX types would go to the
   "multipleExtensionCache" table
3. REFTABLE types would go to the "reftableCache" table

[core "dfs"] // Configuration for the "default" cache table.
  blockSize = 512
  blockLimit = 100
  concurrencyLevel = 5
  (...)

[core "dfs.multipleExtensionCache"]
  packExtensions = "INDEX BITMAP_INDEX"
  blockSize = 512
  blockLimit = 100
  concurrencyLevel = 5
  (...)

[core "dfs.reftableCache"]
  packExtensions = "REFTABLE"
  blockSize = 512
  blockLimit = 100
  concurrencyLevel = 5
  (...)

Change-Id: I0e534e6d78b684832e3d3d269cee2590aa0f1911

1 files changed, 159 insertions, 0 deletions

diff --git a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/dfs/DfsBlockCacheConfigTest.java b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/dfs/DfsBlockCacheConfigTest.java
index 2df0ba1b05..6ca0ff6a16 100644
--- a/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/dfs/DfsBlockCacheConfigTest.java
+++ b/org.eclipse.jgit.test/tst/org/eclipse/jgit/internal/storage/dfs/DfsBlockCacheConfigTest.java
@@ -38,11 +38,27 @@
 
 package org.eclipse.jgit.internal.storage.dfs;
 
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_CORE_SECTION;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_DFS_CACHE_PREFIX;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_DFS_SECTION;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_BLOCK_LIMIT;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_BLOCK_SIZE;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_CONCURRENCY_LEVEL;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PACK_EXTENSIONS;
+import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_STREAM_RATIO;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.closeTo;
+import static org.hamcrest.Matchers.hasSize;
 import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertThrows;
 
+import java.util.List;
+import java.util.stream.Collectors;
+
 import org.eclipse.jgit.internal.JGitText;
+import org.eclipse.jgit.internal.storage.dfs.DfsBlockCacheConfig.DfsBlockCachePackExtConfig;
+import org.eclipse.jgit.internal.storage.pack.PackExt;
+import org.eclipse.jgit.lib.Config;
 import org.junit.Test;
 
 public class DfsBlockCacheConfigTest {
@@ -80,4 +96,147 @@ public class DfsBlockCacheConfigTest {
 
 		assertThat(config.getBlockSize(), is(65536));
 	}
+
+	@Test
+	public void fromConfigs() {
+		Config config = new Config();
+		config.setLong(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
+				CONFIG_KEY_BLOCK_LIMIT, 50 * 1024);
+		config.setInt(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
+				CONFIG_KEY_BLOCK_SIZE, 1024);
+		config.setInt(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
+				CONFIG_KEY_CONCURRENCY_LEVEL, 3);
+		config.setString(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
+				CONFIG_KEY_STREAM_RATIO, "0.5");
+
+		DfsBlockCacheConfig cacheConfig = new DfsBlockCacheConfig()
+				.fromConfig(config);
+		assertThat(cacheConfig.getBlockLimit(), is(50L * 1024L));
+		assertThat(cacheConfig.getBlockSize(), is(1024));
+		assertThat(cacheConfig.getConcurrencyLevel(), is(3));
+		assertThat(cacheConfig.getStreamRatio(), closeTo(0.5, 0.0001));
+	}
+
+	@Test
+	public void fromConfig_blockLimitNotAMultipleOfBlockSize_throws() {
+		Config config = new Config();
+		config.setLong(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
+				CONFIG_KEY_BLOCK_LIMIT, 1025);
+		config.setInt(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
+				CONFIG_KEY_BLOCK_SIZE, 1024);
+
+		assertThrows(IllegalArgumentException.class,
+				() -> new DfsBlockCacheConfig().fromConfig(config));
+	}
+
+	@Test
+	public void fromConfig_streamRatioInvalidFormat_throws() {
+		Config config = new Config();
+		config.setString(CONFIG_CORE_SECTION, CONFIG_DFS_SECTION,
+				CONFIG_KEY_STREAM_RATIO, "0.a5");
+
+		assertThrows(IllegalArgumentException.class,
+				() -> new DfsBlockCacheConfig().fromConfig(config));
+	}
+
+	@Test
+	public void fromConfig_generatesDfsBlockCachePackExtConfigs() {
+		Config config = new Config();
+		addPackExtConfigEntry(config, "pack", List.of(PackExt.PACK),
+				/* blockLimit= */ 20 * 512, /* blockSize= */ 512);
+
+		addPackExtConfigEntry(config, "bitmap", List.of(PackExt.BITMAP_INDEX),
+				/* blockLimit= */ 25 * 1024, /* blockSize= */ 1024);
+
+		addPackExtConfigEntry(config, "index",
+				List.of(PackExt.INDEX, PackExt.OBJECT_SIZE_INDEX,
+						PackExt.REVERSE_INDEX),
+				/* blockLimit= */ 30 * 1024, /* blockSize= */ 1024);
+
+		DfsBlockCacheConfig cacheConfig = new DfsBlockCacheConfig()
+				.fromConfig(config);
+		var configs = cacheConfig.getPackExtCacheConfigurations();
+		assertThat(configs, hasSize(3));
+		var packConfig = getConfigForExt(configs, PackExt.PACK);
+		assertThat(packConfig.getBlockLimit(), is(20L * 512L));
+		assertThat(packConfig.getBlockSize(), is(512));
+
+		var bitmapConfig = getConfigForExt(configs, PackExt.BITMAP_INDEX);
+		assertThat(bitmapConfig.getBlockLimit(), is(25L * 1024L));
+		assertThat(bitmapConfig.getBlockSize(), is(1024));
+
+		var indexConfig = getConfigForExt(configs, PackExt.INDEX);
+		assertThat(indexConfig.getBlockLimit(), is(30L * 1024L));
+		assertThat(indexConfig.getBlockSize(), is(1024));
+		assertThat(getConfigForExt(configs, PackExt.OBJECT_SIZE_INDEX),
+				is(indexConfig));
+		assertThat(getConfigForExt(configs, PackExt.REVERSE_INDEX),
+				is(indexConfig));
+	}
+
+	@Test
+	public void fromConfigs_dfsBlockCachePackExtConfigWithDuplicateExtensions_throws() {
+		Config config = new Config();
+		config.setString(CONFIG_CORE_SECTION, CONFIG_DFS_CACHE_PREFIX + "pack1",
+				CONFIG_KEY_PACK_EXTENSIONS, PackExt.PACK.name());
+
+		config.setString(CONFIG_CORE_SECTION, CONFIG_DFS_CACHE_PREFIX + "pack2",
+				CONFIG_KEY_PACK_EXTENSIONS, PackExt.PACK.name());
+
+		assertThrows(IllegalArgumentException.class,
+				() -> new DfsBlockCacheConfig().fromConfig(config));
+	}
+
+	@Test
+	public void fromConfigs_dfsBlockCachePackExtConfigWithEmptyExtensions_throws() {
+		Config config = new Config();
+		config.setString(CONFIG_CORE_SECTION, CONFIG_DFS_CACHE_PREFIX + "pack1",
+				CONFIG_KEY_PACK_EXTENSIONS, "");
+
+		assertThrows(IllegalArgumentException.class,
+				() -> new DfsBlockCacheConfig().fromConfig(config));
+	}
+
+	@Test
+	public void fromConfigs_dfsBlockCachePackExtConfigWithNoExtensions_throws() {
+		Config config = new Config();
+		config.setInt(CONFIG_CORE_SECTION, CONFIG_DFS_CACHE_PREFIX + "pack1",
+				CONFIG_KEY_BLOCK_SIZE, 0);
+
+		assertThrows(IllegalArgumentException.class,
+				() -> new DfsBlockCacheConfig().fromConfig(config));
+	}
+
+	@Test
+	public void fromConfigs_dfsBlockCachePackExtConfigWithUnknownExtensions_throws() {
+		Config config = new Config();
+		config.setString(CONFIG_CORE_SECTION,
+				CONFIG_DFS_CACHE_PREFIX + "unknownExt",
+				CONFIG_KEY_PACK_EXTENSIONS, "NotAKnownExt");
+
+		assertThrows(IllegalArgumentException.class,
+				() -> new DfsBlockCacheConfig().fromConfig(config));
+	}
+
+	private static void addPackExtConfigEntry(Config config, String configName,
+			List<PackExt> packExts, long blockLimit, int blockSize) {
+		String packExtConfigName = CONFIG_DFS_CACHE_PREFIX + configName;
+		config.setString(CONFIG_CORE_SECTION, packExtConfigName,
+				CONFIG_KEY_PACK_EXTENSIONS, packExts.stream().map(PackExt::name)
+						.collect(Collectors.joining(" ")));
+		config.setLong(CONFIG_CORE_SECTION, packExtConfigName,
+				CONFIG_KEY_BLOCK_LIMIT, blockLimit);
+		config.setInt(CONFIG_CORE_SECTION, packExtConfigName,
+				CONFIG_KEY_BLOCK_SIZE, blockSize);
+	}
+
+	private static DfsBlockCacheConfig getConfigForExt(
+			List<DfsBlockCachePackExtConfig> configs, PackExt packExt) {
+		for (DfsBlockCachePackExtConfig config : configs) {
+			if (config.getPackExts().contains(packExt)) {
+				return config.getPackExtCacheConfiguration();
+			}
+		}
+		return null;
+	}
 }