target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void setBlocksBloom() { BlocksBloom blocksBloom = new BlocksBloom(); byte[] bytes1 = new byte[Bloom.BLOOM_BYTES]; bytes1[0] = 0x01; byte[] bytes2 = new byte[Bloom.BLOOM_BYTES]; bytes2[1] = 0x10; Bloom bloom1 = new Bloom(bytes1); Bloom bloom2 = new Bloom(bytes2); BlocksBloomStore blocksBloomStore = new BlocksBloomStore(64, 0, null); blocksBloom.addBlockBloom(blocksBloomStore.getNoBlocks(), bloom1); blocksBloom.addBlockBloom(blocksBloomStore.getNoBlocks() + 1, bloom2); blocksBloomStore.setBlocksBloom(blocksBloom); Assert.assertSame(blocksBloom, blocksBloomStore.getBlocksBloomByNumber(blocksBloomStore.getNoBlocks())); }
|
public void setBlocksBloom(BlocksBloom blocksBloom) { this.blocksBloom.put(blocksBloom.fromBlock(), blocksBloom); if (this.dataSource != null) { this.dataSource.put(longToKey(blocksBloom.fromBlock()), BlocksBloomEncoder.encode(blocksBloom)); } }
|
BlocksBloomStore { public void setBlocksBloom(BlocksBloom blocksBloom) { this.blocksBloom.put(blocksBloom.fromBlock(), blocksBloom); if (this.dataSource != null) { this.dataSource.put(longToKey(blocksBloom.fromBlock()), BlocksBloomEncoder.encode(blocksBloom)); } } }
|
BlocksBloomStore { public void setBlocksBloom(BlocksBloom blocksBloom) { this.blocksBloom.put(blocksBloom.fromBlock(), blocksBloom); if (this.dataSource != null) { this.dataSource.put(longToKey(blocksBloom.fromBlock()), BlocksBloomEncoder.encode(blocksBloom)); } } BlocksBloomStore(int noBlocks, int noConfirmations, KeyValueDataSource dataSource); }
|
BlocksBloomStore { public void setBlocksBloom(BlocksBloom blocksBloom) { this.blocksBloom.put(blocksBloom.fromBlock(), blocksBloom); if (this.dataSource != null) { this.dataSource.put(longToKey(blocksBloom.fromBlock()), BlocksBloomEncoder.encode(blocksBloom)); } } BlocksBloomStore(int noBlocks, int noConfirmations, KeyValueDataSource dataSource); boolean hasBlockNumber(long blockNumber); BlocksBloom getBlocksBloomByNumber(long number); void setBlocksBloom(BlocksBloom blocksBloom); long firstNumberInRange(long number); long lastNumberInRange(long number); int getNoBlocks(); int getNoConfirmations(); static byte[] longToKey(long value); }
|
BlocksBloomStore { public void setBlocksBloom(BlocksBloom blocksBloom) { this.blocksBloom.put(blocksBloom.fromBlock(), blocksBloom); if (this.dataSource != null) { this.dataSource.put(longToKey(blocksBloom.fromBlock()), BlocksBloomEncoder.encode(blocksBloom)); } } BlocksBloomStore(int noBlocks, int noConfirmations, KeyValueDataSource dataSource); boolean hasBlockNumber(long blockNumber); BlocksBloom getBlocksBloomByNumber(long number); void setBlocksBloom(BlocksBloom blocksBloom); long firstNumberInRange(long number); long lastNumberInRange(long number); int getNoBlocks(); int getNoConfirmations(); static byte[] longToKey(long value); }
|
@Test public void addTwoNonConsecutiveBlocksToBlocksBloom() { BlocksBloom blocksBloom = new BlocksBloom(); byte[] bytes1 = new byte[Bloom.BLOOM_BYTES]; bytes1[0] = 0x01; byte[] bytes2 = new byte[Bloom.BLOOM_BYTES]; bytes2[1] = 0x10; Bloom bloom1 = new Bloom(bytes1); Bloom bloom2 = new Bloom(bytes2); exception.expect(UnsupportedOperationException.class); exception.expectMessage("Block out of sequence"); blocksBloom.addBlockBloom(1, bloom1); blocksBloom.addBlockBloom(3, bloom2); }
|
public void addBlockBloom(long blockNumber, Bloom blockBloom) { if (this.empty) { this.fromBlock = blockNumber; this.toBlock = blockNumber; this.empty = false; } else if (blockNumber == toBlock + 1) { this.toBlock = blockNumber; } else { throw new UnsupportedOperationException("Block out of sequence"); } this.bloom.or(blockBloom); }
|
BlocksBloom { public void addBlockBloom(long blockNumber, Bloom blockBloom) { if (this.empty) { this.fromBlock = blockNumber; this.toBlock = blockNumber; this.empty = false; } else if (blockNumber == toBlock + 1) { this.toBlock = blockNumber; } else { throw new UnsupportedOperationException("Block out of sequence"); } this.bloom.or(blockBloom); } }
|
BlocksBloom { public void addBlockBloom(long blockNumber, Bloom blockBloom) { if (this.empty) { this.fromBlock = blockNumber; this.toBlock = blockNumber; this.empty = false; } else if (blockNumber == toBlock + 1) { this.toBlock = blockNumber; } else { throw new UnsupportedOperationException("Block out of sequence"); } this.bloom.or(blockBloom); } BlocksBloom(); BlocksBloom(long fromBlock, long toBlock, Bloom bloom); }
|
BlocksBloom { public void addBlockBloom(long blockNumber, Bloom blockBloom) { if (this.empty) { this.fromBlock = blockNumber; this.toBlock = blockNumber; this.empty = false; } else if (blockNumber == toBlock + 1) { this.toBlock = blockNumber; } else { throw new UnsupportedOperationException("Block out of sequence"); } this.bloom.or(blockBloom); } BlocksBloom(); BlocksBloom(long fromBlock, long toBlock, Bloom bloom); Bloom getBloom(); long fromBlock(); long toBlock(); long size(); void addBlockBloom(long blockNumber, Bloom blockBloom); boolean matches(Bloom bloom); }
|
BlocksBloom { public void addBlockBloom(long blockNumber, Bloom blockBloom) { if (this.empty) { this.fromBlock = blockNumber; this.toBlock = blockNumber; this.empty = false; } else if (blockNumber == toBlock + 1) { this.toBlock = blockNumber; } else { throw new UnsupportedOperationException("Block out of sequence"); } this.bloom.or(blockBloom); } BlocksBloom(); BlocksBloom(long fromBlock, long toBlock, Bloom bloom); Bloom getBloom(); long fromBlock(); long toBlock(); long size(); void addBlockBloom(long blockNumber, Bloom blockBloom); boolean matches(Bloom bloom); }
|
@Test public void doesNotMatchBloom() { BlocksBloom blocksBloom = new BlocksBloom(); byte[] bytes1 = new byte[Bloom.BLOOM_BYTES]; bytes1[0] = 0x01; byte[] bytes2 = new byte[Bloom.BLOOM_BYTES]; bytes2[1] = 0x10; Bloom bloom1 = new Bloom(bytes1); Bloom bloom2 = new Bloom(bytes2); Assert.assertFalse(blocksBloom.matches(bloom1)); Assert.assertFalse(blocksBloom.matches(bloom2)); bloom1.or(bloom2); Assert.assertFalse(blocksBloom.matches(bloom1)); }
|
public boolean matches(Bloom bloom) { return this.bloom.matches(bloom); }
|
BlocksBloom { public boolean matches(Bloom bloom) { return this.bloom.matches(bloom); } }
|
BlocksBloom { public boolean matches(Bloom bloom) { return this.bloom.matches(bloom); } BlocksBloom(); BlocksBloom(long fromBlock, long toBlock, Bloom bloom); }
|
BlocksBloom { public boolean matches(Bloom bloom) { return this.bloom.matches(bloom); } BlocksBloom(); BlocksBloom(long fromBlock, long toBlock, Bloom bloom); Bloom getBloom(); long fromBlock(); long toBlock(); long size(); void addBlockBloom(long blockNumber, Bloom blockBloom); boolean matches(Bloom bloom); }
|
BlocksBloom { public boolean matches(Bloom bloom) { return this.bloom.matches(bloom); } BlocksBloom(); BlocksBloom(long fromBlock, long toBlock, Bloom bloom); Bloom getBloom(); long fromBlock(); long toBlock(); long size(); void addBlockBloom(long blockNumber, Bloom blockBloom); boolean matches(Bloom bloom); }
|
@Test public void oneBlockAndEvent() { NewBlockFilter filter = new NewBlockFilter(); Block block = new BlockGenerator().getBlock(1); filter.newBlockReceived(block); Object[] result = filter.getEvents(); Assert.assertNotNull(result); Assert.assertEquals(1, result.length); Assert.assertEquals("0x" + block.getHash(), result[0]); }
|
@Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } @Override void newBlockReceived(Block b); }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } @Override void newBlockReceived(Block b); }
|
@Test public void createRemascConfig() { RemascConfigFactory factory = new RemascConfigFactory(REMASC_FILE); Assert.assertNotNull(factory); RemascConfig remascConfig = factory.createRemascConfig("devnet"); Assert.assertNotNull(remascConfig); Assert.assertNotNull(remascConfig.getMaturity()); Assert.assertNotNull(remascConfig.getPublishersDivisor()); Assert.assertNotNull(remascConfig.getPunishmentDivisor()); Assert.assertNotNull(remascConfig.getRskLabsAddress()); Assert.assertNotEquals(RskAddress.nullAddress(), remascConfig.getRskLabsAddress()); Assert.assertNotNull(remascConfig.getRskLabsDivisor()); Assert.assertNotNull(remascConfig.getSyntheticSpan()); Assert.assertNotNull(remascConfig.getLateUncleInclusionPunishmentDivisor()); remascConfig = factory.createRemascConfig("regtest"); Assert.assertNotNull(remascConfig); Assert.assertNotNull(remascConfig.getMaturity()); Assert.assertNotNull(remascConfig.getPublishersDivisor()); Assert.assertNotNull(remascConfig.getPunishmentDivisor()); Assert.assertNotNull(remascConfig.getRskLabsAddress()); Assert.assertNotEquals(RskAddress.nullAddress(), remascConfig.getRskLabsAddress()); Assert.assertNotNull(remascConfig.getRskLabsDivisor()); Assert.assertNotNull(remascConfig.getSyntheticSpan()); Assert.assertNotNull(remascConfig.getLateUncleInclusionPunishmentDivisor()); remascConfig = factory.createRemascConfig("main"); Assert.assertNotNull(remascConfig); Assert.assertNotNull(remascConfig.getMaturity()); Assert.assertNotNull(remascConfig.getPublishersDivisor()); Assert.assertNotNull(remascConfig.getPunishmentDivisor()); Assert.assertNotNull(remascConfig.getRskLabsAddress()); Assert.assertNotEquals(RskAddress.nullAddress(), remascConfig.getRskLabsAddress()); Assert.assertNotNull(remascConfig.getRskLabsDivisor()); Assert.assertNotNull(remascConfig.getSyntheticSpan()); Assert.assertNotNull(remascConfig.getLateUncleInclusionPunishmentDivisor()); remascConfig = factory.createRemascConfig("testnet"); Assert.assertNotNull(remascConfig); Assert.assertNotNull(remascConfig.getMaturity()); Assert.assertNotNull(remascConfig.getPublishersDivisor()); Assert.assertNotNull(remascConfig.getPunishmentDivisor()); Assert.assertNotNull(remascConfig.getRskLabsAddress()); Assert.assertNotEquals(RskAddress.nullAddress(), remascConfig.getRskLabsAddress()); Assert.assertNotNull(remascConfig.getRskLabsDivisor()); Assert.assertNotNull(remascConfig.getSyntheticSpan()); Assert.assertNotNull(remascConfig.getLateUncleInclusionPunishmentDivisor()); }
|
public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); RemascConfig createRemascConfig(String config); }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); RemascConfig createRemascConfig(String config); }
|
@Test(expected = RemascException.class) public void createRemascConfigInvalidFile() { RemascConfigFactory factory = new RemascConfigFactory("NotAFile"); factory.createRemascConfig("testnet"); Assert.fail("This should FAIL"); }
|
public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); RemascConfig createRemascConfig(String config); }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); RemascConfig createRemascConfig(String config); }
|
@Test(expected = RemascException.class) public void createRemascConfigInvalidConfig() { RemascConfigFactory factory = new RemascConfigFactory(REMASC_FILE); factory.createRemascConfig("fakeNet"); Assert.fail("This should FAIL"); }
|
public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); RemascConfig createRemascConfig(String config); }
|
RemascConfigFactory { public RemascConfig createRemascConfig(String config) { RemascConfig remascConfig; try (InputStream is = RemascConfigFactory.class.getClassLoader().getResourceAsStream(this.configPath)){ JsonNode node = mapper.readTree(is); remascConfig = mapper.treeToValue(node.get(config), RemascConfig.class); } catch (Exception ex) { logger.error("Error reading REMASC configuration[{}]: {}", config, ex); throw new RemascException("Error reading REMASC configuration[" + config +"]: ", ex); } return remascConfig; } RemascConfigFactory(String remascConfigFile); RemascConfig createRemascConfig(String config); }
|
@Test public void loadBaseMainnetConfigWithEmptyCliArgs() { Config config = loader.getConfig(); assertThat(config.getString(SystemProperties.PROPERTY_BC_CONFIG_NAME), is("main")); assertThat(config.getBoolean(SystemProperties.PROPERTY_DB_RESET), is(false)); assertThat(config.getString(SystemProperties.PROPERTY_RPC_CORS), is("localhost")); assertThat(config.getBoolean(SystemProperties.PROPERTY_RPC_HTTP_ENABLED), is(true)); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void regtestCliFlagOverridesNetworkBaseConfig() { when(cliArgs.getFlags()) .thenReturn(Collections.singleton(NodeCliFlags.NETWORK_REGTEST)); Config config = loader.getConfig(); assertThat(config.getString(SystemProperties.PROPERTY_BC_CONFIG_NAME), is("regtest")); assertThat(config.getBoolean(SystemProperties.PROPERTY_RPC_HTTP_ENABLED), is(true)); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void testnetCliFlagOverridesNetworkBaseConfig() { when(cliArgs.getFlags()) .thenReturn(Collections.singleton(NodeCliFlags.NETWORK_TESTNET)); Config config = loader.getConfig(); assertThat(config.getString(SystemProperties.PROPERTY_BC_CONFIG_NAME), is("testnet")); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void dbResetCliFlagEnablesReset() { when(cliArgs.getFlags()) .thenReturn(Collections.singleton(NodeCliFlags.DB_RESET)); Config config = loader.getConfig(); assertThat(config.getString(SystemProperties.PROPERTY_BC_CONFIG_NAME), is("main")); assertThat(config.getBoolean(SystemProperties.PROPERTY_DB_RESET), is(true)); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void rpcCorsCliOptionEnablesCorsAndChangesHostname() { when(cliArgs.getOptions()) .thenReturn(Collections.singletonMap(NodeCliOptions.RPC_CORS, "myhostname")); Config config = loader.getConfig(); assertThat(config.getString(SystemProperties.PROPERTY_RPC_CORS), is("myhostname")); assertThat(config.getBoolean(SystemProperties.PROPERTY_RPC_HTTP_ENABLED), is(true)); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void verifyConfigSettingIsOffByDefault() { Config config = loader.getConfig(); assertThat(config.getBoolean(SystemProperties.PROPERTY_BC_VERIFY), is(false)); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void setVerifyConfigSetting() { when(cliArgs.getFlags()).thenReturn(Collections.singleton(NodeCliFlags.VERIFY_CONFIG)); Config config = loader.getConfig(); assertThat(config.getBoolean(SystemProperties.PROPERTY_BC_VERIFY), is(true)); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void twoBlocksAndEvents() { NewBlockFilter filter = new NewBlockFilter(); Block block1 = new BlockGenerator().getBlock(1); Block block2 = new BlockGenerator().getBlock(2); filter.newBlockReceived(block1); filter.newBlockReceived(block2); Object[] result = filter.getEvents(); Assert.assertNotNull(result); Assert.assertEquals(2, result.length); Assert.assertEquals("0x" + block1.getHash(), result[0]); Assert.assertEquals("0x" + block2.getHash(), result[1]); }
|
@Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } @Override void newBlockReceived(Block b); }
|
NewBlockFilter extends Filter { @Override public void newBlockReceived(Block b) { add(new NewBlockFilterEvent(b)); } @Override void newBlockReceived(Block b); }
|
@Test(expected = RskConfigurationException.class) public void detectUnexpectedKeyProblem() { Config defaultConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("unexpectedKey", NULL_VALUE); Config expectedConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("expectedKey", NULL_VALUE); mockConfigFactory(defaultConfig, expectedConfig); loader.getConfig(); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test(expected = RskConfigurationException.class) public void detectExpectedScalarValueProblemInObject() { Config defaultConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("expectedKey.nestedKey", EMPTY_OBJECT_VALUE); Config expectedConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("expectedKey", EMPTY_OBJECT_VALUE); mockConfigFactory(defaultConfig, expectedConfig); loader.getConfig(); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Parameterized.Parameters @Test(expected = RskConfigurationException.class) public void detectExpectedScalarValueProblemInList() { Config defaultConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("expectedKey", ConfigValueFactory.fromIterable(Collections.singletonList(EMPTY_LIST_VALUE))); Config expectedConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("expectedKey", EMPTY_LIST_VALUE); mockConfigFactory(defaultConfig, expectedConfig); loader.getConfig(); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void detectTypeMismatchProblem() { ConfigValue[] values = { NULL_VALUE, TRUE_VALUE, ZERO_VALUE, STRING_VALUE, EMPTY_OBJECT_VALUE, EMPTY_LIST_VALUE }; Predicate<ConfigValueType> isCollectionType = ConfigLoader::isCollectionType; BiConsumer<ConfigValue, ConfigValue> checkTypeMismatchProblem = (ConfigValue expectedValue, ConfigValue actualValue) -> { Config defaultConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("expectedKey", actualValue); Config expectedConfig = EMPTY_CONFIG .withValue("blockchain.config.verify", TRUE_VALUE) .withValue("expectedKey", expectedValue); mockConfigFactory(defaultConfig, expectedConfig); try { loader.getConfig(); fail("Type mismatch problem is not detected"); } catch (RskConfigurationException e) { } }; Stream.of(values) .flatMap(expectedValue -> Stream.of(values) .filter(actualValue -> expectedValue.valueType() != actualValue.valueType() && (isCollectionType.test(expectedValue.valueType()) || isCollectionType.test(actualValue.valueType()))) .map(actualValue -> Pair.of(expectedValue, actualValue))) .forEach(pair -> checkTypeMismatchProblem.accept(pair.getLeft(), pair.getRight())); }
|
public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
ConfigLoader { public Config getConfig() { Config cliConfig = getConfigFromCliArgs(); Config systemPropsConfig = ConfigFactory.systemProperties(); Config systemEnvConfig = ConfigFactory.systemEnvironment(); Config userCustomConfig = getUserCustomConfig(); Config installerConfig = getInstallerConfig(); Config userConfig = ConfigFactory.empty() .withFallback(cliConfig) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig) .withFallback(userCustomConfig) .withFallback(installerConfig); Config networkBaseConfig = getNetworkDefaultConfig(userConfig); Config unifiedConfig = userConfig.withFallback(networkBaseConfig); Config expectedConfig = ConfigFactory.parseResourcesAnySyntax(EXPECTED_RESOURCE_PATH) .withFallback(systemPropsConfig) .withFallback(systemEnvConfig); boolean valid = isActualObjectValid("", expectedConfig.root(), unifiedConfig.root()); if (unifiedConfig.getBoolean(SystemProperties.PROPERTY_BC_VERIFY) && !valid) { throw new RskConfigurationException("Verification of node config settings has failed. See the previous error logs for details."); } return unifiedConfig; } ConfigLoader(CliArgs<NodeCliOptions, NodeCliFlags> cliArgs); Config getConfig(); static boolean isCollectionType(ConfigValueType valueType); }
|
@Test public void getUnknownBlockAsNull() { NetBlockStore store = new NetBlockStore(); Assert.assertNull(store.getBlockByHash(TestUtils.randomBytes(32))); }
|
public synchronized Block getBlockByHash(byte[] hash) { return this.blocks.get(new Keccak256(hash)); }
|
NetBlockStore { public synchronized Block getBlockByHash(byte[] hash) { return this.blocks.get(new Keccak256(hash)); } }
|
NetBlockStore { public synchronized Block getBlockByHash(byte[] hash) { return this.blocks.get(new Keccak256(hash)); } }
|
NetBlockStore { public synchronized Block getBlockByHash(byte[] hash) { return this.blocks.get(new Keccak256(hash)); } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
NetBlockStore { public synchronized Block getBlockByHash(byte[] hash) { return this.blocks.get(new Keccak256(hash)); } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
@Test public void releaseRange() { NetBlockStore store = new NetBlockStore(); final BlockGenerator generator = new BlockGenerator(); Block genesis = generator.getGenesisBlock(); List<Block> blocks1 = generator.getBlockChain(genesis, 1000); List<Block> blocks2 = generator.getBlockChain(genesis, 1000); for (Block b : blocks1) store.saveBlock(b); for (Block b : blocks2) store.saveBlock(b); Assert.assertEquals(2000, store.size()); store.releaseRange(1, 1000); Assert.assertEquals(0, store.size()); }
|
public synchronized void releaseRange(long from, long to) { for (long k = from; k <= to; k++) { for (Block b : this.getBlocksByNumber(k)) { this.removeBlock(b); } } }
|
NetBlockStore { public synchronized void releaseRange(long from, long to) { for (long k = from; k <= to; k++) { for (Block b : this.getBlocksByNumber(k)) { this.removeBlock(b); } } } }
|
NetBlockStore { public synchronized void releaseRange(long from, long to) { for (long k = from; k <= to; k++) { for (Block b : this.getBlocksByNumber(k)) { this.removeBlock(b); } } } }
|
NetBlockStore { public synchronized void releaseRange(long from, long to) { for (long k = from; k <= to; k++) { for (Block b : this.getBlocksByNumber(k)) { this.removeBlock(b); } } } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
NetBlockStore { public synchronized void releaseRange(long from, long to) { for (long k = from; k <= to; k++) { for (Block b : this.getBlocksByNumber(k)) { this.removeBlock(b); } } } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
@Test public void saveHeader() { NetBlockStore store = new NetBlockStore(); BlockHeader blockHeader = blockFactory.getBlockHeaderBuilder() .setParentHash(new byte[0]) .setCoinbase(TestUtils.randomAddress()) .setNumber(1) .setMinimumGasPrice(Coin.ZERO) .build(); store.saveHeader(blockHeader); Assert.assertTrue(store.hasHeader(blockHeader.getHash())); }
|
public synchronized void saveHeader(@Nonnull final BlockHeader header) { this.headers.put(header.getHash(), header); }
|
NetBlockStore { public synchronized void saveHeader(@Nonnull final BlockHeader header) { this.headers.put(header.getHash(), header); } }
|
NetBlockStore { public synchronized void saveHeader(@Nonnull final BlockHeader header) { this.headers.put(header.getHash(), header); } }
|
NetBlockStore { public synchronized void saveHeader(@Nonnull final BlockHeader header) { this.headers.put(header.getHash(), header); } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
NetBlockStore { public synchronized void saveHeader(@Nonnull final BlockHeader header) { this.headers.put(header.getHash(), header); } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
@Test public void removeHeader() { NetBlockStore store = new NetBlockStore(); BlockHeader blockHeader = blockFactory.getBlockHeaderBuilder() .setParentHash(new byte[0]) .setCoinbase(TestUtils.randomAddress()) .setNumber(1) .setMinimumGasPrice(Coin.ZERO) .build(); store.saveHeader(blockHeader); store.removeHeader(blockHeader); Assert.assertFalse(store.hasHeader(blockHeader.getHash())); }
|
public synchronized void removeHeader(@Nonnull final BlockHeader header) { if (!this.hasHeader(header.getHash())) { return; } this.headers.remove(header.getHash()); }
|
NetBlockStore { public synchronized void removeHeader(@Nonnull final BlockHeader header) { if (!this.hasHeader(header.getHash())) { return; } this.headers.remove(header.getHash()); } }
|
NetBlockStore { public synchronized void removeHeader(@Nonnull final BlockHeader header) { if (!this.hasHeader(header.getHash())) { return; } this.headers.remove(header.getHash()); } }
|
NetBlockStore { public synchronized void removeHeader(@Nonnull final BlockHeader header) { if (!this.hasHeader(header.getHash())) { return; } this.headers.remove(header.getHash()); } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
NetBlockStore { public synchronized void removeHeader(@Nonnull final BlockHeader header) { if (!this.hasHeader(header.getHash())) { return; } this.headers.remove(header.getHash()); } synchronized void saveBlock(Block block); synchronized void removeBlock(Block block); synchronized Block getBlockByHash(byte[] hash); synchronized List<Block> getBlocksByNumber(long number); synchronized List<Block> getBlocksByParentHash(Keccak256 hash); List<Block> getChildrenOf(Set<Block> blocks); synchronized boolean hasBlock(Block block); synchronized boolean hasBlock(byte[] hash); synchronized int size(); synchronized long minimalHeight(); synchronized long maximumHeight(); synchronized void releaseRange(long from, long to); synchronized boolean hasHeader(Keccak256 hash); synchronized void saveHeader(@Nonnull final BlockHeader header); synchronized void removeHeader(@Nonnull final BlockHeader header); }
|
@Test public void decode() throws Exception { ECKey key1 = ECKey.fromPrivate(Hex.decode(KEY_1)).decompress(); String check = UUID.randomUUID().toString(); ChannelHandlerContext ctx = Mockito.mock(ChannelHandlerContext.class); PacketDecoder decoder = new PacketDecoder(); PingPeerMessage nodeMessage = PingPeerMessage.create("localhost", 44035, check, key1, NETWORK_ID); InetSocketAddress sender = new InetSocketAddress("localhost", 44035); this.assertDecodedMessage(decoder.decodeMessage(ctx, nodeMessage.getPacket(), sender), sender, DiscoveryMessageType.PING); PongPeerMessage pongPeerMessage = PongPeerMessage.create("localhost", 44036, check, key1, NETWORK_ID); sender = new InetSocketAddress("localhost", 44036); this.assertDecodedMessage(decoder.decodeMessage(ctx, pongPeerMessage.getPacket(), sender), sender, DiscoveryMessageType.PONG); FindNodePeerMessage findNodePeerMessage = FindNodePeerMessage.create(key1.getNodeId(), check, key1, NETWORK_ID); sender = new InetSocketAddress("localhost", 44037); this.assertDecodedMessage(decoder.decodeMessage(ctx, findNodePeerMessage.getPacket(), sender), sender, DiscoveryMessageType.FIND_NODE); NeighborsPeerMessage neighborsPeerMessage = NeighborsPeerMessage.create(new ArrayList<>(), check, key1, NETWORK_ID); sender = new InetSocketAddress("localhost", 44038); this.assertDecodedMessage(decoder.decodeMessage(ctx, neighborsPeerMessage.getPacket(), sender), sender, DiscoveryMessageType.NEIGHBORS); }
|
@Override public void decode(ChannelHandlerContext ctx, DatagramPacket packet, List<Object> out) throws Exception { ByteBuf buf = packet.content(); byte[] encoded = new byte[buf.readableBytes()]; buf.readBytes(encoded); out.add(this.decodeMessage(ctx, encoded, packet.sender())); }
|
PacketDecoder extends MessageToMessageDecoder<DatagramPacket> { @Override public void decode(ChannelHandlerContext ctx, DatagramPacket packet, List<Object> out) throws Exception { ByteBuf buf = packet.content(); byte[] encoded = new byte[buf.readableBytes()]; buf.readBytes(encoded); out.add(this.decodeMessage(ctx, encoded, packet.sender())); } }
|
PacketDecoder extends MessageToMessageDecoder<DatagramPacket> { @Override public void decode(ChannelHandlerContext ctx, DatagramPacket packet, List<Object> out) throws Exception { ByteBuf buf = packet.content(); byte[] encoded = new byte[buf.readableBytes()]; buf.readBytes(encoded); out.add(this.decodeMessage(ctx, encoded, packet.sender())); } }
|
PacketDecoder extends MessageToMessageDecoder<DatagramPacket> { @Override public void decode(ChannelHandlerContext ctx, DatagramPacket packet, List<Object> out) throws Exception { ByteBuf buf = packet.content(); byte[] encoded = new byte[buf.readableBytes()]; buf.readBytes(encoded); out.add(this.decodeMessage(ctx, encoded, packet.sender())); } @Override void decode(ChannelHandlerContext ctx, DatagramPacket packet, List<Object> out); DiscoveryEvent decodeMessage(ChannelHandlerContext ctx, byte[] encoded, InetSocketAddress sender); }
|
PacketDecoder extends MessageToMessageDecoder<DatagramPacket> { @Override public void decode(ChannelHandlerContext ctx, DatagramPacket packet, List<Object> out) throws Exception { ByteBuf buf = packet.content(); byte[] encoded = new byte[buf.readableBytes()]; buf.readBytes(encoded); out.add(this.decodeMessage(ctx, encoded, packet.sender())); } @Override void decode(ChannelHandlerContext ctx, DatagramPacket packet, List<Object> out); DiscoveryEvent decodeMessage(ChannelHandlerContext ctx, byte[] encoded, InetSocketAddress sender); }
|
@Test public void creation() { Node localNode = new Node(Hex.decode(NODE_ID_1), HOST, PORT_1); NodeDistanceTable table = new NodeDistanceTable(KademliaOptions.BINS, KademliaOptions.BUCKET_SIZE, localNode); Assert.assertTrue(table != null); Assert.assertEquals(0, table.getClosestNodes(EMPTY_NODE_ID).size()); }
|
public synchronized List<Node> getClosestNodes(NodeID nodeId) { return getAllNodes().stream() .sorted(new NodeDistanceComparator(nodeId, this.distanceCalculator)) .collect(Collectors.toList()); }
|
NodeDistanceTable { public synchronized List<Node> getClosestNodes(NodeID nodeId) { return getAllNodes().stream() .sorted(new NodeDistanceComparator(nodeId, this.distanceCalculator)) .collect(Collectors.toList()); } }
|
NodeDistanceTable { public synchronized List<Node> getClosestNodes(NodeID nodeId) { return getAllNodes().stream() .sorted(new NodeDistanceComparator(nodeId, this.distanceCalculator)) .collect(Collectors.toList()); } NodeDistanceTable(int numberOfBuckets, int entriesPerBucket, Node localNode); }
|
NodeDistanceTable { public synchronized List<Node> getClosestNodes(NodeID nodeId) { return getAllNodes().stream() .sorted(new NodeDistanceComparator(nodeId, this.distanceCalculator)) .collect(Collectors.toList()); } NodeDistanceTable(int numberOfBuckets, int entriesPerBucket, Node localNode); synchronized OperationResult addNode(Node node); synchronized OperationResult removeNode(Node node); synchronized List<Node> getClosestNodes(NodeID nodeId); Set<Node> getAllNodes(); void updateEntry(Node node); }
|
NodeDistanceTable { public synchronized List<Node> getClosestNodes(NodeID nodeId) { return getAllNodes().stream() .sorted(new NodeDistanceComparator(nodeId, this.distanceCalculator)) .collect(Collectors.toList()); } NodeDistanceTable(int numberOfBuckets, int entriesPerBucket, Node localNode); synchronized OperationResult addNode(Node node); synchronized OperationResult removeNode(Node node); synchronized List<Node> getClosestNodes(NodeID nodeId); Set<Node> getAllNodes(); void updateEntry(Node node); }
|
@Test public void TestDynamicArrayTypeWithInvalidDataSize() { SolidityType.DynamicArrayType dat = new SolidityType.DynamicArrayType("string[]"); byte[] input = new byte[32]; input[31] = 0x10; try { dat.decode(input, 0); Assert.fail(); } catch (IllegalArgumentException e) { } input = new byte[98]; input[31] = 0x01; input[63] = 0x20; input[95] = 0x10; input[96] = 0x68; input[97] = 0x69; try { dat.decode(input, 0); Assert.fail(); } catch (IllegalArgumentException e) { } input = new byte[164]; input[31] = 0x02; input[63] = 0x20; input[95] = 0x02; input[96] = 0x68; input[97] = 0x69; input[129] = 0x20; input[161] = 0x10; input[162] = 0x68; input[163] = 0x69; try { dat.decode(input, 0); Assert.fail(); } catch (IllegalArgumentException e) { } }
|
public abstract Object decode(byte[] encoded, int offset);
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); }
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); SolidityType(String name); }
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); SolidityType(String name); String getName(); @JsonValue String getCanonicalName(); @JsonCreator static SolidityType getType(String typeName); abstract byte[] encode(Object value); abstract Object decode(byte[] encoded, int offset); Object decode(byte[] encoded); int getFixedSize(); boolean isDynamicType(); @Override String toString(); }
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); SolidityType(String name); String getName(); @JsonValue String getCanonicalName(); @JsonCreator static SolidityType getType(String typeName); abstract byte[] encode(Object value); abstract Object decode(byte[] encoded, int offset); Object decode(byte[] encoded); int getFixedSize(); boolean isDynamicType(); @Override String toString(); }
|
@Test public void addNode() { Node localNode = new Node(Hex.decode(NODE_ID_1), HOST, PORT_1); Node node2 = new Node(Hex.decode(NODE_ID_2), HOST, PORT_2); Node node3 = new Node(Hex.decode(NODE_ID_3), HOST, PORT_3); NodeDistanceTable table = new NodeDistanceTable(KademliaOptions.BINS, KademliaOptions.BUCKET_SIZE, localNode); OperationResult result = table.addNode(node3); Assert.assertTrue(result.isSuccess()); result = table.addNode(node2); Assert.assertTrue(result.isSuccess()); Assert.assertEquals(2, table.getClosestNodes(EMPTY_NODE_ID).size()); result = table.addNode(node2); Assert.assertTrue(result.isSuccess()); Assert.assertEquals(2, table.getClosestNodes(EMPTY_NODE_ID).size()); NodeDistanceTable smallerTable = new NodeDistanceTable(KademliaOptions.BINS, 1, localNode); result = smallerTable.addNode(node3); Assert.assertTrue(result.isSuccess()); Node sameDistanceNode = new Node(Hex.decode("00"), HOST, PORT_3); result = smallerTable.addNode(sameDistanceNode); Assert.assertFalse(result.isSuccess()); Assert.assertEquals(NODE_ID_3, result.getAffectedEntry().getNode().getHexId()); }
|
public synchronized OperationResult addNode(Node node) { return getNodeBucket(node).addNode(node); }
|
NodeDistanceTable { public synchronized OperationResult addNode(Node node) { return getNodeBucket(node).addNode(node); } }
|
NodeDistanceTable { public synchronized OperationResult addNode(Node node) { return getNodeBucket(node).addNode(node); } NodeDistanceTable(int numberOfBuckets, int entriesPerBucket, Node localNode); }
|
NodeDistanceTable { public synchronized OperationResult addNode(Node node) { return getNodeBucket(node).addNode(node); } NodeDistanceTable(int numberOfBuckets, int entriesPerBucket, Node localNode); synchronized OperationResult addNode(Node node); synchronized OperationResult removeNode(Node node); synchronized List<Node> getClosestNodes(NodeID nodeId); Set<Node> getAllNodes(); void updateEntry(Node node); }
|
NodeDistanceTable { public synchronized OperationResult addNode(Node node) { return getNodeBucket(node).addNode(node); } NodeDistanceTable(int numberOfBuckets, int entriesPerBucket, Node localNode); synchronized OperationResult addNode(Node node); synchronized OperationResult removeNode(Node node); synchronized List<Node> getClosestNodes(NodeID nodeId); Set<Node> getAllNodes(); void updateEntry(Node node); }
|
@Test public void distance() { DistanceCalculator calculator = new DistanceCalculator(256); Node node1 = new Node(Hex.decode(NODE_ID_1), "190.0.0.128", 8080); Node node2 = new Node(Hex.decode(NODE_ID_2), "192.0.0.127", 8080); Assert.assertEquals(0, calculator.calculateDistance(node1.getId(), node1.getId())); Assert.assertEquals(calculator.calculateDistance(node1.getId(), node2.getId()), calculator.calculateDistance(node2.getId(), node1.getId())); }
|
public int calculateDistance(NodeID node1, NodeID node2) { byte[] nodeId1 = HashUtil.keccak256(HashUtil.keccak256(node1.getID())); byte[] nodeId2 = HashUtil.keccak256(HashUtil.keccak256(node2.getID())); byte[] result = new byte[nodeId1.length]; for (int i = 0; i < result.length; i++) { result[i] = (byte) (((int) nodeId1[i]) ^ ((int) nodeId2[i])); } return msbPosition(result); }
|
DistanceCalculator { public int calculateDistance(NodeID node1, NodeID node2) { byte[] nodeId1 = HashUtil.keccak256(HashUtil.keccak256(node1.getID())); byte[] nodeId2 = HashUtil.keccak256(HashUtil.keccak256(node2.getID())); byte[] result = new byte[nodeId1.length]; for (int i = 0; i < result.length; i++) { result[i] = (byte) (((int) nodeId1[i]) ^ ((int) nodeId2[i])); } return msbPosition(result); } }
|
DistanceCalculator { public int calculateDistance(NodeID node1, NodeID node2) { byte[] nodeId1 = HashUtil.keccak256(HashUtil.keccak256(node1.getID())); byte[] nodeId2 = HashUtil.keccak256(HashUtil.keccak256(node2.getID())); byte[] result = new byte[nodeId1.length]; for (int i = 0; i < result.length; i++) { result[i] = (byte) (((int) nodeId1[i]) ^ ((int) nodeId2[i])); } return msbPosition(result); } DistanceCalculator(int maxDistance); }
|
DistanceCalculator { public int calculateDistance(NodeID node1, NodeID node2) { byte[] nodeId1 = HashUtil.keccak256(HashUtil.keccak256(node1.getID())); byte[] nodeId2 = HashUtil.keccak256(HashUtil.keccak256(node2.getID())); byte[] result = new byte[nodeId1.length]; for (int i = 0; i < result.length; i++) { result[i] = (byte) (((int) nodeId1[i]) ^ ((int) nodeId2[i])); } return msbPosition(result); } DistanceCalculator(int maxDistance); int calculateDistance(NodeID node1, NodeID node2); }
|
DistanceCalculator { public int calculateDistance(NodeID node1, NodeID node2) { byte[] nodeId1 = HashUtil.keccak256(HashUtil.keccak256(node1.getID())); byte[] nodeId2 = HashUtil.keccak256(HashUtil.keccak256(node2.getID())); byte[] result = new byte[nodeId1.length]; for (int i = 0; i < result.length; i++) { result[i] = (byte) (((int) nodeId1[i]) ^ ((int) nodeId2[i])); } return msbPosition(result); } DistanceCalculator(int maxDistance); int calculateDistance(NodeID node1, NodeID node2); }
|
@Test public void channelRead0() throws Exception { Channel channel = Mockito.mock(Channel.class); PeerExplorer peerExplorer = Mockito.mock(PeerExplorer.class); UDPChannel udpChannel = new UDPChannel(channel, peerExplorer); DiscoveryEvent event = Mockito.mock(DiscoveryEvent.class); udpChannel.channelRead0(Mockito.mock(ChannelHandlerContext.class), event); Mockito.verify(peerExplorer, Mockito.times(1)).handleMessage(event); }
|
@Override public void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event) throws Exception { this.peerExplorer.handleMessage(event); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event) throws Exception { this.peerExplorer.handleMessage(event); } }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event) throws Exception { this.peerExplorer.handleMessage(event); } UDPChannel(Channel ch, PeerExplorer peerExplorer); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event) throws Exception { this.peerExplorer.handleMessage(event); } UDPChannel(Channel ch, PeerExplorer peerExplorer); @Override void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event); void write(DiscoveryEvent discoveryEvent); @Override void channelReadComplete(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void channelActive(ChannelHandlerContext ctx); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event) throws Exception { this.peerExplorer.handleMessage(event); } UDPChannel(Channel ch, PeerExplorer peerExplorer); @Override void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event); void write(DiscoveryEvent discoveryEvent); @Override void channelReadComplete(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void channelActive(ChannelHandlerContext ctx); }
|
@Test public void write() { String check = UUID.randomUUID().toString(); ECKey key = new ECKey(); PingPeerMessage nodeMessage = PingPeerMessage.create("localhost", 80, check, key, NETWORK_ID); Channel channel = Mockito.mock(Channel.class); PeerExplorer peerExplorer = Mockito.mock(PeerExplorer.class); UDPChannel udpChannel = new UDPChannel(channel, peerExplorer); udpChannel.write(new DiscoveryEvent(nodeMessage, new InetSocketAddress("localhost", 8080))); Mockito.verify(channel, Mockito.times(1)).write(Mockito.any()); Mockito.verify(channel, Mockito.times(1)).flush(); }
|
public void write(DiscoveryEvent discoveryEvent) { InetSocketAddress address = discoveryEvent.getAddress(); sendPacket(discoveryEvent.getMessage().getPacket(), address); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { public void write(DiscoveryEvent discoveryEvent) { InetSocketAddress address = discoveryEvent.getAddress(); sendPacket(discoveryEvent.getMessage().getPacket(), address); } }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { public void write(DiscoveryEvent discoveryEvent) { InetSocketAddress address = discoveryEvent.getAddress(); sendPacket(discoveryEvent.getMessage().getPacket(), address); } UDPChannel(Channel ch, PeerExplorer peerExplorer); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { public void write(DiscoveryEvent discoveryEvent) { InetSocketAddress address = discoveryEvent.getAddress(); sendPacket(discoveryEvent.getMessage().getPacket(), address); } UDPChannel(Channel ch, PeerExplorer peerExplorer); @Override void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event); void write(DiscoveryEvent discoveryEvent); @Override void channelReadComplete(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void channelActive(ChannelHandlerContext ctx); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { public void write(DiscoveryEvent discoveryEvent) { InetSocketAddress address = discoveryEvent.getAddress(); sendPacket(discoveryEvent.getMessage().getPacket(), address); } UDPChannel(Channel ch, PeerExplorer peerExplorer); @Override void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event); void write(DiscoveryEvent discoveryEvent); @Override void channelReadComplete(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void channelActive(ChannelHandlerContext ctx); }
|
@Test public void channelActive() throws Exception { Channel channel = Mockito.mock(Channel.class); PeerExplorer peerExplorer = Mockito.mock(PeerExplorer.class); UDPChannel udpChannel = new UDPChannel(channel, peerExplorer); ChannelHandlerContext ctx = Mockito.mock(ChannelHandlerContext.class); udpChannel.channelActive(ctx); Mockito.verify(peerExplorer, Mockito.times(1)).start(); }
|
@Override public void channelActive(ChannelHandlerContext ctx) throws Exception { peerExplorer.start(); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { peerExplorer.start(); } }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { peerExplorer.start(); } UDPChannel(Channel ch, PeerExplorer peerExplorer); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { peerExplorer.start(); } UDPChannel(Channel ch, PeerExplorer peerExplorer); @Override void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event); void write(DiscoveryEvent discoveryEvent); @Override void channelReadComplete(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void channelActive(ChannelHandlerContext ctx); }
|
UDPChannel extends SimpleChannelInboundHandler<DiscoveryEvent> { @Override public void channelActive(ChannelHandlerContext ctx) throws Exception { peerExplorer.start(); } UDPChannel(Channel ch, PeerExplorer peerExplorer); @Override void channelRead0(ChannelHandlerContext ctx, DiscoveryEvent event); void write(DiscoveryEvent discoveryEvent); @Override void channelReadComplete(ChannelHandlerContext ctx); @Override void exceptionCaught(ChannelHandlerContext ctx, Throwable cause); @Override void channelActive(ChannelHandlerContext ctx); }
|
@Test public void startChallenge() { ECKey key1 = ECKey.fromPrivate(Hex.decode(KEY_1)).decompress(); ECKey key2 = ECKey.fromPrivate(Hex.decode(KEY_2)).decompress(); ECKey key3 = ECKey.fromPrivate(Hex.decode(KEY_3)).decompress(); Node node1 = new Node(key1.getNodeId(), HOST_1, PORT_1); Node node2 = new Node(key2.getNodeId(), HOST_2, PORT_2); Node node3 = new Node(key3.getNodeId(), HOST_3, PORT_3); NodeDistanceTable distanceTable = new NodeDistanceTable(KademliaOptions.BINS, KademliaOptions.BUCKET_SIZE, node1); PeerExplorer peerExplorer = new PeerExplorer(new ArrayList<>(), node1, distanceTable, new ECKey(), TIMEOUT, UPDATE, CLEAN, NETWORK_ID); peerExplorer.setUDPChannel(Mockito.mock(UDPChannel.class)); NodeChallengeManager manager = new NodeChallengeManager(); NodeChallenge challenge = manager.startChallenge(node2, node3, peerExplorer); Assert.assertNotNull(challenge); Assert.assertEquals(challenge.getChallengedNode(), node2); Assert.assertEquals(challenge.getChallenger(), node3); NodeChallenge anotherChallenge = manager.removeChallenge(UUID.randomUUID().toString()); Assert.assertNull(anotherChallenge); anotherChallenge = manager.removeChallenge(challenge.getChallengeId()); Assert.assertEquals(challenge, anotherChallenge); }
|
public NodeChallenge startChallenge(Node challengedNode, Node challenger, PeerExplorer explorer) { PingPeerMessage pingMessage = explorer.sendPing(challengedNode.getAddress(), 1, challengedNode); String messageId = pingMessage.getMessageId(); NodeChallenge challenge = new NodeChallenge(challengedNode, challenger, messageId); activeChallenges.put(messageId, challenge); return challenge; }
|
NodeChallengeManager { public NodeChallenge startChallenge(Node challengedNode, Node challenger, PeerExplorer explorer) { PingPeerMessage pingMessage = explorer.sendPing(challengedNode.getAddress(), 1, challengedNode); String messageId = pingMessage.getMessageId(); NodeChallenge challenge = new NodeChallenge(challengedNode, challenger, messageId); activeChallenges.put(messageId, challenge); return challenge; } }
|
NodeChallengeManager { public NodeChallenge startChallenge(Node challengedNode, Node challenger, PeerExplorer explorer) { PingPeerMessage pingMessage = explorer.sendPing(challengedNode.getAddress(), 1, challengedNode); String messageId = pingMessage.getMessageId(); NodeChallenge challenge = new NodeChallenge(challengedNode, challenger, messageId); activeChallenges.put(messageId, challenge); return challenge; } }
|
NodeChallengeManager { public NodeChallenge startChallenge(Node challengedNode, Node challenger, PeerExplorer explorer) { PingPeerMessage pingMessage = explorer.sendPing(challengedNode.getAddress(), 1, challengedNode); String messageId = pingMessage.getMessageId(); NodeChallenge challenge = new NodeChallenge(challengedNode, challenger, messageId); activeChallenges.put(messageId, challenge); return challenge; } NodeChallenge startChallenge(Node challengedNode, Node challenger, PeerExplorer explorer); NodeChallenge removeChallenge(String challengeId); @VisibleForTesting int activeChallengesCount(); }
|
NodeChallengeManager { public NodeChallenge startChallenge(Node challengedNode, Node challenger, PeerExplorer explorer) { PingPeerMessage pingMessage = explorer.sendPing(challengedNode.getAddress(), 1, challengedNode); String messageId = pingMessage.getMessageId(); NodeChallenge challenge = new NodeChallenge(challengedNode, challenger, messageId); activeChallenges.put(messageId, challenge); return challenge; } NodeChallenge startChallenge(Node challengedNode, Node challenger, PeerExplorer explorer); NodeChallenge removeChallenge(String challengeId); @VisibleForTesting int activeChallengesCount(); }
|
@Test public void port0DoesntCreateANewChannel() throws InterruptedException { UDPServer udpServer = new UDPServer(HOST, 0, null); Channel channel = Whitebox.getInternalState(udpServer, "channel"); udpServer.start(); TimeUnit.SECONDS.sleep(2); Assert.assertNull(channel); }
|
@Override public void start() { if (port == 0) { logger.error("Discovery can't be started while listen port == 0"); } else { new Thread("UDPServer") { @Override public void run() { try { UDPServer.this.startUDPServer(); } catch (Exception e) { logger.error("Discovery can't be started. ", e); throw new PeerDiscoveryException("Discovery can't be started. ", e); } } }.start(); } }
|
UDPServer implements InternalService { @Override public void start() { if (port == 0) { logger.error("Discovery can't be started while listen port == 0"); } else { new Thread("UDPServer") { @Override public void run() { try { UDPServer.this.startUDPServer(); } catch (Exception e) { logger.error("Discovery can't be started. ", e); throw new PeerDiscoveryException("Discovery can't be started. ", e); } } }.start(); } } }
|
UDPServer implements InternalService { @Override public void start() { if (port == 0) { logger.error("Discovery can't be started while listen port == 0"); } else { new Thread("UDPServer") { @Override public void run() { try { UDPServer.this.startUDPServer(); } catch (Exception e) { logger.error("Discovery can't be started. ", e); throw new PeerDiscoveryException("Discovery can't be started. ", e); } } }.start(); } } UDPServer(String address, int port, PeerExplorer peerExplorer); }
|
UDPServer implements InternalService { @Override public void start() { if (port == 0) { logger.error("Discovery can't be started while listen port == 0"); } else { new Thread("UDPServer") { @Override public void run() { try { UDPServer.this.startUDPServer(); } catch (Exception e) { logger.error("Discovery can't be started. ", e); throw new PeerDiscoveryException("Discovery can't be started. ", e); } } }.start(); } } UDPServer(String address, int port, PeerExplorer peerExplorer); @Override void start(); void startUDPServer(); @Override void stop(); }
|
UDPServer implements InternalService { @Override public void start() { if (port == 0) { logger.error("Discovery can't be started while listen port == 0"); } else { new Thread("UDPServer") { @Override public void run() { try { UDPServer.this.startUDPServer(); } catch (Exception e) { logger.error("Discovery can't be started. ", e); throw new PeerDiscoveryException("Discovery can't be started. ", e); } } }.start(); } } UDPServer(String address, int port, PeerExplorer peerExplorer); @Override void start(); void startUDPServer(); @Override void stop(); }
|
@Test public void handlePingMessage() throws Exception { List<String> nodes = new ArrayList<>(); ECKey key2 = ECKey.fromPrivate(Hex.decode(KEY_2)).decompress(); Node node = new Node(key2.getNodeId(), HOST_2, PORT_2); NodeDistanceTable distanceTable = new NodeDistanceTable(KademliaOptions.BINS, KademliaOptions.BUCKET_SIZE, node); PeerExplorer peerExplorer = new PeerExplorer(nodes, node, distanceTable, key2, TIMEOUT, UPDATE, CLEAN, NETWORK_ID1); Channel internalChannel = Mockito.mock(Channel.class); UDPTestChannel channel = new UDPTestChannel(internalChannel, peerExplorer); ChannelHandlerContext ctx = Mockito.mock(ChannelHandlerContext.class); peerExplorer.setUDPChannel(channel); Assert.assertTrue(peerExplorer.getNodes().isEmpty()); ECKey key1 = ECKey.fromPrivate(Hex.decode(KEY_1)).decompress(); String check = UUID.randomUUID().toString(); PingPeerMessage nodeMessage = PingPeerMessage.create(HOST_1, PORT_1, check, key1, this.NETWORK_ID1); DiscoveryEvent incomingPingEvent = new DiscoveryEvent(nodeMessage, new InetSocketAddress(HOST_2, PORT_3)); channel.channelRead0(ctx, incomingPingEvent); List<DiscoveryEvent> sentEvents = channel.getEventsWritten(); Assert.assertEquals(2, sentEvents.size()); DiscoveryEvent pongEvent = sentEvents.get(0); PongPeerMessage toSenderPong = (PongPeerMessage) pongEvent.getMessage(); Assert.assertEquals(DiscoveryMessageType.PONG, toSenderPong.getMessageType()); Assert.assertEquals(new InetSocketAddress(HOST_2, PORT_3), pongEvent.getAddress()); DiscoveryEvent pingEvent = sentEvents.get(1); PingPeerMessage toSenderPing = (PingPeerMessage) pingEvent.getMessage(); Assert.assertEquals(DiscoveryMessageType.PING, toSenderPing.getMessageType()); Assert.assertEquals(new InetSocketAddress(HOST_2, PORT_3), pingEvent.getAddress()); PongPeerMessage pongResponseFromSender = PongPeerMessage.create(HOST_1, PORT_1, toSenderPing.getMessageId(), key1, NETWORK_ID1); DiscoveryEvent incomingPongEvent = new DiscoveryEvent(pongResponseFromSender, new InetSocketAddress(HOST_2, PORT_3)); channel.channelRead0(ctx, incomingPongEvent); channel.clearEvents(); channel.channelRead0(ctx, incomingPingEvent); sentEvents = channel.getEventsWritten(); Assert.assertEquals(1, sentEvents.size()); pongEvent = sentEvents.get(0); toSenderPong = (PongPeerMessage) pongEvent.getMessage(); Assert.assertEquals(DiscoveryMessageType.PONG, toSenderPong.getMessageType()); Assert.assertEquals(new InetSocketAddress(HOST_2, PORT_3), pongEvent.getAddress()); Assert.assertEquals(NODE_ID_2, ByteUtil.toHexString(toSenderPong.getKey().getNodeId())); }
|
public void handlePingMessage(InetSocketAddress address, PingPeerMessage message) { this.sendPong(address, message); Node connectedNode = this.establishedConnections.get(message.getNodeId()); if (connectedNode == null) { this.sendPing(address, 1); } else { updateEntry(connectedNode); } }
|
PeerExplorer { public void handlePingMessage(InetSocketAddress address, PingPeerMessage message) { this.sendPong(address, message); Node connectedNode = this.establishedConnections.get(message.getNodeId()); if (connectedNode == null) { this.sendPing(address, 1); } else { updateEntry(connectedNode); } } }
|
PeerExplorer { public void handlePingMessage(InetSocketAddress address, PingPeerMessage message) { this.sendPong(address, message); Node connectedNode = this.establishedConnections.get(message.getNodeId()); if (connectedNode == null) { this.sendPing(address, 1); } else { updateEntry(connectedNode); } } PeerExplorer(List<String> initialBootNodes, Node localNode, NodeDistanceTable distanceTable, ECKey key, long reqTimeOut, long updatePeriod, long cleanPeriod, Integer networkId); }
|
PeerExplorer { public void handlePingMessage(InetSocketAddress address, PingPeerMessage message) { this.sendPong(address, message); Node connectedNode = this.establishedConnections.get(message.getNodeId()); if (connectedNode == null) { this.sendPing(address, 1); } else { updateEntry(connectedNode); } } PeerExplorer(List<String> initialBootNodes, Node localNode, NodeDistanceTable distanceTable, ECKey key, long reqTimeOut, long updatePeriod, long cleanPeriod, Integer networkId); void start(); Set<String> startConversationWithNewNodes(); void setUDPChannel(UDPChannel udpChannel); void handleMessage(DiscoveryEvent event); void handlePingMessage(InetSocketAddress address, PingPeerMessage message); void handlePong(InetSocketAddress pongAddress, PongPeerMessage message); void handleFindNode(FindNodePeerMessage message); void handleNeighborsMessage(InetSocketAddress neighborsResponseAddress, NeighborsPeerMessage message); List<Node> getNodes(); PingPeerMessage sendPing(InetSocketAddress nodeAddress, int attempt); PingPeerMessage sendPing(InetSocketAddress nodeAddress, int attempt, Node node); PongPeerMessage sendPong(InetSocketAddress nodeAddress, PingPeerMessage message); FindNodePeerMessage sendFindNode(Node node); NeighborsPeerMessage sendNeighbors(InetSocketAddress nodeAddress, List<Node> nodes, String id); void purgeRequests(); void clean(); void update(); @VisibleForTesting NodeChallengeManager getChallengeManager(); }
|
PeerExplorer { public void handlePingMessage(InetSocketAddress address, PingPeerMessage message) { this.sendPong(address, message); Node connectedNode = this.establishedConnections.get(message.getNodeId()); if (connectedNode == null) { this.sendPing(address, 1); } else { updateEntry(connectedNode); } } PeerExplorer(List<String> initialBootNodes, Node localNode, NodeDistanceTable distanceTable, ECKey key, long reqTimeOut, long updatePeriod, long cleanPeriod, Integer networkId); void start(); Set<String> startConversationWithNewNodes(); void setUDPChannel(UDPChannel udpChannel); void handleMessage(DiscoveryEvent event); void handlePingMessage(InetSocketAddress address, PingPeerMessage message); void handlePong(InetSocketAddress pongAddress, PongPeerMessage message); void handleFindNode(FindNodePeerMessage message); void handleNeighborsMessage(InetSocketAddress neighborsResponseAddress, NeighborsPeerMessage message); List<Node> getNodes(); PingPeerMessage sendPing(InetSocketAddress nodeAddress, int attempt); PingPeerMessage sendPing(InetSocketAddress nodeAddress, int attempt, Node node); PongPeerMessage sendPong(InetSocketAddress nodeAddress, PingPeerMessage message); FindNodePeerMessage sendFindNode(Node node); NeighborsPeerMessage sendNeighbors(InetSocketAddress nodeAddress, List<Node> nodes, String id); void purgeRequests(); void clean(); void update(); @VisibleForTesting NodeChallengeManager getChallengeManager(); }
|
@Test public void create() { ECKey key = new ECKey(); String check = UUID.randomUUID().toString(); PingPeerMessage pingPeerMessage = PingPeerMessage.create("localhost", 80, check, key, NETWORK_ID); PongPeerMessage pongPeerMessage = PongPeerMessage.create("localhost", 80, check, key, NETWORK_ID); InetSocketAddress address = new InetSocketAddress("localhost", 8080); PeerDiscoveryRequest request = PeerDiscoveryRequestBuilder.builder().messageId(check) .message(pingPeerMessage).address(address).expectedResponse(DiscoveryMessageType.PONG) .expirationPeriod(1000).attemptNumber(1).build(); Assert.assertNotNull(request); Assert.assertTrue(request.validateMessageResponse(address, pongPeerMessage)); Assert.assertFalse(request.validateMessageResponse(address, pingPeerMessage)); }
|
public boolean validateMessageResponse(InetSocketAddress responseAddress, PeerDiscoveryMessage message) { return this.expectedResponse == message.getMessageType() && !this.hasExpired() && getAddress().equals(responseAddress); }
|
PeerDiscoveryRequest { public boolean validateMessageResponse(InetSocketAddress responseAddress, PeerDiscoveryMessage message) { return this.expectedResponse == message.getMessageType() && !this.hasExpired() && getAddress().equals(responseAddress); } }
|
PeerDiscoveryRequest { public boolean validateMessageResponse(InetSocketAddress responseAddress, PeerDiscoveryMessage message) { return this.expectedResponse == message.getMessageType() && !this.hasExpired() && getAddress().equals(responseAddress); } PeerDiscoveryRequest(String messageId, PeerDiscoveryMessage message, InetSocketAddress address, DiscoveryMessageType expectedResponse, Long expirationPeriod, int attemptNumber, Node relatedNode); }
|
PeerDiscoveryRequest { public boolean validateMessageResponse(InetSocketAddress responseAddress, PeerDiscoveryMessage message) { return this.expectedResponse == message.getMessageType() && !this.hasExpired() && getAddress().equals(responseAddress); } PeerDiscoveryRequest(String messageId, PeerDiscoveryMessage message, InetSocketAddress address, DiscoveryMessageType expectedResponse, Long expirationPeriod, int attemptNumber, Node relatedNode); String getMessageId(); PeerDiscoveryMessage getMessage(); InetSocketAddress getAddress(); int getAttemptNumber(); Node getRelatedNode(); boolean validateMessageResponse(InetSocketAddress responseAddress, PeerDiscoveryMessage message); boolean hasExpired(); }
|
PeerDiscoveryRequest { public boolean validateMessageResponse(InetSocketAddress responseAddress, PeerDiscoveryMessage message) { return this.expectedResponse == message.getMessageType() && !this.hasExpired() && getAddress().equals(responseAddress); } PeerDiscoveryRequest(String messageId, PeerDiscoveryMessage message, InetSocketAddress address, DiscoveryMessageType expectedResponse, Long expirationPeriod, int attemptNumber, Node relatedNode); String getMessageId(); PeerDiscoveryMessage getMessage(); InetSocketAddress getAddress(); int getAttemptNumber(); Node getRelatedNode(); boolean validateMessageResponse(InetSocketAddress responseAddress, PeerDiscoveryMessage message); boolean hasExpired(); }
|
@Test public void accept() { StatusMessage message = new StatusMessage(mock(Status.class)); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
StatusMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
StatusMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } StatusMessage(Status status); }
|
StatusMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } StatusMessage(Status status); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); Status getStatus(); @Override void accept(MessageVisitor v); }
|
StatusMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } StatusMessage(Status status); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); Status getStatus(); @Override void accept(MessageVisitor v); }
|
@Test public void TestStaticArrayTypeWithInvalidSize() { try { SolidityType.StaticArrayType dat = new SolidityType.StaticArrayType("string[2]"); byte[] input = new byte[34]; input[31] = 0x02; input[32] = 0x68; input[33] = 0x69; dat.decode(input, 0); Assert.fail("should have failed"); } catch (IllegalArgumentException e) { } try { SolidityType.StaticArrayType dat = new SolidityType.StaticArrayType("string[1]"); byte[] input = new byte[34]; input[31] = 0x03; input[32] = 0x68; input[33] = 0x69; dat.decode(input, 0); Assert.fail("should have failed"); } catch (IllegalArgumentException e) { } }
|
public abstract Object decode(byte[] encoded, int offset);
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); }
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); SolidityType(String name); }
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); SolidityType(String name); String getName(); @JsonValue String getCanonicalName(); @JsonCreator static SolidityType getType(String typeName); abstract byte[] encode(Object value); abstract Object decode(byte[] encoded, int offset); Object decode(byte[] encoded); int getFixedSize(); boolean isDynamicType(); @Override String toString(); }
|
SolidityType { public abstract Object decode(byte[] encoded, int offset); SolidityType(String name); String getName(); @JsonValue String getCanonicalName(); @JsonCreator static SolidityType getType(String typeName); abstract byte[] encode(Object value); abstract Object decode(byte[] encoded, int offset); Object decode(byte[] encoded); int getFixedSize(); boolean isDynamicType(); @Override String toString(); }
|
@Test public void accept() { Block block = new BlockGenerator().getBlock(1); BlockResponseMessage message = new BlockResponseMessage(100, block); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BlockResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BlockResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockResponseMessage(long id, Block block); }
|
BlockResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockResponseMessage(long id, Block block); long getId(); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessageWithoutId(); @Override void accept(MessageVisitor v); }
|
BlockResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockResponseMessage(long id, Block block); long getId(); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessageWithoutId(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { byte[] hash = new BlockGenerator().getGenesisBlock().getHash().getBytes(); BlockRequestMessage message = new BlockRequestMessage(100, hash); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BlockRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BlockRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockRequestMessage(long id, byte[] hash); }
|
BlockRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockRequestMessage(long id, byte[] hash); long getId(); byte[] getBlockHash(); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); @Override void accept(MessageVisitor v); }
|
BlockRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockRequestMessage(long id, byte[] hash); long getId(); byte[] getBlockHash(); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { byte[] hash = new byte[]{0x0F}; BodyRequestMessage message = new BodyRequestMessage(100, hash); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BodyRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BodyRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BodyRequestMessage(long id, byte[] hash); }
|
BodyRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BodyRequestMessage(long id, byte[] hash); long getId(); byte[] getBlockHash(); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); @Override void accept(MessageVisitor v); }
|
BodyRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BodyRequestMessage(long id, byte[] hash); long getId(); byte[] getBlockHash(); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { long someId = 42; long someHeight = 99; BlockHashRequestMessage message = new BlockHashRequestMessage(someId, someHeight); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BlockHashRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BlockHashRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHashRequestMessage(long id, long height); }
|
BlockHashRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHashRequestMessage(long id, long height); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); long getHeight(); @Override void accept(MessageVisitor v); }
|
BlockHashRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHashRequestMessage(long id, long height); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); long getHeight(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { BlockHeader blockHeader = mock(BlockHeader.class); List<BlockHeader> headers = new LinkedList<>(); headers.add(blockHeader); BlockHeadersResponseMessage message = new BlockHeadersResponseMessage(1, headers); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BlockHeadersResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BlockHeadersResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHeadersResponseMessage(long id, List<BlockHeader> headers); }
|
BlockHeadersResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHeadersResponseMessage(long id, List<BlockHeader> headers); @Override long getId(); List<BlockHeader> getBlockHeaders(); @Override MessageType getMessageType(); @Override void accept(MessageVisitor v); }
|
BlockHeadersResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHeadersResponseMessage(long id, List<BlockHeader> headers); @Override long getId(); List<BlockHeader> getBlockHeaders(); @Override MessageType getMessageType(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { byte[] hash = HashUtil.randomHash(); BlockHeadersRequestMessage message = new BlockHeadersRequestMessage(1, hash, 100); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BlockHeadersRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BlockHeadersRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHeadersRequestMessage(long id, byte[] hash, int count); }
|
BlockHeadersRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHeadersRequestMessage(long id, byte[] hash, int count); long getId(); byte[] getHash(); int getCount(); @Override byte[] getEncodedMessageWithoutId(); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override void accept(MessageVisitor v); }
|
BlockHeadersRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHeadersRequestMessage(long id, byte[] hash, int count); long getId(); byte[] getHash(); int getCount(); @Override byte[] getEncodedMessageWithoutId(); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override void accept(MessageVisitor v); }
|
@Test public void blockMessage_genesisBlock() { BlockMessage message = mock(BlockMessage.class); Block block = mock(Block.class); when(message.getBlock()).thenReturn(block); when(block.isGenesis()).thenReturn(true); target.apply(message); verify(blockProcessor, never()).processBlock(any(), any()); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockMessage_advancedBlockNumber() { BlockMessage message = mock(BlockMessage.class); Block block = mock(Block.class); when(message.getBlock()).thenReturn(block); when(block.getNumber()).thenReturn(24L); when(blockProcessor.isAdvancedBlock(anyLong())).thenReturn(true); target.apply(message); verify(blockProcessor, never()).processBlock(any(), any()); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockMessage_ignoredForUnclesReward() { BlockMessage message = mock(BlockMessage.class); Block block = mock(Block.class); when(message.getBlock()).thenReturn(block); when(block.getNumber()).thenReturn(24L); when(blockProcessor.canBeIgnoredForUnclesRewards(anyLong())).thenReturn(true); target.apply(message); verify(blockProcessor, never()).processBlock(any(), any()); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockMessage_hasBlockInSomeBlockchain() { BlockMessage message = mock(BlockMessage.class); Block block = mock(Block.class); Keccak256 blockHash = mock(Keccak256.class); byte[] hashBytes = new byte[]{0x0F}; when(message.getBlock()).thenReturn(block); when(block.getNumber()).thenReturn(24L); when(block.getHash()).thenReturn(blockHash); when(blockHash.getBytes()).thenReturn(hashBytes); when(blockProcessor.hasBlockInSomeBlockchain(eq(hashBytes))).thenReturn(true); target.apply(message); verify(blockProcessor, never()).processBlock(any(), any()); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void test1(){ BigInteger privKey = new BigInteger("5e173f6ac3c669587538e7727cf19b782a4f2fda07c1eaa662c593e5e85e3051", 16); byte[] cipher = Hex.decode("049934a7b2d7f9af8fd9db941d9da281ac9381b5740e1f64f7092f3588d4f87f5ce55191a6653e5e80c1c5dd538169aa123e70dc6ffc5af1827e546c0e958e42dad355bcc1fcb9cdf2cf47ff524d2ad98cbf275e661bf4cf00960e74b5956b799771334f426df007350b46049adb21a6e78ab1408d5e6ccde6fb5e69f0f4c92bb9c725c02f99fa72b9cdc8dd53cff089e0e73317f61cc5abf6152513cb7d833f09d2851603919bf0fbe44d79a09245c6e8338eb502083dc84b846f2fee1cc310d2cc8b1b9334728f97220bb799376233e113"); byte[] payload = new byte[0]; try { payload = ECIESCoder.decrypt(privKey, cipher); } catch (Throwable e) {e.printStackTrace();} Assert.assertEquals("802b052f8b066640bba94a4fc39d63815c377fced6fcb84d27f791c9921ddf3e9bf0108e298f490812847109cbd778fae393e80323fd643209841a3b7f110397f37ec61d84cea03dcc5e8385db93248584e8af4b4d1c832d8c7453c0089687a700", ByteUtil.toHexString(payload)); }
|
public static byte[] decrypt(BigInteger privKey, byte[] cipher) throws IOException, InvalidCipherTextException { return decrypt(privKey, cipher, null); }
|
ECIESCoder { public static byte[] decrypt(BigInteger privKey, byte[] cipher) throws IOException, InvalidCipherTextException { return decrypt(privKey, cipher, null); } }
|
ECIESCoder { public static byte[] decrypt(BigInteger privKey, byte[] cipher) throws IOException, InvalidCipherTextException { return decrypt(privKey, cipher, null); } }
|
ECIESCoder { public static byte[] decrypt(BigInteger privKey, byte[] cipher) throws IOException, InvalidCipherTextException { return decrypt(privKey, cipher, null); } static byte[] decrypt(BigInteger privKey, byte[] cipher); static byte[] decrypt(BigInteger privKey, byte[] cipher, byte[] macData); static byte[] decrypt(ECPoint ephem, BigInteger prv, byte[] iv, byte[] cipher, byte[] macData); static byte[] decryptSimple(BigInteger privKey, byte[] cipher); static byte[] encrypt(ECPoint toPub, byte[] plaintext); static byte[] encrypt(ECPoint toPub, byte[] plaintext, byte[] macData); static int getOverhead(); }
|
ECIESCoder { public static byte[] decrypt(BigInteger privKey, byte[] cipher) throws IOException, InvalidCipherTextException { return decrypt(privKey, cipher, null); } static byte[] decrypt(BigInteger privKey, byte[] cipher); static byte[] decrypt(BigInteger privKey, byte[] cipher, byte[] macData); static byte[] decrypt(ECPoint ephem, BigInteger prv, byte[] iv, byte[] cipher, byte[] macData); static byte[] decryptSimple(BigInteger privKey, byte[] cipher); static byte[] encrypt(ECPoint toPub, byte[] plaintext); static byte[] encrypt(ECPoint toPub, byte[] plaintext, byte[] macData); static int getOverhead(); static final int KEY_SIZE; }
|
@Test public void statusMessage() { StatusMessage message = mock(StatusMessage.class); Status status = mock(Status.class); when(message.getStatus()).thenReturn(status); target.apply(message); verify(syncProcessor, times(1)).processStatus(eq(sender),eq(status)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void getBlockMessage() { GetBlockMessage message = mock(GetBlockMessage.class); byte[] blockHash = new byte[]{0x0F}; when(message.getBlockHash()).thenReturn(blockHash); target.apply(message); verify(blockProcessor, times(1)).processGetBlock(eq(sender), eq(blockHash)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockRequestMessage() { BlockRequestMessage message = mock(BlockRequestMessage.class); byte[] blockHash = new byte[]{0x0F}; when(message.getBlockHash()).thenReturn(blockHash); when(message.getId()).thenReturn(24L); target.apply(message); verify(blockProcessor, times(1)) .processBlockRequest(eq(sender), eq(24L), eq(blockHash)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockResponseMessage() { BlockResponseMessage message = mock(BlockResponseMessage.class); target.apply(message); verify(syncProcessor, times(1)) .processBlockResponse(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void skeletonRequestMessage() { SkeletonRequestMessage message = mock(SkeletonRequestMessage.class); when(message.getStartNumber()).thenReturn(24L); when(message.getId()).thenReturn(1L); target.apply(message); verify(blockProcessor, times(1)) .processSkeletonRequest(eq(sender), eq(1L), eq(24L)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockHeadersRequestMessage() { BlockHeadersRequestMessage message = mock(BlockHeadersRequestMessage.class); byte[] hash = new byte[]{0x0F}; when(message.getHash()).thenReturn(hash); when(message.getId()).thenReturn(1L); when(message.getCount()).thenReturn(10); target.apply(message); verify(blockProcessor, times(1)) .processBlockHeadersRequest(eq(sender), eq(1L), eq(hash), eq(10)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockHashRequestMessage() { BlockHashRequestMessage message = mock(BlockHashRequestMessage.class); when(message.getId()).thenReturn(1L); when(message.getHeight()).thenReturn(10L); target.apply(message); verify(blockProcessor, times(1)) .processBlockHashRequest(eq(sender), eq(1L), eq(10L)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void blockHashResponseMessage() { BlockHashResponseMessage message = mock(BlockHashResponseMessage.class); target.apply(message); verify(syncProcessor, times(1)) .processBlockHashResponse(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void newBlockHashMessage() { NewBlockHashMessage message = mock(NewBlockHashMessage.class); target.apply(message); verify(syncProcessor, times(1)).processNewBlockHash(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void skeletonResponseMessage() { SkeletonResponseMessage message = mock(SkeletonResponseMessage.class); target.apply(message); verify(syncProcessor, times(1)) .processSkeletonResponse(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void testValidateComponents() { assertTrue(new ECDSASignature(BigInteger.ONE, BigInteger.ONE, (byte) 27).validateComponents()); assertTrue(new ECDSASignature(BigInteger.ONE, BigInteger.ONE, (byte) 28).validateComponents()); assertTrue(new ECDSASignature(SECP256K1N.subtract(BigInteger.ONE), BigInteger.ONE, (byte) 28).validateComponents()); assertTrue(new ECDSASignature(BigInteger.ONE, SECP256K1N.subtract(BigInteger.ONE), (byte) 28).validateComponents()); assertFalse(new ECDSASignature(BigInteger.ZERO, BigInteger.ONE, (byte) 27).validateComponents()); assertFalse(new ECDSASignature(SECP256K1N, BigInteger.ONE, (byte) 27).validateComponents()); assertFalse(new ECDSASignature(BigInteger.ONE, BigInteger.ZERO, (byte) 27).validateComponents()); assertFalse(new ECDSASignature(BigInteger.ONE, SECP256K1N, (byte) 27).validateComponents()); assertFalse(new ECDSASignature(BigInteger.ONE, BigInteger.ONE, (byte) 29).validateComponents()); assertFalse(new ECDSASignature(BigInteger.ONE, BigInteger.ONE, (byte) 26).validateComponents()); }
|
public boolean validateComponents() { return validateComponents(r, s, v); }
|
ECDSASignature { public boolean validateComponents() { return validateComponents(r, s, v); } }
|
ECDSASignature { public boolean validateComponents() { return validateComponents(r, s, v); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); }
|
ECDSASignature { public boolean validateComponents() { return validateComponents(r, s, v); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub); static ECDSASignature fromSignature(ECKey.ECDSASignature sign); BigInteger getR(); BigInteger getS(); byte getV(); void setV(byte v); static ECDSASignature fromComponents(byte[] r, byte[] s); static ECDSASignature fromComponents(byte[] r, byte[] s, byte v); boolean validateComponents(); static boolean validateComponents(BigInteger r, BigInteger s, byte v); ECDSASignature toCanonicalised(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECDSASignature { public boolean validateComponents() { return validateComponents(r, s, v); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub); static ECDSASignature fromSignature(ECKey.ECDSASignature sign); BigInteger getR(); BigInteger getS(); byte getV(); void setV(byte v); static ECDSASignature fromComponents(byte[] r, byte[] s); static ECDSASignature fromComponents(byte[] r, byte[] s, byte v); boolean validateComponents(); static boolean validateComponents(BigInteger r, BigInteger s, byte v); ECDSASignature toCanonicalised(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void blockHeadersResponseMessage() { BlockHeadersResponseMessage message = mock(BlockHeadersResponseMessage.class); target.apply(message); verify(syncProcessor, times(1)) .processBlockHeadersResponse(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void bodyRequestMessage() { BodyRequestMessage message = mock(BodyRequestMessage.class); byte[] blockHash = new byte[]{0x0F}; when(message.getId()).thenReturn(1L); when(message.getBlockHash()).thenReturn(blockHash); target.apply(message); verify(blockProcessor, times(1)) .processBodyRequest(eq(sender), eq(1L), eq(blockHash)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void bodyResponseMessage() { BodyResponseMessage message = mock(BodyResponseMessage.class); target.apply(message); verify(syncProcessor, times(1)) .processBodyResponse(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void newBlockHashesMessage() { NewBlockHashesMessage message = mock(NewBlockHashesMessage.class); target.apply(message); verify(blockProcessor, times(1)) .processNewBlockHashesMessage(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void newBlockHashesMessage_betterBlockToSync() { NewBlockHashesMessage message = mock(NewBlockHashesMessage.class); when(blockProcessor.hasBetterBlockToSync()).thenReturn(true); target.apply(message); verify(blockProcessor, never()) .processNewBlockHashesMessage(eq(sender), eq(message)); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void transactionsMessage_betterBlockToSync() { TransactionsMessage message = mock(TransactionsMessage.class); when(blockProcessor.hasBetterBlockToSync()).thenReturn(true); target.apply(message); verify(transactionGateway, never()).receiveTransactionsFrom(any(), any()); }
|
public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
MessageVisitor { public void apply(BlockMessage message) { final Block block = message.getBlock(); logger.trace("Process block {} {}", block.getNumber(), block.getPrintableHash()); if (block.isGenesis()) { logger.trace("Skip block processing {} {}", block.getNumber(), block.getPrintableHash()); return; } long blockNumber = block.getNumber(); if (this.blockProcessor.isAdvancedBlock(blockNumber)) { logger.trace("Too advanced block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.canBeIgnoredForUnclesRewards(block.getNumber())){ logger.trace("Block ignored: too far from best block {} {}", blockNumber, block.getPrintableHash()); return; } if (blockProcessor.hasBlockInSomeBlockchain(block.getHash().getBytes())){ logger.trace("Block ignored: it's included in blockchain {} {}", blockNumber, block.getPrintableHash()); return; } BlockProcessResult result = this.blockProcessor.processBlock(sender, block); if (result.isInvalidBlock()) { logger.trace("Invalid block {} {}", blockNumber, block.getPrintableHash()); recordEvent(sender, EventType.INVALID_BLOCK); return; } tryRelayBlock(block, result); if (result.isBest()) { sender.imported(true); } else { sender.imported(false); } recordEvent(sender, EventType.VALID_BLOCK); } MessageVisitor(RskSystemProperties config,
BlockProcessor blockProcessor,
SyncProcessor syncProcessor,
TransactionGateway transactionGateway,
PeerScoringManager peerScoringManager,
ChannelManager channelManager,
Peer sender); void apply(BlockMessage message); void apply(StatusMessage message); void apply(GetBlockMessage message); void apply(BlockRequestMessage message); void apply(BlockResponseMessage message); void apply(SkeletonRequestMessage message); void apply(BlockHeadersRequestMessage message); void apply(BlockHashRequestMessage message); void apply(BlockHashResponseMessage message); void apply(NewBlockHashMessage message); void apply(SkeletonResponseMessage message); void apply(BlockHeadersResponseMessage message); void apply(BodyRequestMessage message); void apply(BodyResponseMessage message); void apply(NewBlockHashesMessage message); void apply(TransactionsMessage message); }
|
@Test public void accept() { List<BlockIdentifier> blockIdentifiers = new LinkedList<>(); SkeletonResponseMessage message = new SkeletonResponseMessage(1, blockIdentifiers); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
SkeletonResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
SkeletonResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } SkeletonResponseMessage(long id, List<BlockIdentifier> blockIdentifiers); }
|
SkeletonResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } SkeletonResponseMessage(long id, List<BlockIdentifier> blockIdentifiers); @Override MessageType getMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); List<BlockIdentifier> getBlockIdentifiers(); @Override void accept(MessageVisitor v); }
|
SkeletonResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } SkeletonResponseMessage(long id, List<BlockIdentifier> blockIdentifiers); @Override MessageType getMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); List<BlockIdentifier> getBlockIdentifiers(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { List<Transaction> transactions = new LinkedList<>(); List<BlockHeader> uncles = new LinkedList<>(); BodyResponseMessage message = new BodyResponseMessage(100, transactions, uncles); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BodyResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BodyResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BodyResponseMessage(long id, List<Transaction> transactions, List<BlockHeader> uncles); }
|
BodyResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BodyResponseMessage(long id, List<Transaction> transactions, List<BlockHeader> uncles); @Override long getId(); List<Transaction> getTransactions(); List<BlockHeader> getUncles(); @Override MessageType getMessageType(); @Override void accept(MessageVisitor v); }
|
BodyResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BodyResponseMessage(long id, List<Transaction> transactions, List<BlockHeader> uncles); @Override long getId(); List<Transaction> getTransactions(); List<BlockHeader> getUncles(); @Override MessageType getMessageType(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { SkeletonRequestMessage message = new SkeletonRequestMessage(1, 10); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
SkeletonRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
SkeletonRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } SkeletonRequestMessage(long id, long startNumber); }
|
SkeletonRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } SkeletonRequestMessage(long id, long startNumber); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); long getStartNumber(); @Override void accept(MessageVisitor v); }
|
SkeletonRequestMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } SkeletonRequestMessage(long id, long startNumber); @Override MessageType getMessageType(); @Override MessageType getResponseMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); long getStartNumber(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { long someId = 42; byte[] hash = new byte[32]; Random random = new Random(); random.nextBytes(hash); BlockHashResponseMessage message = new BlockHashResponseMessage(someId, hash); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BlockHashResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BlockHashResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHashResponseMessage(long id, byte[] hash); }
|
BlockHashResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHashResponseMessage(long id, byte[] hash); @Override MessageType getMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); byte[] getHash(); @Override void accept(MessageVisitor v); }
|
BlockHashResponseMessage extends MessageWithId { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockHashResponseMessage(long id, byte[] hash); @Override MessageType getMessageType(); @Override byte[] getEncodedMessageWithoutId(); long getId(); byte[] getHash(); @Override void accept(MessageVisitor v); }
|
@Test public void testEquals() { ECDSASignature expected = new ECDSASignature(BigInteger.ONE, BigInteger.ONE, (byte) 27); assertEquals(expected, expected); assertEquals(expected, new ECDSASignature(expected.getR(), expected.getS(), expected.getV())); assertEquals(expected, new ECDSASignature(expected.getR(), expected.getS(), (byte) 0)); assertNotEquals(expected, null); assertNotEquals(expected, BigInteger.ZERO); assertNotEquals(new ECDSASignature(BigInteger.ONE, BigInteger.ONE, (byte) 27), new ECDSASignature(BigInteger.TEN, BigInteger.ONE, (byte) 27)); assertNotEquals(new ECDSASignature(BigInteger.ONE, BigInteger.ONE, (byte) 27), new ECDSASignature(BigInteger.ONE, BigInteger.TEN, (byte) 27)); }
|
@Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } ECDSASignature signature = (ECDSASignature) o; if (!r.equals(signature.r)) { return false; } return s.equals(signature.s); }
|
ECDSASignature { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } ECDSASignature signature = (ECDSASignature) o; if (!r.equals(signature.r)) { return false; } return s.equals(signature.s); } }
|
ECDSASignature { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } ECDSASignature signature = (ECDSASignature) o; if (!r.equals(signature.r)) { return false; } return s.equals(signature.s); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); }
|
ECDSASignature { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } ECDSASignature signature = (ECDSASignature) o; if (!r.equals(signature.r)) { return false; } return s.equals(signature.s); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub); static ECDSASignature fromSignature(ECKey.ECDSASignature sign); BigInteger getR(); BigInteger getS(); byte getV(); void setV(byte v); static ECDSASignature fromComponents(byte[] r, byte[] s); static ECDSASignature fromComponents(byte[] r, byte[] s, byte v); boolean validateComponents(); static boolean validateComponents(BigInteger r, BigInteger s, byte v); ECDSASignature toCanonicalised(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECDSASignature { @Override public boolean equals(Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } ECDSASignature signature = (ECDSASignature) o; if (!r.equals(signature.r)) { return false; } return s.equals(signature.s); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub); static ECDSASignature fromSignature(ECKey.ECDSASignature sign); BigInteger getR(); BigInteger getS(); byte getV(); void setV(byte v); static ECDSASignature fromComponents(byte[] r, byte[] s); static ECDSASignature fromComponents(byte[] r, byte[] s, byte v); boolean validateComponents(); static boolean validateComponents(BigInteger r, BigInteger s, byte v); ECDSASignature toCanonicalised(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void getMessageType() { TransactionsMessage message = new TransactionsMessage(null); Assert.assertEquals(MessageType.TRANSACTIONS, message.getMessageType()); }
|
@Override public MessageType getMessageType() { return MessageType.TRANSACTIONS; }
|
TransactionsMessage extends Message { @Override public MessageType getMessageType() { return MessageType.TRANSACTIONS; } }
|
TransactionsMessage extends Message { @Override public MessageType getMessageType() { return MessageType.TRANSACTIONS; } TransactionsMessage(List<Transaction> transactions); }
|
TransactionsMessage extends Message { @Override public MessageType getMessageType() { return MessageType.TRANSACTIONS; } TransactionsMessage(List<Transaction> transactions); List<Transaction> getTransactions(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); String getMessageContentInfo(); @Override void accept(MessageVisitor v); }
|
TransactionsMessage extends Message { @Override public MessageType getMessageType() { return MessageType.TRANSACTIONS; } TransactionsMessage(List<Transaction> transactions); List<Transaction> getTransactions(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); String getMessageContentInfo(); @Override void accept(MessageVisitor v); }
|
@Test public void setAndGetTransactions() { List<Transaction> txs = TransactionUtils.getTransactions(10); TransactionsMessage message = new TransactionsMessage(txs); Assert.assertNotNull(message.getTransactions()); Assert.assertEquals(10, message.getTransactions().size()); Assert.assertSame(txs, message.getTransactions()); }
|
public List<Transaction> getTransactions() { return this.transactions; }
|
TransactionsMessage extends Message { public List<Transaction> getTransactions() { return this.transactions; } }
|
TransactionsMessage extends Message { public List<Transaction> getTransactions() { return this.transactions; } TransactionsMessage(List<Transaction> transactions); }
|
TransactionsMessage extends Message { public List<Transaction> getTransactions() { return this.transactions; } TransactionsMessage(List<Transaction> transactions); List<Transaction> getTransactions(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); String getMessageContentInfo(); @Override void accept(MessageVisitor v); }
|
TransactionsMessage extends Message { public List<Transaction> getTransactions() { return this.transactions; } TransactionsMessage(List<Transaction> transactions); List<Transaction> getTransactions(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); String getMessageContentInfo(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { List<Transaction> txs = new LinkedList<>(); TransactionsMessage message = new TransactionsMessage(txs); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
TransactionsMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
TransactionsMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } TransactionsMessage(List<Transaction> transactions); }
|
TransactionsMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } TransactionsMessage(List<Transaction> transactions); List<Transaction> getTransactions(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); String getMessageContentInfo(); @Override void accept(MessageVisitor v); }
|
TransactionsMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } TransactionsMessage(List<Transaction> transactions); List<Transaction> getTransactions(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); String getMessageContentInfo(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { byte[] hash = new byte[]{0x0F}; GetBlockMessage message = new GetBlockMessage(hash); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
GetBlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
GetBlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } GetBlockMessage(byte[] hash); }
|
GetBlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } GetBlockMessage(byte[] hash); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); byte[] getBlockHash(); @Override void accept(MessageVisitor v); }
|
GetBlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } GetBlockMessage(byte[] hash); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); byte[] getBlockHash(); @Override void accept(MessageVisitor v); }
|
@Test public void getMessageType() { BlockMessage message = new BlockMessage(null); Assert.assertEquals(MessageType.BLOCK_MESSAGE, message.getMessageType()); }
|
@Override public MessageType getMessageType() { return MessageType.BLOCK_MESSAGE; }
|
BlockMessage extends Message { @Override public MessageType getMessageType() { return MessageType.BLOCK_MESSAGE; } }
|
BlockMessage extends Message { @Override public MessageType getMessageType() { return MessageType.BLOCK_MESSAGE; } BlockMessage(Block block); }
|
BlockMessage extends Message { @Override public MessageType getMessageType() { return MessageType.BLOCK_MESSAGE; } BlockMessage(Block block); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); @Override void accept(MessageVisitor v); }
|
BlockMessage extends Message { @Override public MessageType getMessageType() { return MessageType.BLOCK_MESSAGE; } BlockMessage(Block block); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); @Override void accept(MessageVisitor v); }
|
@Test public void getBlock() { Block block = mock(Block.class); BlockMessage message = new BlockMessage(block); Assert.assertSame(block, message.getBlock()); }
|
public Block getBlock() { return this.block; }
|
BlockMessage extends Message { public Block getBlock() { return this.block; } }
|
BlockMessage extends Message { public Block getBlock() { return this.block; } BlockMessage(Block block); }
|
BlockMessage extends Message { public Block getBlock() { return this.block; } BlockMessage(Block block); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); @Override void accept(MessageVisitor v); }
|
BlockMessage extends Message { public Block getBlock() { return this.block; } BlockMessage(Block block); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); @Override void accept(MessageVisitor v); }
|
@Test public void accept() { Block block = mock(Block.class); BlockMessage message = new BlockMessage(block); MessageVisitor visitor = mock(MessageVisitor.class); message.accept(visitor); verify(visitor, times(1)).apply(message); }
|
@Override public void accept(MessageVisitor v) { v.apply(this); }
|
BlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } }
|
BlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockMessage(Block block); }
|
BlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockMessage(Block block); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); @Override void accept(MessageVisitor v); }
|
BlockMessage extends Message { @Override public void accept(MessageVisitor v) { v.apply(this); } BlockMessage(Block block); Block getBlock(); @Override MessageType getMessageType(); @Override byte[] getEncodedMessage(); @Override void accept(MessageVisitor v); }
|
@Test public void sendBlockMessagesAndAddThemToBlockchain() { for (int i = 0; i < 50; i += 5) { Blockchain blockchain = new BlockChainBuilder().ofSize(10 * i); NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, SyncConfiguration.IMMEDIATE_FOR_TESTING); Assert.assertEquals(10 * i, blockchain.getBestBlock().getNumber()); List<Block> extendedChain = new BlockGenerator().getBlockChain(blockchain.getBestBlock(), i); for (Block block : extendedChain) { blockSyncService.processBlock(block, null, false); Assert.assertEquals(block.getNumber(), blockchain.getBestBlock().getNumber()); Assert.assertEquals(block.getHash(), blockchain.getBestBlock().getHash()); } } }
|
public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes); boolean hasBetterBlockToSync(); boolean canBeIgnoredForUnclesRewards(long blockNumber); long getLastKnownBlockNumber(); void setLastKnownBlockNumber(long lastKnownBlockNumber); @CheckForNull Block getBlockFromStoreOrBlockchain(@Nonnull final byte[] hash); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes); boolean hasBetterBlockToSync(); boolean canBeIgnoredForUnclesRewards(long blockNumber); long getLastKnownBlockNumber(); void setLastKnownBlockNumber(long lastKnownBlockNumber); @CheckForNull Block getBlockFromStoreOrBlockchain(@Nonnull final byte[] hash); static final int CHUNK_PART_LIMIT; static final int PROCESSED_BLOCKS_TO_CHECK_STORE; static final int RELEASED_RANGE; }
|
@Test public void sendBlockMessagesAndAddThemToBlockchainInReverseOrder() { for (int i = 1; i < 52; i += 5) { Blockchain blockchain = new BlockChainBuilder().ofSize(10 * i); NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, SyncConfiguration.IMMEDIATE_FOR_TESTING); Assert.assertEquals(10 * i, blockchain.getBestBlock().getNumber()); Block initialBestBlock = blockchain.getBestBlock(); List<Block> extendedChain = new BlockGenerator().getBlockChain(blockchain.getBestBlock(), i); Collections.reverse(extendedChain); for (int j = 0; j < extendedChain.size() - 1; j++) { Block block = extendedChain.get(j); blockSyncService.processBlock(block, null, false); Assert.assertEquals(initialBestBlock.getNumber(), blockchain.getBestBlock().getNumber()); Assert.assertEquals(initialBestBlock.getHash(), blockchain.getBestBlock().getHash()); } Block closingBlock = extendedChain.get(extendedChain.size() - 1); Block newBestBlock = extendedChain.get(0); blockSyncService.processBlock(closingBlock, null, false); Assert.assertEquals(newBestBlock.getNumber(), blockchain.getBestBlock().getNumber()); Assert.assertEquals(newBestBlock.getHash(), blockchain.getBestBlock().getHash()); } }
|
public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes); boolean hasBetterBlockToSync(); boolean canBeIgnoredForUnclesRewards(long blockNumber); long getLastKnownBlockNumber(); void setLastKnownBlockNumber(long lastKnownBlockNumber); @CheckForNull Block getBlockFromStoreOrBlockchain(@Nonnull final byte[] hash); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes); boolean hasBetterBlockToSync(); boolean canBeIgnoredForUnclesRewards(long blockNumber); long getLastKnownBlockNumber(); void setLastKnownBlockNumber(long lastKnownBlockNumber); @CheckForNull Block getBlockFromStoreOrBlockchain(@Nonnull final byte[] hash); static final int CHUNK_PART_LIMIT; static final int PROCESSED_BLOCKS_TO_CHECK_STORE; static final int RELEASED_RANGE; }
|
@Test public void sendBlockMessageAndAddItToBlockchainWithCommonAncestors() { Blockchain blockchain = new BlockChainBuilder().ofSize(10); NetBlockStore store = new NetBlockStore(); BlockNodeInformation nodeInformation = new BlockNodeInformation(); TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, SyncConfiguration.IMMEDIATE_FOR_TESTING); Block initialBestBlock = blockchain.getBestBlock(); Assert.assertEquals(10, initialBestBlock.getNumber()); Block branchingPoint = blockchain.getBlockByNumber(7); BlockGenerator blockGenerator = new BlockGenerator(); List<Block> extendedChain = blockGenerator.getBlockChain(branchingPoint, 10, 1000000l); for (int i = 0; i < extendedChain.size(); i++) { Block newBestBlock = extendedChain.get(i); blockSyncService.processBlock(newBestBlock, null, false); Assert.assertEquals(newBestBlock.getNumber(), blockchain.getBestBlock().getNumber()); Assert.assertEquals(newBestBlock.getHash(), blockchain.getBestBlock().getHash()); } }
|
public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes); boolean hasBetterBlockToSync(); boolean canBeIgnoredForUnclesRewards(long blockNumber); long getLastKnownBlockNumber(); void setLastKnownBlockNumber(long lastKnownBlockNumber); @CheckForNull Block getBlockFromStoreOrBlockchain(@Nonnull final byte[] hash); }
|
BlockSyncService { public BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes) { Instant start = Instant.now(); long bestBlockNumber = this.getBestBlockNumber(); long blockNumber = block.getNumber(); final Keccak256 blockHash = block.getHash(); int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); tryReleaseStore(bestBlockNumber); store.removeHeader(block.getHeader()); if (blockNumber > bestBlockNumber + syncMaxDistance) { logger.trace("Block too advanced {} {} from {} ", blockNumber, block.getPrintableHash(), sender != null ? sender.getPeerNodeID().toString() : "N/A"); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } if (sender != null) { nodeInformation.addBlockToNode(blockHash, sender.getPeerNodeID()); } if (BlockUtils.blockInSomeBlockChain(block, blockchain)) { logger.trace("Block already in a chain {} {}", blockNumber, block.getPrintableHash()); return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } trySaveStore(block); Set<Keccak256> unknownHashes = BlockUtils.unknownDirectAncestorsHashes(block, blockchain, store); if (!unknownHashes.isEmpty()) { if (!ignoreMissingHashes){ logger.trace("Missing hashes for block in process {} {}", blockNumber, block.getPrintableHash()); requestMissingHashes(sender, unknownHashes); } return new BlockProcessResult(false, null, block.getPrintableHash(), Duration.between(start, Instant.now())); } logger.trace("Trying to add to blockchain"); Map<Keccak256, ImportResult> connectResult = connectBlocksAndDescendants(sender, BlockUtils.sortBlocksByNumber(this.getParentsNotInBlockchain(block)), ignoreMissingHashes); return new BlockProcessResult(true, connectResult, block.getPrintableHash(), Duration.between(start, Instant.now())); } BlockSyncService(
@Nonnull final RskSystemProperties config,
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final SyncConfiguration syncConfiguration); BlockProcessResult processBlock(@Nonnull Block block, Peer sender, boolean ignoreMissingHashes); boolean hasBetterBlockToSync(); boolean canBeIgnoredForUnclesRewards(long blockNumber); long getLastKnownBlockNumber(); void setLastKnownBlockNumber(long lastKnownBlockNumber); @CheckForNull Block getBlockFromStoreOrBlockchain(@Nonnull final byte[] hash); static final int CHUNK_PART_LIMIT; static final int PROCESSED_BLOCKS_TO_CHECK_STORE; static final int RELEASED_RANGE; }
|
@Test public void fromComponentsWithRecoveryCalculation() { ECKey key = new ECKey(); byte[] hash = HashUtil.randomHash(); ECDSASignature signature = ECDSASignature.fromSignature(key.sign(hash)); ECDSASignature signatureWithCalculatedV = ECDSASignature.fromComponentsWithRecoveryCalculation( signature.getR().toByteArray(), signature.getS().toByteArray(), hash, key.getPubKey(false) ); Assert.assertEquals(signature.getR(), signatureWithCalculatedV.getR()); Assert.assertEquals(signature.getS(), signatureWithCalculatedV.getS()); Assert.assertEquals(signature.getV(), signatureWithCalculatedV.getV()); signatureWithCalculatedV = ECDSASignature.fromComponentsWithRecoveryCalculation( signature.getR().toByteArray(), signature.getS().toByteArray(), hash, key.getPubKey(true) ); Assert.assertEquals(signature.getR(), signatureWithCalculatedV.getR()); Assert.assertEquals(signature.getS(), signatureWithCalculatedV.getS()); Assert.assertEquals(signature.getV(), signatureWithCalculatedV.getV()); }
|
public static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub) { byte v = calculateRecoveryByte(r, s, hash, pub); return fromComponents(r, s, v); }
|
ECDSASignature { public static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub) { byte v = calculateRecoveryByte(r, s, hash, pub); return fromComponents(r, s, v); } }
|
ECDSASignature { public static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub) { byte v = calculateRecoveryByte(r, s, hash, pub); return fromComponents(r, s, v); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); }
|
ECDSASignature { public static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub) { byte v = calculateRecoveryByte(r, s, hash, pub); return fromComponents(r, s, v); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub); static ECDSASignature fromSignature(ECKey.ECDSASignature sign); BigInteger getR(); BigInteger getS(); byte getV(); void setV(byte v); static ECDSASignature fromComponents(byte[] r, byte[] s); static ECDSASignature fromComponents(byte[] r, byte[] s, byte v); boolean validateComponents(); static boolean validateComponents(BigInteger r, BigInteger s, byte v); ECDSASignature toCanonicalised(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECDSASignature { public static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub) { byte v = calculateRecoveryByte(r, s, hash, pub); return fromComponents(r, s, v); } ECDSASignature(BigInteger r, BigInteger s); ECDSASignature(BigInteger r, BigInteger s, byte v); static ECDSASignature fromComponentsWithRecoveryCalculation(byte[] r, byte[] s, byte[] hash, byte[] pub); static ECDSASignature fromSignature(ECKey.ECDSASignature sign); BigInteger getR(); BigInteger getS(); byte getV(); void setV(byte v); static ECDSASignature fromComponents(byte[] r, byte[] s); static ECDSASignature fromComponents(byte[] r, byte[] s, byte v); boolean validateComponents(); static boolean validateComponents(BigInteger r, BigInteger s, byte v); ECDSASignature toCanonicalised(); @Override boolean equals(Object o); @Override int hashCode(); }
|
@Test public void getDataWhenValueIsNull() throws Exception { Web3.CallArguments args = new Web3.CallArguments(); CallArgumentsToByteArray byteArrayArgs = new CallArgumentsToByteArray(args); Assert.assertNull(byteArrayArgs.getData()); }
|
public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } CallArgumentsToByteArray(Web3.CallArguments args); }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } CallArgumentsToByteArray(Web3.CallArguments args); byte[] getGasPrice(); byte[] getGasLimit(); byte[] getToAddress(); byte[] getValue(); byte[] getData(); RskAddress getFromAddress(); }
|
CallArgumentsToByteArray { public byte[] getData() { byte[] data = null; if (args.data != null && args.data.length() != 0) { data = stringHexToByteArray(args.data); } return data; } CallArgumentsToByteArray(Web3.CallArguments args); byte[] getGasPrice(); byte[] getGasLimit(); byte[] getToAddress(); byte[] getValue(); byte[] getData(); RskAddress getFromAddress(); }
|
@Test public void advancedBlock() throws UnknownHostException { final NetBlockStore store = new NetBlockStore(); final Peer sender = new SimplePeer(); final BlockNodeInformation nodeInformation = new BlockNodeInformation(); final SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; final Blockchain blockchain = new BlockChainBuilder().ofSize(0); final long advancedBlockNumber = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks() + blockchain.getBestBlock().getNumber() + 1; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); Assert.assertTrue(processor.isAdvancedBlock(advancedBlockNumber)); Assert.assertFalse(processor.isAdvancedBlock(advancedBlockNumber - 1)); }
|
@Override public boolean isAdvancedBlock(long blockNumber) { int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); long bestBlockNumber = this.getBestBlockNumber(); return blockNumber > bestBlockNumber + syncMaxDistance; }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean isAdvancedBlock(long blockNumber) { int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); long bestBlockNumber = this.getBestBlockNumber(); return blockNumber > bestBlockNumber + syncMaxDistance; } }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean isAdvancedBlock(long blockNumber) { int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); long bestBlockNumber = this.getBestBlockNumber(); return blockNumber > bestBlockNumber + syncMaxDistance; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean isAdvancedBlock(long blockNumber) { int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); long bestBlockNumber = this.getBestBlockNumber(); return blockNumber > bestBlockNumber + syncMaxDistance; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean isAdvancedBlock(long blockNumber) { int syncMaxDistance = syncConfiguration.getChunkSize() * syncConfiguration.getMaxSkeletonChunks(); long bestBlockNumber = this.getBestBlockNumber(); return blockNumber > bestBlockNumber + syncMaxDistance; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void canBeIgnoredForUncles() throws UnknownHostException { final NetBlockStore store = new NetBlockStore(); final Peer sender = new SimplePeer(); final BlockNodeInformation nodeInformation = new BlockNodeInformation(); final SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; final Blockchain blockchain = new BlockChainBuilder().ofSize(15); final TestSystemProperties config = new TestSystemProperties(); int uncleGenerationLimit = config.getNetworkConstants().getUncleGenerationLimit(); final long blockNumberThatCanBeIgnored = blockchain.getBestBlock().getNumber() - 1 - uncleGenerationLimit; BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); Assert.assertTrue(processor.canBeIgnoredForUnclesRewards(blockNumberThatCanBeIgnored)); Assert.assertFalse(processor.canBeIgnoredForUnclesRewards(blockNumberThatCanBeIgnored + 1)); }
|
@Override public boolean canBeIgnoredForUnclesRewards(long blockNumber) { return blockSyncService.canBeIgnoredForUnclesRewards(blockNumber); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean canBeIgnoredForUnclesRewards(long blockNumber) { return blockSyncService.canBeIgnoredForUnclesRewards(blockNumber); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean canBeIgnoredForUnclesRewards(long blockNumber) { return blockSyncService.canBeIgnoredForUnclesRewards(blockNumber); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean canBeIgnoredForUnclesRewards(long blockNumber) { return blockSyncService.canBeIgnoredForUnclesRewards(blockNumber); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean canBeIgnoredForUnclesRewards(long blockNumber) { return blockSyncService.canBeIgnoredForUnclesRewards(blockNumber); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processTenBlocksAddingToBlockchain() { Blockchain blockchain = new BlockChainBuilder().ofSize(0); NetBlockStore store = new NetBlockStore(); Block genesis = blockchain.getBestBlock(); List<Block> blocks = new BlockGenerator().getBlockChain(genesis, 10); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); processor.processBlock(null, genesis); Assert.assertEquals(0, store.size()); for (Block b : blocks) processor.processBlock(null, b); Assert.assertEquals(10, blockchain.getBestBlock().getNumber()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processTwoBlockListsAddingToBlockchain() { Blockchain blockchain = new BlockChainBuilder().ofSize(0); NetBlockStore store = new NetBlockStore(); Block genesis = blockchain.getBestBlock(); BlockGenerator blockGenerator = new BlockGenerator(); List<Block> blocks = blockGenerator.getBlockChain(genesis, 10); List<Block> blocks2 = blockGenerator.getBlockChain(genesis, 20); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); processor.processBlock(null, genesis); Assert.assertEquals(0, store.size()); for (Block b : blocks) processor.processBlock(null, b); for (Block b : blocks2) processor.processBlock(null, b); Assert.assertEquals(20, blockchain.getBestBlock().getNumber()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processTwoBlockListsAddingToBlockchainWithFork() { NetBlockStore store = new NetBlockStore(); Blockchain blockchain = new BlockChainBuilder().ofSize(0); Block genesis = blockchain.getBestBlock(); BlockGenerator blockGenerator = new BlockGenerator(); List<Block> blocks = blockGenerator.getBlockChain(genesis, 10); List<Block> blocks2 = blockGenerator.getBlockChain(blocks.get(4), 20); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); processor.processBlock(null, genesis); Assert.assertEquals(0, store.size()); for (Block b : blocks) processor.processBlock(null, b); for (Block b : blocks2) processor.processBlock(null, b); Assert.assertEquals(25, blockchain.getBestBlock().getNumber()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void noSyncingWithEmptyBlockchain() { NetBlockStore store = new NetBlockStore(); Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); Assert.assertFalse(processor.hasBetterBlockToSync()); }
|
@Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test @Ignore("Ignored when Process status deleted on block processor") public void noSyncingWithEmptyBlockchainAndLowBestBlock() { NetBlockStore store = new NetBlockStore(); Block block = new BlockGenerator().createBlock(10, 0); Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); Assert.assertFalse(processor.hasBetterBlockToSync()); Status status = new Status(block.getNumber(), block.getHash().getBytes()); Assert.assertFalse(processor.hasBetterBlockToSync()); }
|
@Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test @Ignore("Ignored when Process status deleted on block processor") public void syncingWithEmptyBlockchainAndHighBestBlock() { NetBlockStore store = new NetBlockStore(); Block block = new BlockGenerator().createBlock(30, 0); Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); Assert.assertFalse(processor.hasBetterBlockToSync()); Assert.assertTrue(processor.hasBetterBlockToSync()); }
|
@Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test @Ignore("Ignored when Process status deleted on block processor") public void syncingThenNoSyncing() { NetBlockStore store = new NetBlockStore(); Block block = new BlockGenerator().createBlock(30, 0); Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); Assert.assertFalse(processor.hasBetterBlockToSync()); Assert.assertTrue(processor.hasBetterBlockToSync()); Assert.assertTrue(processor.hasBetterBlockToSync()); blockchain.setStatus(block, new BlockDifficulty(BigInteger.valueOf(30))); Assert.assertFalse(processor.hasBetterBlockToSync()); Assert.assertFalse(processor.hasBetterBlockToSync()); Block block2 = new BlockGenerator().createBlock(60, 0); Assert.assertTrue(processor.hasBetterBlockToSync()); Assert.assertFalse(processor.hasBetterBlockToSync()); }
|
@Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public boolean hasBetterBlockToSync() { return blockSyncService.hasBetterBlockToSync(); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processTenBlocksGenesisAtLastAddingToBlockchain() { NetBlockStore store = new NetBlockStore(); Blockchain blockchain = new BlockChainBuilder().ofSize(0); Block genesis = blockchain.getBestBlock(); List<Block> blocks = new BlockGenerator().getBlockChain(genesis, 10); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); for (Block b : blocks) processor.processBlock(null, b); processor.processBlock(null, genesis); Assert.assertEquals(10, blockchain.getBestBlock().getNumber()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void testHashCode() { Assert.assertEquals(1866897155, ECKey.fromPrivate(privateKey).hashCode()); }
|
@Override public int hashCode() { byte[] bits = getPubKey(true); return (bits[0] & 0xFF) | ((bits[1] & 0xFF) << 8) | ((bits[2] & 0xFF) << 16) | ((bits[3] & 0xFF) << 24); }
|
ECKey { @Override public int hashCode() { byte[] bits = getPubKey(true); return (bits[0] & 0xFF) | ((bits[1] & 0xFF) << 8) | ((bits[2] & 0xFF) << 16) | ((bits[3] & 0xFF) << 24); } }
|
ECKey { @Override public int hashCode() { byte[] bits = getPubKey(true); return (bits[0] & 0xFF) | ((bits[1] & 0xFF) << 8) | ((bits[2] & 0xFF) << 16) | ((bits[3] & 0xFF) << 24); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); }
|
ECKey { @Override public int hashCode() { byte[] bits = getPubKey(true); return (bits[0] & 0xFF) | ((bits[1] & 0xFF) << 8) | ((bits[2] & 0xFF) << 16) | ((bits[3] & 0xFF) << 24); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); }
|
ECKey { @Override public int hashCode() { byte[] bits = getPubKey(true); return (bits[0] & 0xFF) | ((bits[1] & 0xFF) << 8) | ((bits[2] & 0xFF) << 16) | ((bits[3] & 0xFF) << 24); } ECKey(); ECKey(SecureRandom secureRandom); ECKey(@Nullable BigInteger priv, ECPoint pub); static ECPoint compressPoint(ECPoint uncompressed); static ECPoint decompressPoint(ECPoint compressed); static ECKey fromPrivate(BigInteger privKey); static ECKey fromPrivate(byte[] privKeyBytes); static ECKey fromPublicOnly(ECPoint pub); static ECKey fromPublicOnly(byte[] pub); ECKey decompress(); boolean isPubKeyOnly(); boolean hasPrivKey(); static byte[] publicKeyFromPrivate(BigInteger privKey, boolean compressed); byte[] getAddress(); byte[] getNodeId(); byte[] getPubKey(); byte[] getPubKey(boolean compressed); ECPoint getPubKeyPoint(); boolean equalsPub(ECKey other); BigInteger getPrivKey(); String toString(); ECDSASignature doSign(byte[] input); ECDSASignature sign(byte[] messageHash); @Deprecated static ECKey signatureToKey(byte[] messageHash, ECDSASignature signature); byte[] decryptAES(byte[] cipher); @Deprecated static boolean verify(byte[] data, ECDSASignature signature, byte[] pub); @Deprecated boolean verify(byte[] sigHash, ECDSASignature signature); boolean verify(byte[] sigHash, org.ethereum.crypto.signature.ECDSASignature signature); boolean isPubKeyCanonical(); static boolean isPubKeyCanonical(byte[] pubkey); @Deprecated @Nullable static ECKey recoverFromSignature(int recId, ECDSASignature sig, byte[] messageHash, boolean compressed); @Nullable byte[] getPrivKeyBytes(); @Override boolean equals(Object o); @Override int hashCode(); static final ECDomainParameters CURVE; static final BigInteger HALF_CURVE_ORDER; }
|
@Test public void processTenBlocksInverseOrderAddingToBlockchain() { Blockchain blockchain = new BlockChainBuilder().ofSize(0); NetBlockStore store = new NetBlockStore(); Block genesis = blockchain.getBestBlock(); List<Block> blocks = new BlockGenerator().getBlockChain(genesis, 10); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); for (int k = 0; k < 10; k++) processor.processBlock(null, blocks.get(9 - k)); processor.processBlock(null, genesis); Assert.assertEquals(10, blockchain.getBestBlock().getNumber()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processTenBlocksWithHoleAddingToBlockchain() { Blockchain blockchain = new BlockChainBuilder().ofSize(0); NetBlockStore store = new NetBlockStore(); Block genesis = blockchain.getBestBlock(); List<Block> blocks = new BlockGenerator().getBlockChain(genesis, 10); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); for (int k = 0; k < 10; k++) if (k != 5) processor.processBlock(null, blocks.get(9 - k)); processor.processBlock(null, genesis); processor.processBlock(null, blocks.get(4)); Assert.assertEquals(10, blockchain.getBestBlock().getNumber()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block) { return blockSyncService.processBlock(block, sender, false); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test @Ignore("Ignored when Process status deleted on block processor") public void processStatusRetrievingBestBlockUsingSender() throws UnknownHostException { final NetBlockStore store = new NetBlockStore(); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); BlockGenerator blockGenerator = new BlockGenerator(); final Block genesis = blockGenerator.getGenesisBlock(); final Block block = blockGenerator.createChildBlock(genesis); Assert.assertTrue(processor.getNodeInformation().getNodesByBlock(block.getHash().getBytes()).size() == 1); Assert.assertEquals(1, sender.getGetBlockMessages().size()); final Message message = sender.getGetBlockMessages().get(0); Assert.assertNotNull(message); Assert.assertEquals(MessageType.GET_BLOCK_MESSAGE, message.getMessageType()); final GetBlockMessage gbMessage = (GetBlockMessage) message; Assert.assertArrayEquals(block.getHash().getBytes(), gbMessage.getBlockHash()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockNodeInformation getNodeInformation() { return nodeInformation; }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test @Ignore("Ignored when Process status deleted on block processor") public void processStatusHavingBestBlockInStore() throws UnknownHostException { final NetBlockStore store = new NetBlockStore(); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); BlockGenerator blockGenerator = new BlockGenerator(); final Block genesis = blockGenerator.getGenesisBlock(); final Block block = blockGenerator.createChildBlock(genesis); store.saveBlock(block); Assert.assertTrue(processor.getNodeInformation().getNodesByBlock(block.getHash().getBytes()).size() == 1); Assert.assertEquals(1, store.size()); }
|
@Override public BlockNodeInformation getNodeInformation() { return nodeInformation; }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test @Ignore("Ignored when Process status deleted on block processor") public void processStatusHavingBestBlockAsBestBlockInBlockchain() throws UnknownHostException { final NetBlockStore store = new NetBlockStore(); final Blockchain blockchain = new BlockChainBuilder().ofSize(2); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); final Block block = blockchain.getBestBlock(); final Keccak256 blockHash = block.getHash(); Assert.assertTrue(processor.getNodeInformation().getNodesByBlock(block.getHash().getBytes()).size() == 1); Assert.assertTrue(processor.getNodeInformation().getNodesByBlock(block.getHash().getBytes()).contains(sender.getPeerNodeID())); Assert.assertEquals(0, sender.getGetBlockMessages().size()); Assert.assertEquals(0, store.size()); }
|
@Override public BlockNodeInformation getNodeInformation() { return nodeInformation; }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public BlockNodeInformation getNodeInformation() { return nodeInformation; } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processGetBlockHeaderMessageUsingBlockInStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final NetBlockStore store = new NetBlockStore(); store.saveBlock(block); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); processor.processBlockHeadersRequest(sender, 1, block.getHash().getBytes(), 1); Assert.assertFalse(sender.getMessages().isEmpty()); Assert.assertEquals(1, sender.getMessages().size()); final Message message = sender.getMessages().get(0); Assert.assertEquals(MessageType.BLOCK_HEADERS_RESPONSE_MESSAGE, message.getMessageType()); final BlockHeadersResponseMessage bMessage = (BlockHeadersResponseMessage) message; Assert.assertEquals(block.getHeader().getHash(), bMessage.getBlockHeaders().get(0).getHash()); }
|
@Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
@Test public void processGetBlockHeaderMessageUsingEmptyStore() throws UnknownHostException { final Block block = new BlockGenerator().getBlock(3); final NetBlockStore store = new NetBlockStore(); final Blockchain blockchain = new BlockChainBuilder().ofSize(0); BlockNodeInformation nodeInformation = new BlockNodeInformation(); SyncConfiguration syncConfiguration = SyncConfiguration.IMMEDIATE_FOR_TESTING; TestSystemProperties config = new TestSystemProperties(); BlockSyncService blockSyncService = new BlockSyncService(config, store, blockchain, nodeInformation, syncConfiguration); final NodeBlockProcessor processor = new NodeBlockProcessor(store, blockchain, nodeInformation, blockSyncService, syncConfiguration); final SimplePeer sender = new SimplePeer(); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); processor.processBlockHeadersRequest(sender, 1, block.getHash().getBytes(), 1); Assert.assertTrue(nodeInformation.getNodesByBlock(block.getHash()).isEmpty()); Assert.assertTrue(sender.getMessages().isEmpty()); }
|
@Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
NodeBlockProcessor implements BlockProcessor { @Override public void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count) { logger.trace("Processing headers request {} {} from {}", requestId, ByteUtil.toHexString(hash), sender.getPeerNodeID()); if (count > syncConfiguration.getChunkSize()) { logger.trace("Headers request from {} failed because size {}", sender.getPeerNodeID(), count); return; } Block block = blockSyncService.getBlockFromStoreOrBlockchain(hash); if (block == null) { return; } List<BlockHeader> headers = new ArrayList<>(); headers.add(block.getHeader()); for (int k = 1; k < count; k++) { block = blockSyncService.getBlockFromStoreOrBlockchain(block.getParentHash().getBytes()); if (block == null) { break; } headers.add(block.getHeader()); } BlockHeadersResponseMessage response = new BlockHeadersResponseMessage(requestId, headers); sender.sendMessage(response); } NodeBlockProcessor(
@Nonnull final NetBlockStore store,
@Nonnull final Blockchain blockchain,
@Nonnull final BlockNodeInformation nodeInformation,
@Nonnull final BlockSyncService blockSyncService,
@Nonnull final SyncConfiguration syncConfiguration); @Override boolean isAdvancedBlock(long blockNumber); @Override void processNewBlockHashesMessage(final Peer sender, final NewBlockHashesMessage message); @Override void processBlockHeaders(@Nonnull final Peer sender, @Nonnull final List<BlockHeader> blockHeaders); @Override void processGetBlock(@Nonnull final Peer sender, @Nonnull final byte[] hash); @Override void processBlockRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHeadersRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash, int count); @Override void processBodyRequest(@Nonnull final Peer sender, long requestId, @Nonnull final byte[] hash); @Override void processBlockHashRequest(@Nonnull final Peer sender, long requestId, long height); @Override void processSkeletonRequest(@Nonnull final Peer sender, long requestId, long startNumber); @Override boolean canBeIgnoredForUnclesRewards(long blockNumber); @Override BlockNodeInformation getNodeInformation(); long getBestBlockNumber(); @Override boolean hasBlock(@Nonnull final byte[] hash); @Override boolean hasBlockInProcessorStore(@Nonnull final byte[] hash); @Override BlockProcessResult processBlock(@Nullable final Peer sender, @Nonnull final Block block); @Override boolean hasBlockInSomeBlockchain(@Nonnull final byte[] hash); @Override boolean hasBetterBlockToSync(); @Override long getLastKnownBlockNumber(); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.