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