Examples with DB org.mapdb.DB used on opensource projects

Example 1 with DB

use of org.mapdb.DB in project mapdb by jankotek.

the class Issue418Test method test_set.

@Test
public void test_set() {
    final File tmp = TT.tempFile();
    for (int o = 0; o < 2; o++) {
        final DB db = DBMaker.fileDB(tmp).make();
        final Set map = db.hashSet("foo").expireMaxSize(100).createOrOpen();
        for (int i = 0; i < TT.testScale() * 10000; i++) map.add("foo" + i);
        db.commit();
        db.close();
    }
}

Example 2 with DB

use of org.mapdb.DB in project rskj by rsksmart.

the class IndexedBlockStoreTest method test6.

// leveldb + mapdb, multi branch, total difficulty test
@Test
public void test6() throws IOException {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    Map<Long, List<IndexedBlockStore.BlockInfo>> indexMap = createIndexMap(indexDB);
    KeyValueDataSource blocksDB = new LevelDbDataSource(config, "blocks");
    blocksDB.init();
    try {
        IndexedBlockStore indexedBlockStore = new IndexedBlockStore(indexMap, blocksDB, indexDB);
        Block genesis = Genesis.getInstance(config);
        List<Block> bestLine = getRandomChain(genesis.getHash().getBytes(), 1, 100);
        indexedBlockStore.saveBlock(genesis, genesis.getCumulativeDifficulty(), true);
        BlockDifficulty td = genesis.getCumulativeDifficulty();
        for (int i = 0; i < bestLine.size(); ++i) {
            Block newBlock = bestLine.get(i);
            td = td.add(newBlock.getCumulativeDifficulty());
            indexedBlockStore.saveBlock(newBlock, td, true);
        }
        byte[] forkParentHash = bestLine.get(60).getHash().getBytes();
        long forkParentNumber = bestLine.get(60).getNumber();
        List<Block> forkLine = getRandomChain(forkParentHash, forkParentNumber + 1, 50);
        for (int i = 0; i < forkLine.size(); ++i) {
            Block newBlock = forkLine.get(i);
            Block parentBlock = indexedBlockStore.getBlockByHash(newBlock.getParentHash().getBytes());
            td = indexedBlockStore.getTotalDifficultyForHash(parentBlock.getHash().getBytes());
            td = td.add(newBlock.getCumulativeDifficulty());
            indexedBlockStore.saveBlock(newBlock, td, false);
        }
        // calc all TDs
        Map<Keccak256, BlockDifficulty> tDiffs = new HashMap<>();
        td = Genesis.getInstance(config).getCumulativeDifficulty();
        for (Block block : bestLine) {
            td = td.add(block.getCumulativeDifficulty());
            tDiffs.put(block.getHash(), td);
        }
        Map<Keccak256, BlockDifficulty> tForkDiffs = new HashMap<>();
        Block block = forkLine.get(0);
        td = tDiffs.get(block.getParentHash());
        for (Block currBlock : forkLine) {
            td = td.add(currBlock.getCumulativeDifficulty());
            tForkDiffs.put(currBlock.getHash(), td);
        }
        // Assert tds on bestLine
        for (Keccak256 hash : tDiffs.keySet()) {
            BlockDifficulty currTD = tDiffs.get(hash);
            BlockDifficulty checkTd = indexedBlockStore.getTotalDifficultyForHash(hash.getBytes());
            assertEquals(checkTd, currTD);
        }
        // Assert tds on forkLine
        for (Keccak256 hash : tForkDiffs.keySet()) {
            BlockDifficulty currTD = tForkDiffs.get(hash);
            BlockDifficulty checkTd = indexedBlockStore.getTotalDifficultyForHash(hash.getBytes());
            assertEquals(checkTd, currTD);
        }
        indexedBlockStore.flush();
        // Assert tds on bestLine
        for (Keccak256 hash : tDiffs.keySet()) {
            BlockDifficulty currTD = tDiffs.get(hash);
            BlockDifficulty checkTd = indexedBlockStore.getTotalDifficultyForHash(hash.getBytes());
            assertEquals(checkTd, currTD);
        }
        // check total difficulty
        Block bestBlock = bestLine.get(bestLine.size() - 1);
        BlockDifficulty totalDifficulty = indexedBlockStore.getTotalDifficultyForHash(bestBlock.getHash().getBytes());
        BlockDifficulty totalDifficulty_ = tDiffs.get(bestBlock.getHash());
        assertEquals(totalDifficulty_, totalDifficulty);
        // Assert tds on forkLine
        for (Keccak256 hash : tForkDiffs.keySet()) {
            BlockDifficulty currTD = tForkDiffs.get(hash);
            BlockDifficulty checkTd = indexedBlockStore.getTotalDifficultyForHash(hash.getBytes());
            assertEquals(checkTd, currTD);
        }
    } finally {
        blocksDB.close();
        indexDB.close();
        FileUtil.recursiveDelete(testDir);
    }
}

Example 3 with DB

use of org.mapdb.DB in project rskj by rsksmart.

the class TestUtils method createMapDB.

public static DB createMapDB(String testDBDir) {
    String blocksIndexFile = testDBDir + "/blocks/index";
    File dbFile = new File(blocksIndexFile);
    if (!dbFile.getParentFile().exists())
        dbFile.getParentFile().mkdirs();
    DB db = DBMaker.fileDB(dbFile).transactionDisable().closeOnJvmShutdown().make();
    return db;
}

Example 4 with DB

use of org.mapdb.DB in project rskj by rsksmart.

the class IndexedBlockStoreTest method test5.

// leveldb + mapdb, save part to disk part to cache, and check it exist
@Test
@Ignore
public void test5() throws IOException {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    Map<Long, List<IndexedBlockStore.BlockInfo>> indexMap = createIndexMap(indexDB);
    KeyValueDataSource blocksDB = new LevelDbDataSource(config, "blocks");
    blocksDB.init();
    try {
        IndexedBlockStore indexedBlockStore = new IndexedBlockStore(indexMap, blocksDB, indexDB);
        BlockDifficulty cummDiff = BlockDifficulty.ZERO;
        int preloadSize = blocks.size() / 2;
        for (int i = 0; i < preloadSize; ++i) {
            Block block = blocks.get(i);
            cummDiff = cummDiff.add(block.getCumulativeDifficulty());
            indexedBlockStore.saveBlock(block, cummDiff, true);
        }
        indexedBlockStore.flush();
        for (int i = preloadSize; i < blocks.size(); ++i) {
            Block block = blocks.get(i);
            cummDiff = cummDiff.add(block.getCumulativeDifficulty());
            indexedBlockStore.saveBlock(block, cummDiff, true);
        }
        // testing:   getTotalDifficultyForHash(byte[])
        // testing:   getMaxNumber()
        long bestIndex = blocks.get(blocks.size() - 1).getNumber();
        assertEquals(bestIndex, indexedBlockStore.getMaxNumber());
        assertEquals(cumDifficulty, indexedBlockStore.getTotalDifficultyForHash(blocks.get(blocks.size() - 1).getHash().getBytes()));
        // testing:  getBlockByHash(byte[])
        Block block = blocks.get(50);
        Block block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
        assertEquals(block.getNumber(), block_.getNumber());
        block = blocks.get(150);
        block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
        assertEquals(block.getNumber(), block_.getNumber());
        block = blocks.get(0);
        block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
        assertEquals(block.getNumber(), block_.getNumber());
        block = blocks.get(8003);
        block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
        assertEquals(block.getNumber(), block_.getNumber());
        block_ = indexedBlockStore.getBlockByHash(Hex.decode("00112233"));
        assertEquals(null, block_);
        // testing:  getChainBlockByNumber(long)
        block = blocks.get(50);
        block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
        assertEquals(block.getNumber(), block_.getNumber());
        block = blocks.get(150);
        block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
        assertEquals(block.getNumber(), block_.getNumber());
        block = blocks.get(0);
        block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
        assertEquals(block.getNumber(), block_.getNumber());
        block = blocks.get(8003);
        block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
        assertEquals(block.getNumber(), block_.getNumber());
        block_ = indexedBlockStore.getChainBlockByNumber(10000);
        assertEquals(null, block_);
        // testing: getBlocksInformationByNumber(long)
        block = blocks.get(50);
        BlockInformation blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
        Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
        Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
        block = blocks.get(150);
        blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
        Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
        Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
        block = blocks.get(0);
        blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
        Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
        Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
        block = blocks.get(8003);
        blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
        Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
        Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
        int blocksNum = indexedBlockStore.getBlocksInformationByNumber(10000).size();
        assertEquals(0, blocksNum);
        // testing: getListHashesEndWith(byte[], long)
        block = blocks.get(8003);
        List<byte[]> hashList = indexedBlockStore.getListHashesEndWith(block.getHash().getBytes(), 100);
        for (int i = 0; i < 100; ++i) {
            block = blocks.get(8003 - i);
            String hash = Hex.toHexString(hashList.get(i));
            String hash_ = Hex.toHexString(block.getHash().getBytes());
            assertEquals(hash_, hash);
        }
        // testing: getListHashesStartWith(long, long)
        block = blocks.get(7003);
        hashList = indexedBlockStore.getListHashesStartWith(block.getNumber(), 100);
        for (int i = 0; i < 100; ++i) {
            block = blocks.get(7003 + i);
            String hash = Hex.toHexString(hashList.get(i));
            String hash_ = Hex.toHexString(block.getHash().getBytes());
            assertEquals(hash_, hash);
        }
        indexedBlockStore.flush();
        blocksDB.close();
        indexDB.close();
        // testing after: REOPEN
        indexDB = createMapDB(testDir);
        indexMap = createIndexMap(indexDB);
        blocksDB = new LevelDbDataSource(config, "blocks");
        blocksDB.init();
        indexedBlockStore = new IndexedBlockStore(indexMap, blocksDB, indexDB);
        // testing: getListHashesStartWith(long, long)
        block = blocks.get(7003);
        hashList = indexedBlockStore.getListHashesStartWith(block.getNumber(), 100);
        for (int i = 0; i < 100; ++i) {
            block = blocks.get(7003 + i);
            String hash = Hex.toHexString(hashList.get(i));
            String hash_ = Hex.toHexString(block.getHash().getBytes());
            assertEquals(hash_, hash);
        }
    } finally {
        blocksDB.close();
        indexDB.close();
        FileUtil.recursiveDelete(testDir);
    }
}

Example 5 with DB

use of org.mapdb.DB in project rskj by rsksmart.

the class IndexedBlockStoreTest method test4.

// leveldb + mapdb, save some load, flush to disk, and check it exist
@Test
@Ignore
public void test4() throws IOException {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    Map<Long, List<IndexedBlockStore.BlockInfo>> indexMap = createIndexMap(indexDB);
    KeyValueDataSource blocksDB = new LevelDbDataSource(config, "blocks");
    blocksDB.init();
    IndexedBlockStore indexedBlockStore = new IndexedBlockStore(indexMap, blocksDB, indexDB);
    BlockDifficulty cummDiff = BlockDifficulty.ZERO;
    for (Block block : blocks) {
        cummDiff = cummDiff.add(block.getCumulativeDifficulty());
        indexedBlockStore.saveBlock(block, cummDiff, true);
    }
    // testing:   getTotalDifficultyForHash(byte[])
    // testing:   getMaxNumber()
    long bestIndex = blocks.get(blocks.size() - 1).getNumber();
    assertEquals(bestIndex, indexedBlockStore.getMaxNumber());
    assertEquals(cumDifficulty, indexedBlockStore.getTotalDifficultyForHash(blocks.get(blocks.size() - 1).getHash().getBytes()));
    // testing:  getBlockByHash(byte[])
    Block block = blocks.get(50);
    Block block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
    assertEquals(block.getNumber(), block_.getNumber());
    block = blocks.get(150);
    block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
    assertEquals(block.getNumber(), block_.getNumber());
    block = blocks.get(0);
    block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
    assertEquals(block.getNumber(), block_.getNumber());
    block = blocks.get(8003);
    block_ = indexedBlockStore.getBlockByHash(block.getHash().getBytes());
    assertEquals(block.getNumber(), block_.getNumber());
    block_ = indexedBlockStore.getBlockByHash(Hex.decode("00112233"));
    assertEquals(null, block_);
    // testing:  getChainBlockByNumber(long)
    block = blocks.get(50);
    block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
    assertEquals(block.getNumber(), block_.getNumber());
    block = blocks.get(150);
    block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
    assertEquals(block.getNumber(), block_.getNumber());
    block = blocks.get(0);
    block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
    assertEquals(block.getNumber(), block_.getNumber());
    block = blocks.get(8003);
    block_ = indexedBlockStore.getChainBlockByNumber(block.getNumber());
    assertEquals(block.getNumber(), block_.getNumber());
    block_ = indexedBlockStore.getChainBlockByNumber(10000);
    assertEquals(null, block_);
    // testing: getBlocksInformationByNumber(long)
    block = blocks.get(50);
    BlockInformation blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
    Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
    Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
    block = blocks.get(150);
    blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
    Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
    Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
    block = blocks.get(0);
    blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
    Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
    Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
    block = blocks.get(8003);
    blockInformation = indexedBlockStore.getBlocksInformationByNumber(block.getNumber()).get(0);
    Assert.assertArrayEquals(block.getHash().getBytes(), blockInformation.getHash());
    Assert.assertTrue(blockInformation.getTotalDifficulty().compareTo(ZERO) > 0);
    int blocksNum = indexedBlockStore.getBlocksInformationByNumber(10000).size();
    assertEquals(0, blocksNum);
    // testing: getListHashesEndWith(byte[], long)
    block = blocks.get(8003);
    List<byte[]> hashList = indexedBlockStore.getListHashesEndWith(block.getHash().getBytes(), 100);
    for (int i = 0; i < 100; ++i) {
        block = blocks.get(8003 - i);
        String hash = Hex.toHexString(hashList.get(i));
        String hash_ = Hex.toHexString(block.getHash().getBytes());
        assertEquals(hash_, hash);
    }
    // testing: getListHashesStartWith(long, long)
    block = blocks.get(7003);
    hashList = indexedBlockStore.getListHashesStartWith(block.getNumber(), 100);
    for (int i = 0; i < 100; ++i) {
        block = blocks.get(7003 + i);
        String hash = Hex.toHexString(hashList.get(i));
        String hash_ = Hex.toHexString(block.getHash().getBytes());
        assertEquals(hash_, hash);
    }
    blocksDB.close();
    indexDB.close();
    // testing after: REOPEN
    indexDB = createMapDB(testDir);
    indexMap = createIndexMap(indexDB);
    blocksDB = new LevelDbDataSource(config, "blocks");
    blocksDB.init();
    indexedBlockStore = new IndexedBlockStore(indexMap, blocksDB, indexDB);
    // testing: getListHashesStartWith(long, long)
    block = blocks.get(7003);
    hashList = indexedBlockStore.getListHashesStartWith(block.getNumber(), 100);
    for (int i = 0; i < 100; ++i) {
        block = blocks.get(7003 + i);
        String hash = Hex.toHexString(hashList.get(i));
        String hash_ = Hex.toHexString(block.getHash().getBytes());
        assertEquals(hash_, hash);
    }
    blocksDB.close();
    indexDB.close();
    FileUtil.recursiveDelete(testDir);
}