| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more contributor license |
| * agreements. See the NOTICE file distributed with this work for additional information regarding |
| * copyright ownership. The ASF licenses this file to You 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 org.apache.geode.management.internal.cli.commands; |
| |
| import static org.apache.geode.cache.Region.SEPARATOR; |
| import static org.apache.geode.internal.lang.SystemUtils.CURRENT_DIRECTORY; |
| import static org.assertj.core.api.Assertions.assertThat; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.Serializable; |
| import java.nio.file.Files; |
| import java.nio.file.Path; |
| import java.nio.file.Paths; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Properties; |
| import java.util.stream.IntStream; |
| |
| import junitparams.JUnitParamsRunner; |
| import junitparams.Parameters; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.experimental.categories.Category; |
| import org.junit.rules.TemporaryFolder; |
| import org.junit.runner.RunWith; |
| |
| import org.apache.geode.cache.Cache; |
| import org.apache.geode.cache.DiskStore; |
| import org.apache.geode.cache.Region; |
| import org.apache.geode.cache.configuration.CacheConfig; |
| import org.apache.geode.cache.configuration.DiskDirType; |
| import org.apache.geode.cache.configuration.DiskStoreType; |
| import org.apache.geode.distributed.Locator; |
| import org.apache.geode.distributed.internal.InternalConfigurationPersistenceService; |
| import org.apache.geode.distributed.internal.InternalLocator; |
| import org.apache.geode.internal.cache.DiskInitFile; |
| import org.apache.geode.internal.cache.InternalCache; |
| import org.apache.geode.internal.cache.SnapshotTestUtil; |
| import org.apache.geode.management.internal.cli.result.model.TabularResultModel; |
| import org.apache.geode.test.dunit.SerializableRunnableIF; |
| import org.apache.geode.test.dunit.rules.ClusterStartupRule; |
| import org.apache.geode.test.dunit.rules.MemberVM; |
| import org.apache.geode.test.junit.assertions.CommandResultAssert; |
| import org.apache.geode.test.junit.categories.PersistenceTest; |
| import org.apache.geode.test.junit.rules.GfshCommandRule; |
| import org.apache.geode.test.junit.rules.ServerStarterRule; |
| |
| @Category(PersistenceTest.class) |
| @RunWith(JUnitParamsRunner.class) |
| public class DiskStoreCommandsDUnitTest implements Serializable { |
| private static final String GROUP = "GROUP1"; |
| private static final String GROUP2 = "GROUP2"; |
| private static final String REGION_1 = "REGION1"; |
| private static final String DISKSTORE = "DISKSTORE"; |
| |
| @Rule |
| public ClusterStartupRule rule = new ClusterStartupRule(); |
| |
| @Rule |
| public transient GfshCommandRule gfsh = new GfshCommandRule(); |
| |
| @Rule |
| public transient TemporaryFolder tempDir = new TemporaryFolder(); |
| |
| private void createDiskStoreAndRegion(MemberVM jmxManager, int serverCount) { |
| createDiskStore(jmxManager, serverCount, GROUP); |
| |
| gfsh.executeAndAssertThat(String.format( |
| "create region --name=%s --type=REPLICATE_PERSISTENT --disk-store=%s --group=%s --eviction-action=overflow-to-disk", |
| REGION_1, DISKSTORE, GROUP)).statusIsSuccess(); |
| } |
| |
| @SuppressWarnings("deprecation") |
| private void createDiskStore(MemberVM jmxManager, int serverCount, String group) { |
| gfsh.executeAndAssertThat(String.format( |
| "create disk-store --name=%s --dir=%s --group=%s --auto-compact=false --compaction-threshold=99 --max-oplog-size=1 --allow-force-compaction=true", |
| DISKSTORE, DISKSTORE, group)) |
| .statusIsSuccess() |
| .doesNotContainOutput("Did not complete waiting"); |
| |
| gfsh.executeAndAssertThat("list disk-stores").statusIsSuccess() |
| .tableHasColumnWithValuesContaining("Disk Store Name", |
| IntStream.rangeClosed(1, serverCount).mapToObj(x -> DISKSTORE).toArray(String[]::new)); |
| } |
| |
| private static SerializableRunnableIF dataProducer() { |
| return () -> { |
| Cache cache = ClusterStartupRule.getCache(); |
| assertThat(cache).isNotNull(); |
| Region<String, String> r = cache.getRegion(REGION_1); |
| r.put("A", "B"); |
| }; |
| } |
| |
| @Test |
| public void createDuplicateDiskStoreFails() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| |
| MemberVM locator = rule.startLocatorVM(0); |
| @SuppressWarnings("unused") |
| MemberVM server1 = rule.startServerVM(1, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| |
| createDiskStore(locator, 1, GROUP); |
| |
| gfsh.executeAndAssertThat(String.format( |
| "create disk-store --name=%s --dir=%s --group=%s --auto-compact=false --compaction-threshold=99 --max-oplog-size=1 --allow-force-compaction=true", |
| DISKSTORE, DISKSTORE, GROUP)) |
| .statusIsError() |
| .containsOutput("Error: Disk store DISKSTORE already exists"); |
| } |
| |
| @Test |
| public void createDuplicateDiskStoreFailsNoServers() throws Exception { |
| MemberVM locator = rule.startLocatorVM(0); |
| |
| gfsh.connectAndVerify(locator); |
| |
| gfsh.executeAndAssertThat(String.format( |
| "create disk-store --name=%s --dir=%s --group=%s --auto-compact=false --compaction-threshold=99 --max-oplog-size=1 --allow-force-compaction=true", |
| DISKSTORE, DISKSTORE, GROUP)) |
| .statusIsError() |
| .containsOutput("No Members Found"); |
| } |
| |
| @Test |
| public void createDuplicateDiskStoreOnDifferentGroups() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| |
| MemberVM locator = rule.startLocatorVM(0); |
| rule.startServerVM(1, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| createDiskStore(locator, 1, GROUP); |
| |
| props.setProperty("groups", GROUP2); |
| |
| rule.startServerVM(2, props, locator.getPort()); |
| createDiskStore(locator, 1, GROUP2); |
| } |
| |
| @Test |
| public void testMissingDiskStore() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| |
| MemberVM locator = rule.startLocatorVM(0); |
| MemberVM server1 = rule.startServerVM(1, props, locator.getPort()); |
| MemberVM server2 = rule.startServerVM(2, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| |
| createDiskStoreAndRegion(locator, 2); |
| |
| server1.invoke(dataProducer()); |
| |
| gfsh.executeAndAssertThat("show missing-disk-stores") |
| .containsOutput("No missing disk store found"); |
| |
| server1.stop(false); |
| |
| server2.invoke(() -> { |
| Cache cache = ClusterStartupRule.getCache(); |
| assertThat(cache).isNotNull(); |
| Region<String, String> r = cache.getRegion(REGION_1); |
| r.put("A", "C"); |
| }); |
| |
| server2.stop(false); |
| |
| int locatorPort = locator.getPort(); |
| server1.invokeAsync(() -> { |
| // trying to restart the server asynchronously |
| ServerStarterRule serverRule = new ServerStarterRule().withProperties(props) |
| .withName("server-1").withConnectionToLocator(locatorPort).withAutoStart(); |
| ClusterStartupRule.memberStarter = serverRule; |
| serverRule.before(); |
| }); |
| |
| locator.waitUntilDiskStoreIsReadyOnExactlyThisManyServers(DISKSTORE, 1); |
| |
| TabularResultModel table = |
| gfsh.executeAndAssertThat("show missing-disk-stores").statusIsSuccess() |
| .containsOutput("Missing Disk Stores", "No missing colocated region found") |
| .hasTableSection().getActual(); |
| |
| List<String> diskstoreIDs = table.getValuesInColumn("Disk Store ID"); |
| assertThat(diskstoreIDs.size()).isEqualTo(1); |
| |
| gfsh.executeAndAssertThat("revoke missing-disk-store --id=" + diskstoreIDs.get(0)) |
| .statusIsSuccess().containsOutput("Missing disk store successfully revoked"); |
| |
| locator.waitUntilRegionIsReadyOnExactlyThisManyServers(SEPARATOR + REGION_1, 1); |
| |
| server1.invoke(() -> { |
| Cache cache = ClusterStartupRule.getCache(); |
| assertThat(cache).isNotNull(); |
| Region<String, String> r = cache.getRegion(REGION_1); |
| assertThat(r.get("A")).isEqualTo("B"); |
| }); |
| } |
| |
| @Test |
| public void testValidateOfflineDiskStoreCommand() throws Exception { |
| MemberVM server1 = rule.startServerVM(0, x -> x.withJMXManager().withProperty("groups", GROUP)); |
| |
| gfsh.connectAndVerify(server1.getJmxPort(), GfshCommandRule.PortType.jmxManager); |
| |
| createDiskStoreAndRegion(server1, 1); |
| |
| server1.invoke(dataProducer()); |
| |
| gfsh.executeAndAssertThat("show missing-disk-stores") |
| .containsOutput("No missing disk store found"); |
| |
| server1.stop(false); |
| |
| String diskDirs = new File(server1.getWorkingDir(), DISKSTORE).getAbsolutePath(); |
| gfsh.executeAndAssertThat( |
| "validate offline-disk-store --name=" + DISKSTORE + " --disk-dirs=" + diskDirs) |
| .statusIsSuccess() |
| .containsOutput("Total number of region entries in this disk store is: 1"); |
| } |
| |
| @Test |
| public void testExportOfflineDiskStore() throws Exception { |
| MemberVM server1 = rule.startServerVM(0, x -> x.withJMXManager().withProperty("groups", GROUP)); |
| |
| gfsh.connectAndVerify(server1.getJmxPort(), GfshCommandRule.PortType.jmxManager); |
| |
| createDiskStoreAndRegion(server1, 1); |
| |
| server1.invoke(dataProducer()); |
| |
| gfsh.executeAndAssertThat("show missing-disk-stores") |
| .containsOutput("No missing disk store found"); |
| |
| server1.stop(false); |
| |
| String diskDirs = new File(server1.getWorkingDir(), DISKSTORE).getAbsolutePath(); |
| File exportDir = tempDir.newFolder(); |
| gfsh.executeAndAssertThat("export offline-disk-store --name=" + DISKSTORE + " --disk-dirs=" |
| + diskDirs + " --dir=" + exportDir.getAbsolutePath()).statusIsSuccess() |
| .containsOutput("Exported all regions from disk store DISKSTORE"); |
| |
| Map<String, String> entries = new HashMap<>(); |
| entries.put("A", "B"); |
| SnapshotTestUtil.checkSnapshotEntries(exportDir, entries, DISKSTORE, REGION_1); |
| } |
| |
| private boolean diskStoreExistsInClusterConfig(MemberVM jmxManager) { |
| return jmxManager.invoke(() -> { |
| InternalConfigurationPersistenceService sharedConfig = |
| ((InternalLocator) Locator.getLocator()).getConfigurationPersistenceService(); |
| List<DiskStoreType> diskStores = sharedConfig.getCacheConfig(GROUP).getDiskStores(); |
| |
| return diskStores.size() == 1 && DISKSTORE.equals(diskStores.get(0).getName()); |
| }); |
| } |
| |
| @Test |
| public void testCannotDestroyDiskStoreInUse() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| |
| MemberVM locator = rule.startLocatorVM(0); |
| rule.startServerVM(1, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| |
| createDiskStoreAndRegion(locator, 1); |
| |
| gfsh.executeAndAssertThat( |
| String.format("destroy disk-store --name=%s --group=%s", DISKSTORE, GROUP)).statusIsError() |
| .containsOutput("Disk store is currently in use by these regions"); |
| assertThat(diskStoreExistsInClusterConfig(locator)).isTrue(); |
| } |
| |
| @Test |
| public void testDestroyUpdatesSharedConfig() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| |
| MemberVM locator = rule.startLocatorVM(0); |
| rule.startServerVM(1, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator.getJmxPort(), GfshCommandRule.PortType.jmxManager); |
| |
| createDiskStoreAndRegion(locator, 1); |
| |
| gfsh.executeAndAssertThat("destroy region --name=" + REGION_1).statusIsSuccess(); |
| gfsh.executeAndAssertThat( |
| String.format("destroy disk-store --name=%s --group=%s", DISKSTORE, GROUP)) |
| .statusIsSuccess(); |
| assertThat(diskStoreExistsInClusterConfig(locator)).isFalse(); |
| } |
| |
| @Test |
| @SuppressWarnings("deprecation") |
| public void testBackupDiskStore() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| MemberVM locator = rule.startLocatorVM(0); |
| MemberVM server1 = rule.startServerVM(1, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| |
| createDiskStoreAndRegion(locator, 1); |
| |
| server1.invoke(dataProducer()); |
| |
| String backupDir = tempDir.newFolder().getCanonicalPath(); |
| String diskDirs = new File(server1.getWorkingDir(), DISKSTORE).getAbsolutePath(); |
| gfsh.executeAndAssertThat( |
| String.format("backup disk-store --dir=%s --baseline-dir=%s", diskDirs, backupDir)) |
| .statusIsSuccess() |
| .tableHasColumnWithExactValuesInAnyOrder("Member", "locator-0", "server-1"); |
| } |
| |
| @Test |
| public void destroyDiskStoreIsIdempotent() throws Exception { |
| MemberVM locator = rule.startLocatorVM(0); |
| rule.startServerVM(1, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| |
| gfsh.executeAndAssertThat( |
| String.format("create disk-store --name=%s --dir=%s", DISKSTORE, DISKSTORE)) |
| .statusIsSuccess() |
| .doesNotContainOutput("Did not complete waiting"); |
| |
| gfsh.executeAndAssertThat(String.format("destroy disk-store --name=%s --if-exists", DISKSTORE)) |
| .statusIsSuccess(); |
| |
| locator.invoke(() -> { |
| InternalLocator internalLocator = ClusterStartupRule.getLocator(); |
| assertThat(internalLocator).isNotNull(); |
| InternalConfigurationPersistenceService cc = |
| internalLocator.getConfigurationPersistenceService(); |
| CacheConfig config = cc.getCacheConfig("cluster"); |
| assertThat(config.getDiskStores().size()).isEqualTo(0); |
| }); |
| |
| gfsh.executeAndAssertThat(String.format("destroy disk-store --name=%s --if-exists", DISKSTORE)) |
| .statusIsSuccess(); |
| } |
| |
| @Test |
| public void testCompactDiskStore() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| |
| MemberVM locator = rule.startLocatorVM(0); |
| MemberVM server1 = rule.startServerVM(1, props, locator.getPort()); |
| rule.startServerVM(2, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| |
| createDiskStoreAndRegion(locator, 2); |
| |
| server1.invoke(() -> { |
| InternalCache cache = ClusterStartupRule.getCache(); |
| assertThat(cache).isNotNull(); |
| Region<Integer, String> r = cache.getRegion(REGION_1); |
| // Make sure we have more than 1 log and there is something to compact |
| for (int i = 0; i < 10000; i++) { |
| r.put(i, "value_" + i); |
| r.put(i, "another_value_" + i); |
| } |
| }); |
| |
| CommandResultAssert resultAssert = gfsh.executeAndAssertThat( |
| String.format("compact disk-store --name=%s --group=%s", DISKSTORE, GROUP)) |
| .statusIsSuccess(); |
| |
| resultAssert.hasDataSection("server-1").hasContent().containsKeys("UUID", "Host", "Directory"); |
| resultAssert.hasDataSection("server-2").hasContent().containsKeys("UUID", "Host", "Directory"); |
| } |
| |
| @Test |
| public void testDescribeDiskStoreCommand() throws Exception { |
| MemberVM server1 = rule.startServerVM(0, x -> x.withJMXManager().withProperty("groups", GROUP)); |
| |
| gfsh.connectAndVerify(server1.getJmxPort(), GfshCommandRule.PortType.jmxManager); |
| |
| createDiskStoreAndRegion(server1, 1); |
| |
| server1.invoke(dataProducer()); |
| |
| CommandResultAssert resultAssert = gfsh.executeAndAssertThat( |
| String.format("describe disk-store --member=%s --name=%s", server1.getName(), DISKSTORE)) |
| .statusIsSuccess(); |
| resultAssert.hasDataSection(DescribeDiskStoreCommand.DISK_STORE_SECTION) |
| .hasContent() |
| .containsKeys("Disk Store Name", "Member ID", "Member Name", |
| "Allow Force Compaction", "Auto Compaction", "Compaction Threshold", "Max Oplog Size", |
| "Queue Size", "Time Interval", "Write Buffer Size", "Disk Usage Warning Percentage", |
| "Disk Usage Critical Percentage", "PDX Serialization Meta-Data Stored"); |
| |
| resultAssert.hasTableSection(DescribeDiskStoreCommand.DISK_DIR_SECTION) |
| .hasColumn("Disk Directory").hasSize(1); |
| |
| resultAssert.hasTableSection(DescribeDiskStoreCommand.REGION_SECTION) |
| .hasColumn("Region Path").hasSize(1); |
| } |
| |
| @Test |
| public void testDescribeMissingDiskStoreCommand() throws Exception { |
| MemberVM server1 = rule.startServerVM(0, x -> x.withJMXManager().withProperty("groups", GROUP)); |
| |
| gfsh.connectAndVerify(server1.getJmxPort(), GfshCommandRule.PortType.jmxManager); |
| |
| createDiskStoreAndRegion(server1, 1); |
| |
| server1.invoke(() -> { |
| Cache cache = ClusterStartupRule.getCache(); |
| Region<String, String> r = cache.getRegion(REGION_1); |
| r.put("A", "B"); |
| }); |
| |
| gfsh.executeAndAssertThat( |
| String.format("describe disk-store --member=%s --name=%s", server1.getName(), "UNKNOWN")) |
| .statusIsError() |
| .containsOutput("A disk store with name 'UNKNOWN' was not found on member 'server-0'."); |
| } |
| |
| @Test |
| public void testUpgradeOfflineDiskStoreCommandFailsAsExpected() throws Exception { |
| MemberVM server1 = rule.startServerVM(0, x -> x.withJMXManager().withProperty("groups", GROUP)); |
| |
| gfsh.connectAndVerify(server1.getJmxPort(), GfshCommandRule.PortType.jmxManager); |
| |
| createDiskStoreAndRegion(server1, 1); |
| |
| server1.invoke(dataProducer()); |
| |
| // Should not be able to do this on a running system |
| String diskDirs = new File(server1.getWorkingDir(), DISKSTORE).getAbsolutePath(); |
| gfsh.executeAndAssertThat( |
| String.format("upgrade offline-disk-store --name=%s --disk-dirs=%s", DISKSTORE, diskDirs)) |
| .statusIsError().containsOutput("The disk is currently being used by another process"); |
| |
| server1.stop(false); |
| |
| gfsh.executeAndAssertThat( |
| String.format("upgrade offline-disk-store --name=%s --disk-dirs=%s", DISKSTORE, diskDirs)) |
| .statusIsError().containsOutput("This disk store is already at version"); |
| } |
| |
| @Test |
| public void revokingUnknownDiskStoreShowsErrorCorrectly() throws Exception { |
| Properties props = new Properties(); |
| props.setProperty("groups", GROUP); |
| |
| MemberVM locator = rule.startLocatorVM(0); |
| rule.startServerVM(1, props, locator.getPort()); |
| |
| gfsh.connectAndVerify(locator); |
| gfsh.executeAndAssertThat("revoke missing-disk-store --id=unknown-diskstore").statusIsError() |
| .containsOutput("Unable to find missing disk store to revoke"); |
| } |
| |
| @Test |
| public void testAlterOfflineDiskStoreCommandFailsAsExpected() throws Exception { |
| MemberVM server1 = rule.startServerVM(0, x -> x.withJMXManager().withProperty("groups", GROUP)); |
| |
| gfsh.connectAndVerify(server1.getJmxPort(), GfshCommandRule.PortType.jmxManager); |
| |
| createDiskStoreAndRegion(server1, 1); |
| |
| server1.invoke(dataProducer()); |
| |
| String diskDirs = new File(server1.getWorkingDir(), DISKSTORE).getAbsolutePath(); |
| gfsh.executeAndAssertThat( |
| String.format("alter disk-store --name=%s --region=%s --disk-dirs=%s --compressor=foo.Bar", |
| DISKSTORE, REGION_1, diskDirs)) |
| .statusIsError().containsOutput("DISKSTORE: Could not lock"); |
| |
| server1.stop(false); |
| gfsh.disconnect(); |
| |
| gfsh.executeAndAssertThat( |
| String.format( |
| "alter disk-store --name=%s --region=INVALID --disk-dirs=%s --compressor=foo.Bar", |
| DISKSTORE, diskDirs)) |
| .statusIsError() |
| .containsOutput("The disk store does not contain a region named: " + SEPARATOR + "INVALID"); |
| } |
| |
| @Test |
| @Parameters({"compact offline-disk-store", "describe offline-disk-store", |
| "upgrade offline-disk-store", "validate offline-disk-store", |
| "alter disk-store --region=testRegion --enable-statistics=true"}) |
| public void offlineDiskStoreCommandShouldNotCreateFolderIfDiskStoreDoesNotExist( |
| String baseCommand) { |
| Path nonExistingDiskStorePath = |
| Paths.get(tempDir.getRoot().getAbsolutePath() + File.separator + "nonExistingDiskStore"); |
| assertThat(Files.exists(nonExistingDiskStorePath)).isFalse(); |
| gfsh.executeAndAssertThat(baseCommand + " --name=" + DISKSTORE + " --disk-dirs=" |
| + nonExistingDiskStorePath.toAbsolutePath().toString()).statusIsError() |
| .containsOutput("Could not find disk-dirs:"); |
| assertThat(Files.exists(nonExistingDiskStorePath)).isFalse(); |
| } |
| |
| @Test |
| @Parameters({"compact offline-disk-store", "describe offline-disk-store", |
| "upgrade offline-disk-store", "validate offline-disk-store", |
| "alter disk-store --region=testRegion --enable-statistics=true"}) |
| public void offlineDiskStoreCommandShouldFailWhenDiskStoreFileDoesNotExist( |
| String baseCommand) { |
| Path diskStorePath = |
| Paths.get(tempDir.getRoot().getAbsolutePath()); |
| assertThat(Files.exists(diskStorePath)).isTrue(); |
| Path diskStoreFilePath = |
| Paths.get(diskStorePath + File.separator + "BACKUPnonExistingDiskStore" |
| + DiskInitFile.IF_FILE_EXT); |
| assertThat(Files.exists(diskStoreFilePath)).isFalse(); |
| gfsh.executeAndAssertThat(baseCommand + " --name=nonExistingDiskStore --disk-dirs=" |
| + diskStorePath.toAbsolutePath().toString()).statusIsError() |
| .containsOutput("The init file " + diskStoreFilePath + " does not exist."); |
| assertThat(Files.exists(diskStoreFilePath)).isFalse(); |
| } |
| |
| @Test |
| @Parameters(method = "getDiskDirNames") |
| public void validateDiskStoreDiskDirectoryPath(String diskDirectoryName) |
| throws Exception { |
| // Start locator and server |
| MemberVM locator = rule.startLocatorVM(0); |
| MemberVM server = rule.startServerVM(1, locator.getPort()); |
| |
| // Connect gfsh |
| gfsh.connectAndVerify(locator); |
| |
| // Create a disk store with the input disk-dir name |
| gfsh.executeAndAssertThat( |
| String.format("create disk-store --name=%s --dir=%s", DISKSTORE, diskDirectoryName)) |
| .statusIsSuccess() |
| .doesNotContainOutput("Did not complete waiting"); |
| |
| // Verify the server defines the disk store with the disk-dir path |
| server.invoke(() -> verifyDiskStoreInServer(DISKSTORE, diskDirectoryName)); |
| |
| // Verify the cluster config stores the disk store with the input disk-dir path |
| locator.invoke(() -> verifyDiskStoreInClusterConfiguration(diskDirectoryName)); |
| |
| // Stop and start the server |
| rule.stop(1); |
| server = rule.startServerVM(2, locator.getPort()); |
| |
| // Verify the server still defines the disk store with the disk-dir path |
| server.invoke(() -> verifyDiskStoreInServer(DISKSTORE, diskDirectoryName)); |
| } |
| |
| // Invoked via JUnit params |
| @SuppressWarnings("unused") |
| private String[] getDiskDirNames() throws IOException { |
| tempDir.create(); |
| return new String[] {tempDir.newFolder(DISKSTORE).getAbsolutePath(), DISKSTORE}; |
| } |
| |
| private void verifyDiskStoreInServer(String diskStoreName, String diskDirectoryName) { |
| DiskStore diskStore = ClusterStartupRule.getCache().findDiskStore(diskStoreName); |
| assertThat(diskStore).isNotNull(); |
| File[] diskDirs = diskStore.getDiskDirs(); |
| assertThat(diskDirs.length).isEqualTo(1); |
| File diskDir = diskDirs[0]; |
| String absoluteDiskDirectoryName = diskDirectoryName.startsWith(File.separator) |
| ? diskDirectoryName : CURRENT_DIRECTORY + File.separator + diskDirectoryName; |
| assertThat(diskDir.getAbsolutePath()).isEqualTo(absoluteDiskDirectoryName); |
| } |
| |
| private void verifyDiskStoreInClusterConfiguration(String absoluteDirectoryName) { |
| InternalLocator internalLocator = ClusterStartupRule.getLocator(); |
| InternalConfigurationPersistenceService cc = |
| internalLocator.getConfigurationPersistenceService(); |
| CacheConfig config = cc.getCacheConfig("cluster"); |
| List<DiskStoreType> diskStores = config.getDiskStores(); |
| assertThat(diskStores.size()).isEqualTo(1); |
| DiskStoreType diskStore = diskStores.get(0); |
| List<DiskDirType> diskDirs = diskStore.getDiskDirs(); |
| assertThat(diskDirs.size()).isEqualTo(1); |
| DiskDirType diskDir = diskDirs.get(0); |
| assertThat(diskDir.getContent()).isEqualTo(absoluteDirectoryName); |
| } |
| } |