Spring/spring-tools
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactored IndexCacheKey to deal with separate key components separatly, allows the cache to delete outdated files from previous releases for cleaup

Browse Source
This commit is contained in:
Martin Lippert
2023-07-17 17:04:48 +02:00
parent cf26bb89e6
commit 1cec4a77f5
7 changed files with 210 additions and 103 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/index/cache/IndexCacheKey.java vendored
View File

@@ -10,6 +10,8 @@
*******************************************************************************/
package org.springframework.ide.vscode.boot.index.cache;
import java.util.Objects;
/**
* @author Martin Lippert
*/
@@ -17,16 +19,28 @@ public class IndexCacheKey {
private static final String SEPARATOR = "-";
private final String primaryIdentifier;
private final String project;
private final String indexer;
private final String category;
private final String version;
public IndexCacheKey(String primaryIdentifier, String version) {
this.primaryIdentifier = primaryIdentifier;
public IndexCacheKey(String project, String indexer, String category, String version) {
this.project = project;
this.indexer = indexer;
this.category = category;
this.version = version;
}
public String getPrimaryIdentifier() {
return primaryIdentifier;
public String getProject() {
return project;
}
public String getIndexer() {
return indexer;
}
public String getCategory() {
return category;
}
public String getVersion() {
@@ -35,16 +49,12 @@ public class IndexCacheKey {
@Override
public String toString() {
return primaryIdentifier + SEPARATOR + version;
return project + SEPARATOR + indexer + SEPARATOR + category + SEPARATOR + version;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((primaryIdentifier == null) ? 0 : primaryIdentifier.hashCode());
result = prime * result + ((version == null) ? 0 : version.hashCode());
return result;
return Objects.hash(category, indexer, project, version);
}
@Override
@@ -55,27 +65,54 @@ public class IndexCacheKey {
return false;
if (getClass() != obj.getClass())
return false;
IndexCacheKey other = (IndexCacheKey) obj;
return this.toString().equals(other.toString());
return Objects.equals(category, other.category) && Objects.equals(indexer, other.indexer)
&& Objects.equals(project, other.project) && Objects.equals(version, other.version);
}
public static IndexCacheKey parse(String fileName) {
if (fileName != null && fileName.length() > 0) {
int separatorIndex = fileName.lastIndexOf(SEPARATOR);
if (separatorIndex > 0) {
String primary = fileName.substring(0, separatorIndex);
String version = fileName.substring(separatorIndex + 1);
if (fileName != null) {
int fileextensionIndex = version.lastIndexOf(".");
if (fileextensionIndex > 0) {
version = version.substring(0, fileextensionIndex);
}
return new IndexCacheKey(primary, version);
String name = removeFileExtension(fileName);
if (name != null && name.length() > 0) {
String version = lastSegment(name);
int endIndex = Math.max(name.length() - version.length() - 1, 0);
String remainingName = name.substring(0, endIndex);
String category = lastSegment(remainingName);
endIndex = Math.max(remainingName.length() - category.length() - 1, 0);
remainingName = remainingName.substring(0, endIndex);
String indexer = lastSegment(remainingName);
endIndex = Math.max(remainingName.length() - indexer.length() - 1, 0);
String project = remainingName.substring(0, endIndex);
return new IndexCacheKey(project, indexer, category, version);
}
}
return null;
}
private static String lastSegment(String name) {
int separatorIndex = name.lastIndexOf(SEPARATOR);
if (separatorIndex > 0) {
return name.substring(separatorIndex + 1);
}
else {
return name;
}
}
private static String removeFileExtension(String name) {
int fileextensionIndex = name.lastIndexOf(".");
if (fileextensionIndex >= 0) {
return name.substring(0, fileextensionIndex);
}
else {
return name;
}
}
}

11
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/index/cache/IndexCacheOnDisc.java vendored
View File

@@ -304,7 +304,16 @@ public class IndexCacheOnDisc implements IndexCache {
IndexCacheKey key = IndexCacheKey.parse(fileName);
if (key != null && !key.equals(cacheKey)
&& key.getPrimaryIdentifier().equals(cacheKey.getPrimaryIdentifier())) {
&& key.getProject().equals(cacheKey.getProject())
&& key.getIndexer().equals(cacheKey.getIndexer())
&& key.getCategory().equals(cacheKey.getCategory())) {
cacheFiles[i].delete();
}
// cleanup old cache files without category information (pre 4.19.1 release)
else if (key != null && !key.equals(cacheKey)
&& key.getProject().equals(cacheKey.getProject())
&& key.getIndexer().equals(cacheKey.getIndexer())
&& key.getCategory().equals("")) {
cacheFiles[i].delete();
}
}

2
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/utils/SpringFactoriesIndexer.java
View File

@@ -155,7 +155,7 @@ public class SpringFactoriesIndexer implements SpringIndexer {
}
})
.collect(Collectors.joining(","));
return new IndexCacheKey(project.getElementName() + "-factories-", DigestUtils.md5Hex(filesIndentifier).toUpperCase());
return new IndexCacheKey(project.getElementName(), "factories", "", DigestUtils.md5Hex(filesIndentifier).toUpperCase());
}

2
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/utils/SpringIndexerJava.java
View File

@@ -656,7 +656,7 @@ public class SpringIndexerJava implements SpringIndexer {
.map(file -> file.getAbsolutePath() + "#" + file.lastModified())
.collect(Collectors.joining(","));
return new IndexCacheKey(project.getElementName() + "-java-" + elementType + "-", DigestUtils.md5Hex(GENERATION + "-" + classpathIdentifier).toUpperCase());
return new IndexCacheKey(project.getElementName(), "java", elementType, DigestUtils.md5Hex(GENERATION + "-" + classpathIdentifier).toUpperCase());
}
public void setScanTestJavaSources(boolean scanTestJavaSources) {

2
headless-services/spring-boot-language-server/src/main/java/org/springframework/ide/vscode/boot/java/utils/SpringIndexerXML.java
View File

@@ -306,7 +306,7 @@ public class SpringIndexerXML implements SpringIndexer {
.map(file -> file.getAbsolutePath() + "#" + file.lastModified())
.collect(Collectors.joining(","));
return new IndexCacheKey(project.getElementName() + "-xml-" + elementType + "-", DigestUtils.md5Hex(classpathIdentifier).toUpperCase());
return new IndexCacheKey(project.getElementName(), "xml", elementType, DigestUtils.md5Hex(classpathIdentifier).toUpperCase());
}
private void clearIndex() {

91
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/index/cache/test/IndexCacheKeyTest.java vendored
View File

@@ -12,6 +12,7 @@ package org.springframework.ide.vscode.boot.index.cache.test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import org.junit.jupiter.api.Test;
import org.springframework.ide.vscode.boot.index.cache.IndexCacheKey;
@@ -23,56 +24,90 @@ public class IndexCacheKeyTest {
@Test
void testCacheKey() {
IndexCacheKey key = new IndexCacheKey("primary", "version");
IndexCacheKey key = new IndexCacheKey("project", "indexer", "category", "version");
IndexCacheKey keyEquals = new IndexCacheKey("project", "indexer", "category", "version");
IndexCacheKey keyNotEquals = new IndexCacheKey("project", "indexer2", "category2", "version");
assertEquals("primary", key.getPrimaryIdentifier());
assertEquals("project", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("category", key.getCategory());
assertEquals("version", key.getVersion());
assertEquals("primary-version", key.toString());
assertEquals("project-indexer-category-version", key.toString());
assertEquals(key, keyEquals);
assertEquals(key.hashCode(), keyEquals.hashCode());
assertNotEquals(key, keyNotEquals);
assertNotEquals(key.hashCode(), keyNotEquals.hashCode());
}
@Test
void testCacheKeyParsingFromFileName() {
IndexCacheKey key = IndexCacheKey.parse("primary-version.json");
assertEquals("primary", key.getPrimaryIdentifier());
IndexCacheKey key = IndexCacheKey.parse("project-indexer-category-version.json");
assertEquals("project", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("category", key.getCategory());
assertEquals("version", key.getVersion());
key = IndexCacheKey.parse("primary-name-with-separator-123ABC.json");
assertEquals("primary-name-with-separator", key.getPrimaryIdentifier());
key = IndexCacheKey.parse("project-name-with-separator-indexer-category-123ABC.json");
assertEquals("project-name-with-separator", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("category", key.getCategory());
assertEquals("123ABC", key.getVersion());
}
@Test
void testCacheKeyParsingWithoutFileExtension() {
IndexCacheKey key = IndexCacheKey.parse("primary-version");
assertEquals("primary", key.getPrimaryIdentifier());
IndexCacheKey key = IndexCacheKey.parse("primary-indexer-category-version");
assertEquals("primary", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("category", key.getCategory());
assertEquals("version", key.getVersion());
key = IndexCacheKey.parse("primary-name-with-separator-123ABC");
assertEquals("primary-name-with-separator", key.getPrimaryIdentifier());
key = IndexCacheKey.parse("project-name-with-separator-indexer-category-123ABC");
assertEquals("project-name-with-separator", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("category", key.getCategory());
assertEquals("123ABC", key.getVersion());
}
@Test
void testCacheKeyEquals() {
IndexCacheKey key1 = new IndexCacheKey("primary", "1");
IndexCacheKey key2 = new IndexCacheKey("primary", "1");
void testCacheKeyParsingFromOldReleases() {
IndexCacheKey key = IndexCacheKey.parse("project-with-separator-indexer--version");
assertEquals("project-with-separator", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("", key.getCategory());
assertEquals("version", key.getVersion());
IndexCacheKey key3 = new IndexCacheKey("primary", "2");
IndexCacheKey key4 = new IndexCacheKey("secondary", "1");
key = IndexCacheKey.parse("project-with-separator-indexer--version.json");
assertEquals("project-with-separator", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("", key.getCategory());
assertEquals("version", key.getVersion());
}
@Test
void testBrokenCacheFileNames() {
IndexCacheKey key = IndexCacheKey.parse("version.json");
assertEquals("", key.getProject());
assertEquals("", key.getIndexer());
assertEquals("", key.getCategory());
assertEquals("version", key.getVersion());
assertEquals(key1, key1);
assertEquals(key2, key2);
assertEquals(key3, key3);
assertEquals(key4, key4);
key = IndexCacheKey.parse("category-123ABC.json");
assertEquals("", key.getProject());
assertEquals("", key.getIndexer());
assertEquals("category", key.getCategory());
assertEquals("123ABC", key.getVersion());
key = IndexCacheKey.parse("indexer-category-123ABC.json");
assertEquals("", key.getProject());
assertEquals("indexer", key.getIndexer());
assertEquals("category", key.getCategory());
assertEquals("123ABC", key.getVersion());
assertEquals(key1, key2);
assertNotEquals(key1, key3);
assertNotEquals(key2, key3);
assertNotEquals(key3, key4);
assertNotEquals(key1, key4);
assertNotEquals(key4, key1);
assertNotEquals(key4, key2);
key = IndexCacheKey.parse(".json");
assertNull(key);
}
}

118
headless-services/spring-boot-language-server/src/test/java/org/springframework/ide/vscode/boot/index/cache/test/IndexCacheOnDiscTest.java vendored
View File

@@ -52,6 +52,8 @@ import com.google.common.collect.Multimap;
public class IndexCacheOnDiscTest {
private static final IndexCacheKey CACHE_KEY_VERSION_1 = new IndexCacheKey("someProject", "someIndexer", "someCategory", "1");
private Path tempDir;
private IndexCacheOnDisc cache;
@@ -68,7 +70,7 @@ public class IndexCacheOnDiscTest {
@Test
void testEmptyCache() throws Exception {
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("something", "0"), new String[0], CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("something", "someIndexer", "someCategory", "0"), new String[0], CachedSymbol.class);
assertNull(result);
}
@@ -90,13 +92,13 @@ public class IndexCacheOnDiscTest {
EnhancedSymbolInformation enhancedSymbol = new EnhancedSymbolInformation(symbol, null);
generatedSymbols.add(new CachedSymbol("", timeFile1.toMillis(), enhancedSymbol));
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols, ImmutableMultimap.of(
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols, ImmutableMultimap.of(
file1.toString(), "file1dep1",
file2.toString(), "file2dep1",
file2.toString(), "file2dep2"
), CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
CachedSymbol[] cachedSymbols = result.getLeft();
assertNotNull(cachedSymbols);
@@ -112,8 +114,8 @@ public class IndexCacheOnDiscTest {
assertEquals(dependencies.get(file1.toString()), ImmutableSet.of("file1dep1"));
assertEquals(dependencies.get(file2.toString()), ImmutableSet.of("file2dep1", "file2dep2"));
assertEquals(timeFile1.toMillis(), cache.getModificationTimestamp(new IndexCacheKey("somekey", "1"), file1.toString()));
assertEquals(0, cache.getModificationTimestamp(new IndexCacheKey("somekey", "1"), "random-non-existing-file"));
assertEquals(timeFile1.toMillis(), cache.getModificationTimestamp(CACHE_KEY_VERSION_1, file1.toString()));
assertEquals(0, cache.getModificationTimestamp(CACHE_KEY_VERSION_1, "random-non-existing-file"));
}
@Test
@@ -134,9 +136,9 @@ public class IndexCacheOnDiscTest {
EnhancedSymbolInformation enhancedSymbol = new EnhancedSymbolInformation(symbol, null);
generatedSymbols.add(new CachedSymbol("", timeFile1.toMillis(), enhancedSymbol));
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols, null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols, null, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("otherkey", "1"), files, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("someOtherProject", "someOtherIndexer", "someOtherCategory", "1"), files, CachedSymbol.class);
assertNull(result);
}
@@ -158,14 +160,14 @@ public class IndexCacheOnDiscTest {
EnhancedSymbolInformation enhancedSymbol = new EnhancedSymbolInformation(symbol, null);
generatedSymbols.add(new CachedSymbol("", timeFile1.toMillis(), enhancedSymbol));
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols, ImmutableMultimap.of(
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols, ImmutableMultimap.of(
file1.toString(), "file1dep",
file2.toString(), "file2dep"
), CachedSymbol.class);
assertTrue(file1.toFile().setLastModified(timeFile1.toMillis() + 1000));
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
assertNull(result);
}
@@ -180,10 +182,10 @@ public class IndexCacheOnDiscTest {
Files.createFile(file3);
String[] files = {file1.toString(), file2.toString()};
cache.store(new IndexCacheKey("somekey", "1"), files, new ArrayList<>(), null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, new ArrayList<>(), null, CachedSymbol.class);
String[] moreFiles = {file1.toString(), file2.toString(), file3.toString()};
assertNull(cache.retrieve(new IndexCacheKey("somekey", "1"), moreFiles, CachedSymbol.class));
assertNull(cache.retrieve(CACHE_KEY_VERSION_1, moreFiles, CachedSymbol.class));
}
@Test
@@ -197,24 +199,48 @@ public class IndexCacheOnDiscTest {
Files.createFile(file3);
String[] files = {file1.toString(), file2.toString(), file3.toString()};
cache.store(new IndexCacheKey("somekey", "1"), files, new ArrayList<>(), null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, new ArrayList<>(), null, CachedSymbol.class);
String[] fewerFiles = {file1.toString(), file2.toString()};
assertNull(cache.retrieve(new IndexCacheKey("somekey", "1"), fewerFiles, CachedSymbol.class));
assertNull(cache.retrieve(CACHE_KEY_VERSION_1, fewerFiles, CachedSymbol.class));
}
@Test
void testDeleteOldCacheFileIfNewOneIsStored() throws Exception {
IndexCacheKey key1 = new IndexCacheKey("somekey", "1");
IndexCacheKey key1 = CACHE_KEY_VERSION_1;
cache.store(key1, new String[0], new ArrayList<>(), null, CachedSymbol.class);
assertTrue(Files.exists(tempDir.resolve(Paths.get(key1.toString() + ".json"))));
IndexCacheKey key2 = new IndexCacheKey("somekey", "2");
IndexCacheKey key2 = new IndexCacheKey("someProject", "someIndexer", "someCategory", "2");
cache.store(key2, new String[0], new ArrayList<>(), null, CachedSymbol.class);
assertTrue(Files.exists(tempDir.resolve(Paths.get(key2.toString() + ".json"))));
assertFalse(Files.exists(tempDir.resolve(Paths.get(key1.toString() + ".json"))));
}
@Test
void testDeleteOldCacheFileFromPreviousReleasesIfNewOneIsStored() throws Exception {
IndexCacheKey key1 = new IndexCacheKey("someProject", "someIndexer", "", "2");
cache.store(key1, new String[0], new ArrayList<>(), null, CachedSymbol.class);
assertTrue(Files.exists(tempDir.resolve(Paths.get(key1.toString() + ".json"))));
IndexCacheKey key2 = new IndexCacheKey("someProject", "someIndexer", "someCategory", "2");
cache.store(key2, new String[0], new ArrayList<>(), null, CachedSymbol.class);
assertTrue(Files.exists(tempDir.resolve(Paths.get(key2.toString() + ".json"))));
assertFalse(Files.exists(tempDir.resolve(Paths.get(key1.toString() + ".json"))));
}
@Test
void testDoNotDeleteCacheFileFromOtherCategory() throws Exception {
IndexCacheKey key1 = new IndexCacheKey("someProject", "someIndexer", "someCategory", "2");
cache.store(key1, new String[0], new ArrayList<>(), null, CachedSymbol.class);
assertTrue(Files.exists(tempDir.resolve(Paths.get(key1.toString() + ".json"))));
IndexCacheKey key2 = new IndexCacheKey("someProject", "someIndexer", "otherCategory", "2");
cache.store(key2, new String[0], new ArrayList<>(), null, CachedSymbol.class);
assertTrue(Files.exists(tempDir.resolve(Paths.get(key2.toString() + ".json"))));
assertTrue(Files.exists(tempDir.resolve(Paths.get(key1.toString() + ".json"))));
}
@Test
void testEnhancedInformationSubclasses() throws Exception {
Path file1 = Paths.get(tempDir.toAbsolutePath().toString(), "tempFile1");
@@ -232,9 +258,9 @@ public class IndexCacheOnDiscTest {
generatedSymbols.add(new CachedSymbol(doc1URI, timeFile1.toMillis(), enhancedSymbol));
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols, null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols, null, CachedSymbol.class);
CachedSymbol[] cachedSymbols = cache.retrieveSymbols(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
CachedSymbol[] cachedSymbols = cache.retrieveSymbols(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
assertNotNull(cachedSymbols);
assertEquals(1, cachedSymbols.length);
@@ -269,7 +295,7 @@ public class IndexCacheOnDiscTest {
EnhancedSymbolInformation enhancedSymbol1 = new EnhancedSymbolInformation(symbol1, null);
generatedSymbols1.add(new CachedSymbol(doc1URI, timeFile1.toMillis(), enhancedSymbol1));
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols1, null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols1, null, CachedSymbol.class);
List<CachedSymbol> generatedSymbols2 = new ArrayList<>();
symbol1 = new WorkspaceSymbol("symbol1", SymbolKind.Field, Either.forLeft(new Location(doc1URI, new Range(new Position(3, 10), new Position(3, 20)))));
@@ -282,13 +308,13 @@ public class IndexCacheOnDiscTest {
generatedSymbols2.add(new CachedSymbol(doc1URI, timeFile1.toMillis() + 2000, enhancedSymbol2));
assertTrue(file1.toFile().setLastModified(timeFile1.toMillis() + 2000));
cache.update(new IndexCacheKey("somekey", "1"), file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols2, null, CachedSymbol.class);
cache.update(CACHE_KEY_VERSION_1, file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols2, null, CachedSymbol.class);
AbstractIndexCacheable[] cachedSymbols = cache.retrieveSymbols(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
AbstractIndexCacheable[] cachedSymbols = cache.retrieveSymbols(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
assertNotNull(cachedSymbols);
assertEquals(2, cachedSymbols.length);
assertEquals(timeFile1.toMillis() + 2000, cache.getModificationTimestamp(new IndexCacheKey("somekey", "1"), file1.toString()));
assertEquals(timeFile1.toMillis() + 2000, cache.getModificationTimestamp(CACHE_KEY_VERSION_1, file1.toString()));
}
@Test
@@ -327,7 +353,7 @@ public class IndexCacheOnDiscTest {
generatedSymbols.add(new CachedSymbol(doc3URI, timeFile3.toMillis(), enhancedSymbol3));
// store original version of the symbols to the cache
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols, null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols, null, CachedSymbol.class);
// create updated and new symbols
@@ -352,10 +378,10 @@ public class IndexCacheOnDiscTest {
long[] updatedModificationTimestamps = new long[]{timeFile1.toMillis() + 2000, timeFile2.toMillis() + 3000};
// update multiple files in the cache
cache.update(new IndexCacheKey("somekey", "1"), updatedFiles, updatedModificationTimestamps, updatedSymbols, null, CachedSymbol.class);
cache.update(CACHE_KEY_VERSION_1, updatedFiles, updatedModificationTimestamps, updatedSymbols, null, CachedSymbol.class);
// double check whether all changes got stored and retrieved correctly
CachedSymbol[] cachedSymbols = cache.retrieveSymbols(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
CachedSymbol[] cachedSymbols = cache.retrieveSymbols(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
assertNotNull(cachedSymbols);
assertEquals(4, cachedSymbols.length);
@@ -364,9 +390,9 @@ public class IndexCacheOnDiscTest {
assertSymbol(updatedEnhancedSymbol2, cachedSymbols);
assertSymbol(enhancedSymbol3, cachedSymbols);
assertEquals(timeFile1.toMillis() + 2000, cache.getModificationTimestamp(new IndexCacheKey("somekey", "1"), file1.toString()));
assertEquals(timeFile2.toMillis() + 3000, cache.getModificationTimestamp(new IndexCacheKey("somekey", "1"), file2.toString()));
assertEquals(timeFile3.toMillis(), cache.getModificationTimestamp(new IndexCacheKey("somekey", "1"), file3.toString()));
assertEquals(timeFile1.toMillis() + 2000, cache.getModificationTimestamp(CACHE_KEY_VERSION_1, file1.toString()));
assertEquals(timeFile2.toMillis() + 3000, cache.getModificationTimestamp(CACHE_KEY_VERSION_1, file2.toString()));
assertEquals(timeFile3.toMillis(), cache.getModificationTimestamp(CACHE_KEY_VERSION_1, file3.toString()));
}
private void assertSymbol(EnhancedSymbolInformation enhancedSymbol, CachedSymbol[] cachedSymbols) {
@@ -394,13 +420,13 @@ public class IndexCacheOnDiscTest {
List<CachedSymbol> generatedSymbols = ImmutableList.of();
Multimap<String, String> dependencies = ImmutableMultimap.of(file1.toString(), "dep1");
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols, dependencies, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols, dependencies, CachedSymbol.class);
assertTrue(file1.toFile().setLastModified(timeFile1.toMillis() + 2000));
Set<String> dependencies2 = ImmutableSet.of("dep1", "dep2");
cache.update(new IndexCacheKey("somekey", "1"), file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols, dependencies2, CachedSymbol.class);
cache.update(CACHE_KEY_VERSION_1, file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols, dependencies2, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
assertNotNull(result);
assertEquals(ImmutableSet.of("dep1", "dep2"), result.getRight().get(file1.toString()));
}
@@ -421,14 +447,14 @@ public class IndexCacheOnDiscTest {
EnhancedSymbolInformation enhancedSymbol1 = new EnhancedSymbolInformation(symbol1, null);
generatedSymbols1.add(new CachedSymbol(doc1URI, timeFile1.toMillis(), enhancedSymbol1));
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols1, null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols1, null, CachedSymbol.class);
List<CachedSymbol> generatedSymbols2 = new ArrayList<>();
assertTrue(file1.toFile().setLastModified(timeFile1.toMillis() + 2000));
cache.update(new IndexCacheKey("somekey", "1"), file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols2, null, CachedSymbol.class);
cache.update(CACHE_KEY_VERSION_1, file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols2, null, CachedSymbol.class);
AbstractIndexCacheable[] cachedSymbols = cache.retrieveSymbols(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
AbstractIndexCacheable[] cachedSymbols = cache.retrieveSymbols(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
assertNotNull(cachedSymbols);
assertEquals(0, cachedSymbols.length);
}
@@ -449,15 +475,15 @@ public class IndexCacheOnDiscTest {
file1.toString(), "dep2"
);
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols1, dependencies1, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols1, dependencies1, CachedSymbol.class);
List<CachedSymbol> generatedSymbols2 = new ArrayList<>();
assertTrue(file1.toFile().setLastModified(timeFile1.toMillis() + 2000));
Set<String> dependencies2 = ImmutableSet.of("dep2");
cache.update(new IndexCacheKey("somekey", "1"), file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols2, dependencies2, CachedSymbol.class);
cache.update(CACHE_KEY_VERSION_1, file1.toAbsolutePath().toString(), timeFile1.toMillis() + 2000, generatedSymbols2, dependencies2, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
assertNotNull(result);
assertEquals(ImmutableSet.of("dep2"), result.getRight().get(file1.toString()));
}
@@ -482,7 +508,7 @@ public class IndexCacheOnDiscTest {
EnhancedSymbolInformation enhancedSymbol1 = new EnhancedSymbolInformation(symbol1, null);
generatedSymbols1.add(new CachedSymbol(doc1URI, timeFile1.toMillis(), enhancedSymbol1));
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols1, null, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols1, null, CachedSymbol.class);
List<CachedSymbol> generatedSymbols2 = new ArrayList<>();
WorkspaceSymbol symbol2 = new WorkspaceSymbol("symbol2", SymbolKind.Interface, Either.forLeft(new Location(doc2URI, new Range(new Position(5, 5), new Position(5, 10)))));
@@ -490,9 +516,9 @@ public class IndexCacheOnDiscTest {
generatedSymbols2.add(new CachedSymbol(doc2URI, timeFile2.toMillis(), enhancedSymbol2));
cache.update(new IndexCacheKey("somekey", "1"), file2.toString(), timeFile2.toMillis(), generatedSymbols2, null, CachedSymbol.class);
cache.update(CACHE_KEY_VERSION_1, file2.toString(), timeFile2.toMillis(), generatedSymbols2, null, CachedSymbol.class);
AbstractIndexCacheable[] cachedSymbols = cache.retrieveSymbols(new IndexCacheKey("somekey", "1"), new String[]{file1.toString(), file2.toString()}, CachedSymbol.class);
AbstractIndexCacheable[] cachedSymbols = cache.retrieveSymbols(CACHE_KEY_VERSION_1, new String[]{file1.toString(), file2.toString()}, CachedSymbol.class);
assertNotNull(cachedSymbols);
assertEquals(2, cachedSymbols.length);
}
@@ -512,12 +538,12 @@ public class IndexCacheOnDiscTest {
Multimap<String, String> dependencies1 = ImmutableMultimap.of(
file1.toString(), "dep1"
);
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols1, dependencies1, CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols1, dependencies1, CachedSymbol.class);
Set<String> dependencies2 = ImmutableSet.of("dep2");
cache.update(new IndexCacheKey("somekey", "1"), file2.toString(), timeFile2.toMillis(), generatedSymbols1, dependencies2, CachedSymbol.class);
cache.update(CACHE_KEY_VERSION_1, file2.toString(), timeFile2.toMillis(), generatedSymbols1, dependencies2, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("somekey", "1"), new String[]{file1.toString(), file2.toString()}, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(CACHE_KEY_VERSION_1, new String[]{file1.toString(), file2.toString()}, CachedSymbol.class);
assertNotNull(result);
assertEquals(ImmutableSet.of("dep2"), result.getRight().get(file2.toString()));
assertEquals(ImmutableSet.of("dep1"), result.getRight().get(file1.toString()));
@@ -525,7 +551,7 @@ public class IndexCacheOnDiscTest {
@Test
void testProjectDeleted() throws Exception {
IndexCacheKey key1 = new IndexCacheKey("somekey", "1");
IndexCacheKey key1 = CACHE_KEY_VERSION_1;
cache.store(key1, new String[0], new ArrayList<>(), null, CachedSymbol.class);
assertTrue(Files.exists(tempDir.resolve(Paths.get(key1.toString() + ".json"))));
@@ -563,11 +589,11 @@ public class IndexCacheOnDiscTest {
file1.toString(), "dep1",
file2.toString(), "dep2"
);
cache.store(new IndexCacheKey("somekey", "1"), files, generatedSymbols, dependencies, CachedSymbol.class);
cache.removeFile(new IndexCacheKey("somekey", "1"), file1.toAbsolutePath().toString(), CachedSymbol.class);
cache.store(CACHE_KEY_VERSION_1, files, generatedSymbols, dependencies, CachedSymbol.class);
cache.removeFile(CACHE_KEY_VERSION_1, file1.toAbsolutePath().toString(), CachedSymbol.class);
files = new String[]{file2.toAbsolutePath().toString()};
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(new IndexCacheKey("somekey", "1"), files, CachedSymbol.class);
Pair<CachedSymbol[], Multimap<String, String>> result = cache.retrieve(CACHE_KEY_VERSION_1, files, CachedSymbol.class);
CachedSymbol[] cachedSymbols = result.getLeft();
assertNotNull(result);
assertEquals(1, cachedSymbols.length);