public boolean setup(boolean readOnly) { boolean open = false; try { EnvironmentConfig envConfig = new EnvironmentConfig(); envConfig.setReadOnly(readOnly); envConfig.setAllowCreate(!readOnly); env = new Environment(envHome, envConfig); StoreConfig storeConfig = new StoreConfig(); storeConfig.setReadOnly(readOnly); storeConfig.setAllowCreate(!readOnly); store = new EntityStore(env, "EntityStore", storeConfig); objectBySid = store.getPrimaryIndex(String.class, TestObject.class); open = true; } catch (EnvironmentLockedException e) { } catch (Exception e) { e.printStackTrace(); System.exit(-1); } return open; }
private Bdb(boolean readOnly, File directory) throws IOException { try { directory.mkdirs(); EnvironmentConfig envConfig = new EnvironmentConfig(); envConfig.setSharedCache(true); envConfig.setReadOnly(readOnly); envConfig.setAllowCreate(!readOnly); /* * int primeForLockTable = SieveForPrimeNumbers.largestPrime( * Runtime.getRuntime().availableProcessors() - 1); * * envConfig.setConfigParam("je.lock.nLockTables", Integer.toString(primeForLockTable)); * envConfig.setConfigParam("je.log.faultReadSize", "4096"); * */ bdbEnv = new Environment(directory, envConfig); } catch (EnvironmentLockedException e) { throw new IOException(e); } catch (DatabaseException e) { throw new IOException(e); } }
/** * Test that any conflicts between configuration object settings and the underlying impl object * are detected. */ @Test public void testConfigConflict() throws Throwable { try { EnvironmentConfig envConfig = TestUtils.initEnvConfig(); envConfig.setAllowCreate(true); env = create(envHome, envConfig); /* * Test conflicts of duplicate allowed configuration. */ /* 1a. Create allowing duplicates. */ DatabaseConfig firstConfig = new DatabaseConfig(); firstConfig.setAllowCreate(true); firstConfig.setSortedDuplicates(true); Database firstHandle = env.openDatabase(null, "fooDups", firstConfig); /* 1b. Try to open w/no duplicates. */ DatabaseConfig secondConfig = new DatabaseConfig(); secondConfig.setSortedDuplicates(false); try { env.openDatabase(null, "fooDups", secondConfig); fail("Conflict in duplicates allowed should be detected."); } catch (IllegalArgumentException expected) { } firstHandle.close(); env.removeDatabase(null, "fooDups"); /* 2a. Create dis-allowing duplicates. */ firstConfig.setSortedDuplicates(false); firstConfig.setKeyPrefixing(false); firstHandle = env.openDatabase(null, "fooDups", firstConfig); /* 2b. Try to open w/duplicates. */ secondConfig.setSortedDuplicates(true); try { env.openDatabase(null, "fooDups", secondConfig); fail("Conflict in duplicates allowed should be detected."); } catch (IllegalArgumentException expected) { } firstHandle.close(); /* * Test conflicts of read only. If the environment is read/write * we should be able to open handles in read only or read/write * mode. If the environment is readonly, the database handles * must also be read only. */ DatabaseConfig readOnlyConfig = new DatabaseConfig(); readOnlyConfig.setReadOnly(true); Database roHandle = env.openDatabase(null, "fooDups", readOnlyConfig); roHandle.close(); /* Open the environment in read only mode. */ close(env); envConfig = TestUtils.initEnvConfig(); envConfig.setReadOnly(true); env = create(envHome, envConfig); /* Open a readOnly database handle, should succeed */ roHandle = env.openDatabase(null, "fooDups", readOnlyConfig); roHandle.close(); /* Open a read/write database handle, should not succeed. */ try { env.openDatabase(null, "fooDups", null); fail("Should not be able to open read/write"); } catch (IllegalArgumentException expected) { } close(env); /* * Check comparator changes. */ /* 1a. Open w/a null comparator */ env = create(envHome, null); firstConfig = new DatabaseConfig(); firstConfig.setAllowCreate(true); firstHandle = env.openDatabase(null, "fooComparator", firstConfig); DatabaseConfig firstRetrievedConfig = firstHandle.getConfig(); assertEquals(null, firstRetrievedConfig.getBtreeComparator()); assertEquals(null, firstRetrievedConfig.getDuplicateComparator()); /* * 1b. Open a db w/a different comparator, shouldn't take effect * because override is not set. */ secondConfig = new DatabaseConfig(); Comparator btreeComparator = new TestComparator(); Comparator dupComparator = new TestComparator(); secondConfig.setBtreeComparator((Class<Comparator<byte[]>>) btreeComparator.getClass()); secondConfig.setDuplicateComparator((Class<Comparator<byte[]>>) dupComparator.getClass()); Database secondHandle = env.openDatabase(null, "fooComparator", secondConfig); DatabaseConfig retrievedConfig = secondHandle.getConfig(); assertEquals(null, retrievedConfig.getBtreeComparator()); assertEquals(null, retrievedConfig.getDuplicateComparator()); secondHandle.close(); /* Same as above but with a serialized comparator. */ secondConfig = new DatabaseConfig(); btreeComparator = new TestSerialComparator(); dupComparator = new TestSerialComparator(); secondConfig.setBtreeComparator(btreeComparator); secondConfig.setDuplicateComparator(dupComparator); secondHandle = env.openDatabase(null, "fooComparator", secondConfig); retrievedConfig = secondHandle.getConfig(); assertEquals(null, retrievedConfig.getBtreeComparator()); assertEquals(null, retrievedConfig.getDuplicateComparator()); secondHandle.close(); /* * Test that update DatabaseConfig while there are open handles * should throw exceptions. */ secondConfig.setOverrideBtreeComparator(true); secondConfig.setOverrideDuplicateComparator(true); btreeComparator = new TestComparator(); dupComparator = new TestComparator(); secondConfig.setBtreeComparator((Class<Comparator<byte[]>>) btreeComparator.getClass()); secondConfig.setDuplicateComparator((Class<Comparator<byte[]>>) dupComparator.getClass()); try { secondHandle = env.openDatabase(null, "fooComparator", secondConfig); fail("Expect exceptions here"); } catch (IllegalStateException e) { /* Expected exception. */ } catch (Exception e) { fail("Unexpected exception: " + e.getMessage()); } secondHandle.close(); /* * Open a new database handle without DatabaseConfig changes should * be valid. */ try { secondHandle = env.openDatabase(null, "fooComparator", firstConfig); } catch (Exception e) { fail("Unexpected exception: " + e.getMessage()); } secondHandle.close(); firstHandle.close(); close(env); } catch (Throwable t) { t.printStackTrace(); close(env); throw t; } }