1 /*- 2 * See the file LICENSE for redistribution information. 3 * 4 * Copyright (c) 2002, 2014 Oracle and/or its affiliates. All rights reserved. 5 * 6 */ 7 8 package com.sleepycat.je.log; 9 10 import static org.junit.Assert.fail; 11 12 import java.io.File; 13 import java.io.IOException; 14 15 import org.junit.After; 16 import org.junit.Test; 17 18 import com.sleepycat.je.DatabaseException; 19 import com.sleepycat.je.DbInternal; 20 import com.sleepycat.je.Environment; 21 import com.sleepycat.je.EnvironmentConfig; 22 import com.sleepycat.je.EnvironmentFailureException; 23 import com.sleepycat.je.config.EnvironmentParams; 24 import com.sleepycat.je.dbi.EnvironmentImpl; 25 import com.sleepycat.je.util.TestUtils; 26 import com.sleepycat.util.test.SharedTestUtils; 27 import com.sleepycat.util.test.TestBase; 28 29 /** 30 * File Manager 31 */ 32 public class FileManagerMultiDataDirTest extends TestBase { 33 34 private static int FILE_SIZE = 120; 35 36 private static int N_DATA_DIRS = 3; 37 38 private Environment env; 39 private FileManager fileManager; 40 private final File envHome; 41 FileManagerMultiDataDirTest()42 public FileManagerMultiDataDirTest() { 43 envHome = SharedTestUtils.getTestDir(); 44 } 45 46 @After tearDown()47 public void tearDown() 48 throws IOException, DatabaseException { 49 50 if (fileManager != null) { 51 fileManager.clear(); 52 fileManager.close(); 53 } 54 } 55 createEnvAndFileManager()56 private void createEnvAndFileManager() 57 throws DatabaseException { 58 59 EnvironmentConfig envConfig = TestUtils.initEnvConfig(); 60 DbInternal.disableParameterValidation(envConfig); 61 envConfig.setConfigParam(EnvironmentParams.LOG_FILE_MAX.getName(), 62 new Integer(FILE_SIZE).toString()); 63 /* Yank the cache size way down. */ 64 envConfig.setConfigParam 65 (EnvironmentParams.LOG_FILE_CACHE_SIZE.getName(), "3"); 66 envConfig.setAllowCreate(true); 67 68 envConfig.setConfigParam 69 (EnvironmentParams.LOG_N_DATA_DIRECTORIES.getName(), 70 N_DATA_DIRS + ""); 71 for (int i = 1; i <= N_DATA_DIRS; i += 1) { 72 new File(envHome, "data00" + i).mkdir(); 73 } 74 75 env = new Environment(envHome, envConfig); 76 EnvironmentImpl envImpl = DbInternal.getEnvironmentImpl(env); 77 78 /* Make a standalone file manager for this test. */ 79 envImpl.close(); 80 envImpl.open(); /* Just sets state to OPEN. */ 81 fileManager = new FileManager(envImpl, envHome, false); 82 83 /* 84 * Remove any files after the environment is created again! We want to 85 * remove the files made by recovery, so we can test the file manager 86 * in controlled cases. 87 */ 88 TestUtils.removeFiles("Setup", envHome, FileManager.JE_SUFFIX); 89 } 90 91 @Test testMultipleDataDirs1()92 public void testMultipleDataDirs1() 93 throws Throwable { 94 95 EnvironmentConfig envConfig = TestUtils.initEnvConfig(); 96 envConfig.setAllowCreate(true); 97 98 /* Create 000, 001, 002, 003, expect failure because of 000 */ 99 envConfig.setConfigParam 100 (EnvironmentParams.LOG_N_DATA_DIRECTORIES.getName(), 101 N_DATA_DIRS + ""); 102 for (int i = 1; i <= N_DATA_DIRS; i += 1) { 103 new File(envHome, "data00" + i).mkdir(); 104 } 105 new File(envHome, "data000").mkdir(); 106 107 try { 108 env = new Environment(envHome, envConfig); 109 fail("expected too many dirs exception"); 110 } catch (EnvironmentFailureException EFE) { 111 } 112 113 File dataDir = new File(envHome, "data000"); 114 TestUtils.removeFiles 115 ("TearDown", dataDir, FileManager.JE_SUFFIX); 116 dataDir.delete(); 117 118 /* 119 * Remove any files after the environment is created again! We want to 120 * remove the files made by recovery, so we can test the file manager 121 * in controlled cases. 122 */ 123 TestUtils.removeFiles("Setup", envHome, FileManager.JE_SUFFIX); 124 } 125 126 @Test testMultipleDataDirs2()127 public void testMultipleDataDirs2() 128 throws Throwable { 129 130 EnvironmentConfig envConfig = TestUtils.initEnvConfig(); 131 envConfig.setAllowCreate(true); 132 133 /* Create 001, 002, 004, expect failure because 003 doesn't exist */ 134 envConfig.setConfigParam 135 (EnvironmentParams.LOG_N_DATA_DIRECTORIES.getName(), 136 N_DATA_DIRS + ""); 137 new File(envHome, "data001").mkdir(); 138 new File(envHome, "data002").mkdir(); 139 new File(envHome, "data004").mkdir(); 140 141 try { 142 env = new Environment(envHome, envConfig); 143 fail("expected too many dirs exception"); 144 } catch (EnvironmentFailureException EFE) { 145 } 146 147 File dataDir = new File(envHome, "data004"); 148 TestUtils.removeFiles 149 ("TearDown", dataDir, FileManager.JE_SUFFIX); 150 dataDir.delete(); 151 152 /* 153 * Remove any files after the environment is created again! We want to 154 * remove the files made by recovery, so we can test the file manager 155 * in controlled cases. 156 */ 157 TestUtils.removeFiles("Setup", envHome, FileManager.JE_SUFFIX); 158 } 159 160 @Test testMultipleDataDirs3()161 public void testMultipleDataDirs3() 162 throws Throwable { 163 164 EnvironmentConfig envConfig = TestUtils.initEnvConfig(); 165 envConfig.setAllowCreate(true); 166 167 /* Create 001, 002, expect failure because 003 doesn't exist */ 168 envConfig.setConfigParam 169 (EnvironmentParams.LOG_N_DATA_DIRECTORIES.getName(), 170 N_DATA_DIRS + ""); 171 new File(envHome, "data001").mkdir(); 172 new File(envHome, "data002").mkdir(); 173 174 try { 175 env = new Environment(envHome, envConfig); 176 fail("expected too many dirs exception"); 177 } catch (EnvironmentFailureException EFE) { 178 } 179 180 /* 181 * Remove any files after the environment is created again! We want to 182 * remove the files made by recovery, so we can test the file manager 183 * in controlled cases. 184 */ 185 TestUtils.removeFiles("Setup", envHome, FileManager.JE_SUFFIX); 186 } 187 188 @Test testMultipleDataDirs4()189 public void testMultipleDataDirs4() 190 throws Throwable { 191 192 EnvironmentConfig envConfig = TestUtils.initEnvConfig(); 193 envConfig.setAllowCreate(true); 194 195 /* Create 001, 002, 003, expect failure because 003 is a file */ 196 envConfig.setConfigParam 197 (EnvironmentParams.LOG_N_DATA_DIRECTORIES.getName(), 198 N_DATA_DIRS + ""); 199 new File(envHome, "data001").mkdir(); 200 new File(envHome, "data002").mkdir(); 201 new File(envHome, "data003").createNewFile(); 202 203 try { 204 env = new Environment(envHome, envConfig); 205 fail("expected too many dirs exception"); 206 } catch (EnvironmentFailureException EFE) { 207 } 208 209 /* 210 * Remove any files after the environment is created again! We want to 211 * remove the files made by recovery, so we can test the file manager 212 * in controlled cases. 213 */ 214 TestUtils.removeFiles("Setup", envHome, FileManager.JE_SUFFIX); 215 } 216 217 @Test testMultipleDataDirs5()218 public void testMultipleDataDirs5() 219 throws Throwable { 220 221 EnvironmentConfig envConfig = TestUtils.initEnvConfig(); 222 envConfig.setAllowCreate(true); 223 224 /* Create 001, 002, xxx, expect failure because xxx is not NNN */ 225 envConfig.setConfigParam 226 (EnvironmentParams.LOG_N_DATA_DIRECTORIES.getName(), 227 N_DATA_DIRS + ""); 228 new File(envHome, "data001").mkdir(); 229 new File(envHome, "data002").mkdir(); 230 new File(envHome, "dataxxx").mkdir(); 231 232 try { 233 env = new Environment(envHome, envConfig); 234 fail("expected too many dirs exception"); 235 } catch (EnvironmentFailureException EFE) { 236 } 237 238 File dataDir = new File(envHome, "dataxxx"); 239 TestUtils.removeFiles 240 ("TearDown", dataDir, FileManager.JE_SUFFIX); 241 dataDir.delete(); 242 243 /* 244 * Remove any files after the environment is created again! We want to 245 * remove the files made by recovery, so we can test the file manager 246 * in controlled cases. 247 */ 248 TestUtils.removeFiles("Setup", envHome, FileManager.JE_SUFFIX); 249 } 250 251 @Test testMultipleDataDirs6()252 public void testMultipleDataDirs6() 253 throws Throwable { 254 255 EnvironmentConfig envConfig = TestUtils.initEnvConfig(); 256 envConfig.setAllowCreate(true); 257 258 /* Create 001, 002, xxx, expect failure because xxx is not NNN */ 259 envConfig.setConfigParam 260 (EnvironmentParams.LOG_N_DATA_DIRECTORIES.getName(), "0"); 261 new File(envHome, "data001").mkdir(); 262 new File(envHome, "data002").mkdir(); 263 new File(envHome, "data003").mkdir(); 264 265 try { 266 env = new Environment(envHome, envConfig); 267 fail("expected too many dirs exception"); 268 } catch (EnvironmentFailureException EFE) { 269 } 270 271 File dataDir = new File(envHome, "dataxxx"); 272 TestUtils.removeFiles 273 ("TearDown", dataDir, FileManager.JE_SUFFIX); 274 dataDir.delete(); 275 276 /* 277 * Remove any files after the environment is created again! We want to 278 * remove the files made by recovery, so we can test the file manager 279 * in controlled cases. 280 */ 281 TestUtils.removeFiles("Setup", envHome, FileManager.JE_SUFFIX); 282 } 283 } 284