Examples with MapDBBlocksIndex co.rsk.db.MapDBBlocksIndex used on opensource projects

Example 1 with MapDBBlocksIndex

use of co.rsk.db.MapDBBlocksIndex in project rskj by rsksmart.

the class IndexedBlockStoreTest method test6.

// leveldb + mapdb, multi branch, total difficulty test
@Test
@Ignore("Ethereum block format")
public void test6() throws IOException {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    KeyValueDataSource blocksDB = new LevelDbDataSource("blocks", config.databaseDir());
    blocksDB.init();
    try {
        IndexedBlockStore indexedBlockStore = new IndexedBlockStore(blockFactory, blocksDB, new MapDBBlocksIndex(indexDB));
        Block genesis = RskTestFactory.getGenesisInstance(config);
        List<Block> bestLine = getRandomChain(blockFactory, 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(blockFactory, 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 = RskTestFactory.getGenesisInstance(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 2 with MapDBBlocksIndex

use of co.rsk.db.MapDBBlocksIndex 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() {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    KeyValueDataSource blocksDB = new LevelDbDataSource("blocks", config.databaseDir());
    blocksDB.init();
    try {
        IndexedBlockStore indexedBlockStore = new IndexedBlockStore(blockFactory, blocksDB, new MapDBBlocksIndex(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 = ByteUtil.toHexString(hashList.get(i));
            String hash_ = ByteUtil.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 = ByteUtil.toHexString(hashList.get(i));
            String hash_ = ByteUtil.toHexString(block.getHash().getBytes());
            assertEquals(hash_, hash);
        }
        indexedBlockStore.flush();
        blocksDB.close();
        indexDB.close();
        // testing after: REOPEN
        indexDB = createMapDB(testDir);
        blocksDB = new LevelDbDataSource("blocks", config.databaseDir());
        blocksDB.init();
        indexedBlockStore = new IndexedBlockStore(blockFactory, blocksDB, new MapDBBlocksIndex(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 = ByteUtil.toHexString(hashList.get(i));
            String hash_ = ByteUtil.toHexString(block.getHash().getBytes());
            assertEquals(hash_, hash);
        }
    } finally {
        blocksDB.close();
        indexDB.close();
        FileUtil.recursiveDelete(testDir);
    }
}

Example 3 with MapDBBlocksIndex

use of co.rsk.db.MapDBBlocksIndex in project rskj by rsksmart.

the class IndexedBlockStoreTest method test8.

// leveldb + mapdb, multi branch, total re-branch test
@Test
@Ignore("Ethereum block format")
public void test8() {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    KeyValueDataSource blocksDB = new LevelDbDataSource("blocks", config.databaseDir());
    blocksDB.init();
    try {
        IndexedBlockStore indexedBlockStore = new IndexedBlockStore(blockFactory, blocksDB, new MapDBBlocksIndex(indexDB));
        Block genesis = RskTestFactory.getGenesisInstance(config);
        List<Block> bestLine = getRandomChain(blockFactory, genesis.getHash().getBytes(), 1, 100);
        indexedBlockStore.saveBlock(genesis, genesis.getCumulativeDifficulty(), true);
        BlockDifficulty td = BlockDifficulty.ZERO;
        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(blockFactory, forkParentHash, forkParentNumber + 1, 10);
        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);
        }
        Block bestBlock = bestLine.get(bestLine.size() - 1);
        Block forkBlock = forkLine.get(forkLine.size() - 1);
        assertTrue(indexedBlockStore.getBestBlock().getNumber() == 100);
        indexedBlockStore.reBranch(forkBlock);
        assertTrue(indexedBlockStore.getBestBlock().getNumber() == 71);
        // Assert that all fork moved to the main line
        for (Block currBlock : forkLine) {
            Long number = currBlock.getNumber();
            Block chainBlock = indexedBlockStore.getChainBlockByNumber(number);
            assertEquals(currBlock.getPrintableHash(), chainBlock.getPrintableHash());
        }
        // Assert that all fork moved to the main line
        // re-branch back to previous line and assert that
        // all the block really moved
        bestBlock = bestLine.get(bestLine.size() - 1);
        indexedBlockStore.reBranch(bestBlock);
        for (Block currBlock : bestLine) {
            Long number = currBlock.getNumber();
            Block chainBlock = indexedBlockStore.getChainBlockByNumber(number);
            assertEquals(currBlock.getPrintableHash(), chainBlock.getPrintableHash());
        }
    } finally {
        blocksDB.close();
        indexDB.close();
        FileUtil.recursiveDelete(testDir);
    }
}

Example 4 with MapDBBlocksIndex

use of co.rsk.db.MapDBBlocksIndex 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() {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    KeyValueDataSource blocksDB = new LevelDbDataSource("blocks", config.databaseDir());
    blocksDB.init();
    IndexedBlockStore indexedBlockStore = new IndexedBlockStore(blockFactory, blocksDB, new MapDBBlocksIndex(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 = ByteUtil.toHexString(hashList.get(i));
        String hash_ = ByteUtil.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 = ByteUtil.toHexString(hashList.get(i));
        String hash_ = ByteUtil.toHexString(block.getHash().getBytes());
        assertEquals(hash_, hash);
    }
    blocksDB.close();
    indexDB.close();
    // testing after: REOPEN
    indexDB = createMapDB(testDir);
    blocksDB = new LevelDbDataSource("blocks", config.databaseDir());
    blocksDB.init();
    indexedBlockStore = new IndexedBlockStore(blockFactory, blocksDB, new MapDBBlocksIndex(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 = ByteUtil.toHexString(hashList.get(i));
        String hash_ = ByteUtil.toHexString(block.getHash().getBytes());
        assertEquals(hash_, hash);
    }
    blocksDB.close();
    indexDB.close();
    FileUtil.recursiveDelete(testDir);
}

Example 5 with MapDBBlocksIndex

use of co.rsk.db.MapDBBlocksIndex in project rskj by rsksmart.

the class IndexedBlockStoreTest method test7.

// leveldb + mapdb, multi branch, total re-branch test
@Test
@Ignore("Ethereum block format")
public void test7() throws IOException {
    BigInteger bi = new BigInteger(32, new Random());
    String testDir = "test_db_" + bi;
    config.setDataBaseDir(testDir);
    DB indexDB = createMapDB(testDir);
    KeyValueDataSource blocksDB = new LevelDbDataSource("blocks", config.databaseDir());
    blocksDB.init();
    try {
        IndexedBlockStore indexedBlockStore = new IndexedBlockStore(blockFactory, blocksDB, new MapDBBlocksIndex(indexDB));
        Block genesis = RskTestFactory.getGenesisInstance(config);
        List<Block> bestLine = getRandomChain(blockFactory, 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(blockFactory, 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);
        }
        Block bestBlock = bestLine.get(bestLine.size() - 1);
        Block forkBlock = forkLine.get(forkLine.size() - 1);
        indexedBlockStore.reBranch(forkBlock);
    } finally {
        blocksDB.close();
        indexDB.close();
        FileUtil.recursiveDelete(testDir);
    }
}