public void WhenRefreshWhitelist_AndActivePeersAvailable_ThenWhitelistContainsActivePeers()
{
// Arrange.
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockLogger = new Mock <ILogger>();
var mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 2000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var activeEndpointOne = new IPEndPoint(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var activeEndpointTwo = new IPEndPoint(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var activeEndpointThree = new IPEndPoint(activeIpAddressThree, 80);
IPAddress activeIpAddressFour = IPAddress.Parse("::ffff:192.168.0.4");
var activeEndpointFour = new IPEndPoint(activeIpAddressFour, 80);
IPAddress activeIpAddressFive = IPAddress.Parse("2607:f8b0:4009:80e::200e");
var activeEndpointFive = new IPEndPoint(activeIpAddressFive, 80);
var testDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointFour, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointFive, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(50))
};
// PeerAddressManager does not support IPv4 addresses that are not represented as embedded IPv4 addresses in an IPv6 address.
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(testDataSet);
IMasterFile spiedMasterFile = null;
var mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
NodeSettings nodeSettings = NodeSettings.Default(this.Network);
DnsSettings dnsSettings = new DnsSettings(NodeSettings.Default(this.Network));
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings(nodeSettings);
var whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings, this.peerBanning);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
// Check for A records (IPv4 embedded in IPv6 and IPv4 addresses).
var question4 = new Question(new Domain(dnsSettings.DnsHostName), RecordType.A);
IList <IResourceRecord> resourceRecordsIpv4 = spiedMasterFile.Get(question4);
resourceRecordsIpv4.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords4 = resourceRecordsIpv4.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords4.Should().HaveCount(4);
// Check for AAAA records (IPv6 addresses).
var question6 = new Question(new Domain(dnsSettings.DnsHostName), RecordType.AAAA);
IList <IResourceRecord> resourceRecordsIpv6 = spiedMasterFile.Get(question6);
resourceRecordsIpv6.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords6 = resourceRecordsIpv6.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords6.Should().HaveCount(1);
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in testDataSet)
{
if (testData.Item1.Address.IsIPv4MappedToIPv6)
{
ipAddressResourceRecords4.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().NotBeNull();
}
else
{
ipAddressResourceRecords6.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address)).Should().NotBeNull();
}
}
}
private PeerConnectorDiscovery CreatePeerConnectorDiscovery(NodeSettings nodeSettings, ConnectionManagerSettings connectionSettings, IPeerAddressManager peerAddressManager)
{
var peerConnector = new PeerConnectorDiscovery(this.asyncLoopFactory, DateTimeProvider.Default, this.extendedLoggerFactory, this.network, this.networkPeerFactory, this.nodeLifetime, nodeSettings, connectionSettings, peerAddressManager);
var connectionManager = CreateConnectionManager(nodeSettings, connectionSettings, peerAddressManager, peerConnector);
peerConnector.Initialize(connectionManager);
return(peerConnector);
}
private IConnectionManager CreateConnectionManager(NodeSettings nodeSettings, ConnectionManagerSettings connectionSettings, IPeerAddressManager peerAddressManager, IPeerConnector peerConnector)
{
var connectionManager = new ConnectionManager(
DateTimeProvider.Default,
this.LoggerFactory.Object,
this.network,
this.networkPeerFactory,
nodeSettings,
this.nodeLifetime,
this.networkPeerParameters,
peerAddressManager,
new IPeerConnector[] { peerConnector },
null,
connectionSettings);
return(connectionManager);
}
/// <summary>
/// Creates the test chain with some default blocks and txs.
/// </summary>
/// <param name="network">Network to create the chain on.</param>
/// <param name="scriptPubKey">Public key to create blocks/txs with.</param>
/// <returns>Context object representing the test chain.</returns>
public static async Task <ITestChainContext> CreateAsync(Network network, Script scriptPubKey, string dataDir)
{
NodeSettings nodeSettings = new NodeSettings(network, args: new string[] { $"-datadir={dataDir}" });
var loggerFactory = new ExtendedLoggerFactory();
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
network.Consensus.Options = new PowConsensusOptions();
ConsensusSettings consensusSettings = new ConsensusSettings(nodeSettings, loggerFactory);
PowConsensusValidator consensusValidator = new PowConsensusValidator(network, new Checkpoints(), dateTimeProvider, loggerFactory);
ConcurrentChain chain = new ConcurrentChain(network);
CachedCoinView cachedCoinView = new CachedCoinView(new InMemoryCoinView(chain.Tip.HashBlock), DateTimeProvider.Default, loggerFactory);
NetworkPeerFactory networkPeerFactory = new NetworkPeerFactory(network, dateTimeProvider, loggerFactory);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory);
var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, Network.Main, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager);
var connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, connectionSettings);
LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(chain, connectionManager, new LoggerFactory());
PeerBanning peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, nodeSettings);
NodeDeployments deployments = new NodeDeployments(network, chain);
ConsensusRules consensusRules = new PowConsensusRules(network, loggerFactory, dateTimeProvider, chain, deployments, consensusSettings, new Checkpoints()).Register(new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration());
ConsensusLoop consensus = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), consensusValidator, new NodeLifetime(), chain, cachedCoinView, blockPuller, deployments, loggerFactory, new ChainState(new InvalidBlockHashStore(dateTimeProvider)), connectionManager, dateTimeProvider, new Signals.Signals(), consensusSettings, nodeSettings, peerBanning, consensusRules);
await consensus.StartAsync();
BlockPolicyEstimator blockPolicyEstimator = new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings);
TxMempool mempool = new TxMempool(dateTimeProvider, blockPolicyEstimator, loggerFactory, nodeSettings);
MempoolSchedulerLock mempoolLock = new MempoolSchedulerLock();
// Simple block creation, nothing special yet:
PowBlockAssembler blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider, loggerFactory);
BlockTemplate newBlock = blockAssembler.CreateNewBlock(scriptPubKey);
chain.SetTip(newBlock.Block.Header);
await consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = newBlock.Block
}, network.Consensus, consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
List <BlockInfo> blockinfo = CreateBlockInfoList();
// We can't make transactions until we have inputs
// Therefore, load 100 blocks :)
int baseheight = 0;
List <Block> blocks = new List <Block>();
List <Transaction> srcTxs = new List <Transaction>();
for (int i = 0; i < blockinfo.Count; ++i)
{
Block currentBlock = newBlock.Block.Clone(); // pointer for convenience
currentBlock.Header.HashPrevBlock = chain.Tip.HashBlock;
currentBlock.Header.Version = 1;
currentBlock.Header.Time = Utils.DateTimeToUnixTime(chain.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = currentBlock.Transactions[0].Clone();
txCoinbase.Inputs.Clear();
txCoinbase.Version = 1;
txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(blockinfo[i].extraNonce), Op.GetPushOp(chain.Height) })));
// Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
txCoinbase.AddOutput(new TxOut(Money.Zero, new Script()));
currentBlock.Transactions[0] = txCoinbase;
if (srcTxs.Count == 0)
{
baseheight = chain.Height;
}
if (srcTxs.Count < 4)
{
srcTxs.Add(currentBlock.Transactions[0]);
}
currentBlock.UpdateMerkleRoot();
currentBlock.Header.Nonce = blockinfo[i].nonce;
chain.SetTip(currentBlock.Header);
await consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = currentBlock
}, network.Consensus, consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
blocks.Add(currentBlock);
}
// Just to make sure we can still make simple blocks
blockAssembler = CreatePowBlockAssembler(network, consensus, chain, mempoolLock, mempool, dateTimeProvider, loggerFactory);
newBlock = blockAssembler.CreateNewBlock(scriptPubKey);
MempoolValidator mempoolValidator = new MempoolValidator(mempool, mempoolLock, consensusValidator, dateTimeProvider, new MempoolSettings(nodeSettings), chain, cachedCoinView, loggerFactory, nodeSettings);
return(new TestChainContext {
MempoolValidator = mempoolValidator, SrcTxs = srcTxs
});
}
public async Task InitializeAsync()
{
this.blockinfo = new List <Blockinfo>();
var lst = blockinfoarr.Cast <long>().ToList();
for (int i = 0; i < lst.Count; i += 2)
{
this.blockinfo.Add(new Blockinfo {
extranonce = (int)lst[i], nonce = (uint)lst[i + 1]
});
}
// Note that by default, these tests run with size accounting enabled.
this.network = Network.Main;
var hex = Encoders.Hex.DecodeData("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
this.scriptPubKey = new Script(new[] { Op.GetPushOp(hex), OpcodeType.OP_CHECKSIG });
this.newBlock = new BlockTemplate(this.network);
this.entry = new TestMemPoolEntryHelper();
this.chain = new ConcurrentChain(this.network);
this.network.Consensus.Options = new PowConsensusOptions();
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
this.cachedCoinView = new CachedCoinView(new InMemoryCoinView(this.chain.Tip.HashBlock), dateTimeProvider, new LoggerFactory());
var loggerFactory = new ExtendedLoggerFactory();
loggerFactory.AddConsoleWithFilters();
NodeSettings nodeSettings = new NodeSettings(args: new string[] { "-checkpoints" });
var consensusSettings = new ConsensusSettings().Load(nodeSettings);
PowConsensusValidator consensusValidator = new PowConsensusValidator(this.network, new Checkpoints(), dateTimeProvider, loggerFactory);
NetworkPeerFactory networkPeerFactory = new NetworkPeerFactory(this.network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads(), new SelfEndpointTracker());
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker());
var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, Network.Main, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager);
var connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, this.network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, connectionSettings);
LookaheadBlockPuller blockPuller = new LookaheadBlockPuller(this.chain, connectionManager, new LoggerFactory());
PeerBanning peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager);
NodeDeployments deployments = new NodeDeployments(this.network, this.chain);
ConsensusRules consensusRules = new PowConsensusRules(this.network, loggerFactory, dateTimeProvider, this.chain, deployments, consensusSettings, new Checkpoints(), this.cachedCoinView, blockPuller).Register(new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration());
this.consensus = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), consensusValidator, new NodeLifetime(), this.chain, this.cachedCoinView, blockPuller, new NodeDeployments(this.network, this.chain), loggerFactory, new ChainState(new InvalidBlockHashStore(dateTimeProvider)), connectionManager, dateTimeProvider, new Signals.Signals(), consensusSettings, nodeSettings, peerBanning, consensusRules);
await this.consensus.StartAsync();
this.entry.Fee(11);
this.entry.Height(11);
var date1 = new MemoryPoolTests.DateTimeProviderSet();
date1.time = dateTimeProvider.GetTime();
date1.timeutc = dateTimeProvider.GetUtcNow();
this.DateTimeProvider = date1;
this.mempool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(new MempoolSettings(nodeSettings), new LoggerFactory(), nodeSettings), new LoggerFactory(), nodeSettings);
this.mempoolLock = new MempoolSchedulerLock();
// Simple block creation, nothing special yet:
this.newBlock = AssemblerForTest(this).Build(this.chain.Tip, this.scriptPubKey);
this.chain.SetTip(this.newBlock.Block.Header);
await this.consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = this.newBlock.Block
}, this.network.Consensus, this.consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
// We can't make transactions until we have inputs
// Therefore, load 100 blocks :)
this.baseheight = 0;
List <Block> blocks = new List <Block>();
this.txFirst = new List <Transaction>();
for (int i = 0; i < this.blockinfo.Count; ++i)
{
var pblock = this.newBlock.Block.Clone(); // pointer for convenience
pblock.Header.HashPrevBlock = this.chain.Tip.HashBlock;
pblock.Header.Version = 1;
pblock.Header.Time = Utils.DateTimeToUnixTime(this.chain.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = pblock.Transactions[0].Clone();
txCoinbase.Inputs.Clear();
txCoinbase.Version = 1;
txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(this.blockinfo[i].extranonce), Op.GetPushOp(this.chain.Height) })));
// Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
txCoinbase.AddOutput(new TxOut(Money.Zero, new Script()));
pblock.Transactions[0] = txCoinbase;
if (this.txFirst.Count == 0)
{
this.baseheight = this.chain.Height;
}
if (this.txFirst.Count < 4)
{
this.txFirst.Add(pblock.Transactions[0]);
}
pblock.UpdateMerkleRoot();
pblock.Header.Nonce = this.blockinfo[i].nonce;
this.chain.SetTip(pblock.Header);
await this.consensus.ValidateAndExecuteBlockAsync(new RuleContext(new BlockValidationContext {
Block = pblock
}, this.network.Consensus, this.consensus.Tip) { CheckPow = false, CheckMerkleRoot = false });
blocks.Add(pblock);
}
// Just to make sure we can still make simple blocks
this.newBlock = AssemblerForTest(this).Build(this.chain.Tip, this.scriptPubKey);
Assert.NotNull(this.newBlock);
}
public TestContext()
{
this.Network = KnownNetworks.RegTest;
this.chain = new ConcurrentChain(this.Network);
this.dateTimeProvider = new DateTimeProvider();
this.hashStore = new InvalidBlockHashStore(this.dateTimeProvider);
this.coinView = new TestInMemoryCoinView(this.chain.Tip.HashBlock);
this.HeaderValidator = new Mock <IHeaderValidator>();
this.HeaderValidator.Setup(hv => hv.ValidateHeader(It.IsAny <ChainedHeader>())).Returns(new ValidationContext());
this.nodeLifetime = new NodeLifetime();
this.ibd = new Mock <IInitialBlockDownloadState>();
this.BlockPuller = new Mock <IBlockPuller>();
this.BlockPuller.Setup(b => b.Initialize(It.IsAny <BlockPuller.OnBlockDownloadedCallback>()))
.Callback <BlockPuller.OnBlockDownloadedCallback>((d) => { this.blockPullerBlockDownloadCallback = d; });
this.BlockStore = new Mock <IBlockStore>();
this.checkpoints = new Mock <ICheckpoints>();
this.ChainState = new Mock <IChainState>();
this.nodeStats = new NodeStats(this.dateTimeProvider);
string[] param = new string[] { };
this.nodeSettings = new NodeSettings(this.Network, args: param);
this.ConsensusSettings = new ConsensusSettings(this.nodeSettings);
this.loggerFactory = this.nodeSettings.LoggerFactory;
var connectionSettings = new ConnectionManagerSettings(this.nodeSettings);
this.selfEndpointTracker = new SelfEndpointTracker(this.loggerFactory, connectionSettings);
this.Network.Consensus.Options = new ConsensusOptions();
this.ruleRegistration = new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration();
this.ruleRegistration.RegisterRules(this.Network.Consensus);
// Dont check PoW of a header in this test.
this.Network.Consensus.HeaderValidationRules.RemoveAll(x => x.GetType() == typeof(CheckDifficultyPowRule));
this.ChainedHeaderTree = new ChainedHeaderTree(
this.Network,
this.loggerFactory,
this.HeaderValidator.Object,
this.checkpoints.Object,
this.ChainState.Object,
this.FinalizedBlockMock.Object,
this.ConsensusSettings,
this.hashStore);
this.networkPeerFactory = new NetworkPeerFactory(this.Network,
this.dateTimeProvider,
this.loggerFactory, new PayloadProvider().DiscoverPayloads(),
this.selfEndpointTracker,
this.ibd.Object,
new ConnectionManagerSettings(this.nodeSettings));
this.peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, this.nodeSettings.DataFolder, this.loggerFactory, this.selfEndpointTracker);
var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(this.loggerFactory), this.loggerFactory, this.Network, this.networkPeerFactory, this.nodeLifetime, this.nodeSettings, this.peerAddressManager);
this.connectionManager = new ConnectionManager(this.dateTimeProvider, this.loggerFactory, this.Network, this.networkPeerFactory, this.nodeSettings,
this.nodeLifetime, new NetworkPeerConnectionParameters(), this.peerAddressManager, new IPeerConnector[] { },
peerDiscovery, this.selfEndpointTracker, connectionSettings, new VersionProvider(), this.nodeStats);
this.deployments = new NodeDeployments(this.Network, this.chain);
this.consensusRules = new PowConsensusRuleEngine(this.Network, this.loggerFactory, this.dateTimeProvider, this.chain, this.deployments, this.ConsensusSettings,
this.checkpoints.Object, this.coinView, this.ChainState.Object, this.hashStore, this.nodeStats);
this.consensusRules.Register();
var tree = new ChainedHeaderTree(this.Network, this.loggerFactory, this.HeaderValidator.Object, this.checkpoints.Object,
this.ChainState.Object, this.FinalizedBlockMock.Object, this.ConsensusSettings, this.hashStore);
this.PartialValidator = new Mock <IPartialValidator>();
this.FullValidator = new Mock <IFullValidator>();
this.peerBanning = new PeerBanning(this.connectionManager, this.loggerFactory, this.dateTimeProvider, this.peerAddressManager);
this.IntegrityValidator.Setup(i => i.VerifyBlockIntegrity(It.IsAny <ChainedHeader>(), It.IsAny <Block>()))
.Returns(new ValidationContext());
ConsensusManager consensusManager = new ConsensusManager(tree, this.Network, this.loggerFactory, this.ChainState.Object, this.IntegrityValidator.Object,
this.PartialValidator.Object, this.FullValidator.Object, this.consensusRules,
this.FinalizedBlockMock.Object, new Stratis.Bitcoin.Signals.Signals(this.loggerFactory, null), this.peerBanning, this.ibd.Object, this.chain,
this.BlockPuller.Object, this.BlockStore.Object, this.connectionManager, this.nodeStats, this.nodeLifetime, this.ConsensusSettings);
this.TestConsensusManager = new TestConsensusManager(consensusManager);
}
public void WhenRefreshWhitelist_AndOwnIPInPeers_AndNotRunningFullNode_ThenWhitelistDoesNotContainOwnIP()
{
// Arrange.
Mock <IDateTimeProvider> mockDateTimeProvider = new Mock <IDateTimeProvider>();
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 5000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
NetworkAddress activeNetworkAddressOne = new NetworkAddress(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
NetworkAddress activeNetworkAddressTwo = new NetworkAddress(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
NetworkAddress activeNetworkAddressThree = new NetworkAddress(activeIpAddressThree, 80);
List <Tuple <NetworkAddress, DateTimeOffset> > activeTestDataSet = new List <Tuple <NetworkAddress, DateTimeOffset> >()
{
new Tuple <NetworkAddress, DateTimeOffset> (activeNetworkAddressOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
};
IPAddress externalIPAdress = IPAddress.Parse("::ffff:192.168.99.99");
int externalPort = 80;
NetworkAddress externalNetworkAddress = new NetworkAddress(externalIPAdress, externalPort);
List <Tuple <NetworkAddress, DateTimeOffset> > externalIPTestDataSet = new List <Tuple <NetworkAddress, DateTimeOffset> >()
{
new Tuple <NetworkAddress, DateTimeOffset> (externalNetworkAddress, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40)),
};
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(activeTestDataSet.Union(externalIPTestDataSet).ToList());
string[] args = new string[] {
$"-dnspeeractivethreshold={inactiveTimePeriod.ToString()}",
$"-externalip={externalNetworkAddress.Endpoint.Address.ToString()}",
$"-port={externalPort.ToString()}",
};
IMasterFile spiedMasterFile = null;
Mock <IDnsServer> mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
Network network = Network.StratisTest;
NodeSettings nodeSettings = new NodeSettings(network).LoadArguments(args);
DnsSettings dnsSettings = new Mock <DnsSettings>().Object;
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
dnsSettings.DnsFullNode = false;
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
WhitelistManager whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
Question question = new Question(new Domain(dnsSettings.DnsHostName), RecordType.AAAA);
IList <IResourceRecord> resourceRecords = spiedMasterFile.Get(question);
resourceRecords.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords = resourceRecords.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords.Should().HaveSameCount(activeTestDataSet);
foreach (Tuple <NetworkAddress, DateTimeOffset> testData in activeTestDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Endpoint.Address)).Should().NotBeNull();
}
// External IP.
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(externalNetworkAddress.Endpoint)).Should().BeNull("the external IP peer should not be in DNS as not running full node.");
}
public PeerAddressManagerTests()
{
this.connectionManagerSettings = new ConnectionManagerSettings(NodeSettings.Default(new StraxRegTest()));
}
public void WhiteListedEndpoint_CanBeMappedAndRoutedTo_OtherNode()
{
IPEndPoint endpointA = null;
IPEndPoint endpointB = null;
IPEndPoint endpointOut = null;
var connectionManagerSettings = new ConnectionManagerSettings(NodeSettings.Default(this.Network));
var networkEndpoints = connectionManagerSettings.Bind.Select(x => x.Endpoint).ToList();
// IPV4: 127.0.0.1:16178 != 0.0.0.0:16178 (both are considered local endpoints)
endpointA = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 16178);
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
connectionManagerSettings.Port = 16178;
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// IPV6: [::1]:16178 != [::]:16178
endpointA = new IPEndPoint(IPAddress.Parse("[::1]"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("[::]"), 16178);
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
connectionManagerSettings.Port = 16178;
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// 127.0.0.1:16178 != 0.0.0.0:44556
endpointA = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 44556);
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
connectionManagerSettings.Port = 44556;
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// 0.0.0.0:16178 == 127.0.0.1:16178
endpointA = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 16178);
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
connectionManagerSettings.Port = 16178;
Assert.True(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// IPV4: 0.0.0.0:16178 == 127.0.0.2:16178
endpointA = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("127.0.0.2"), 16178);
connectionManagerSettings.Port = 16178;
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
Assert.True(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// IPV6: [::]:16178 == [::1]:16178
endpointA = new IPEndPoint(IPAddress.Parse("[::]"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("[::1]"), 16178);
connectionManagerSettings.Port = 16178;
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
Assert.True(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// IPV4: 0.0.0.0:16178 == 127.0.0.2:999
endpointA = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("127.0.0.2"), 999);
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
connectionManagerSettings.Port = 999;
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// IPV6: [::]:16178 != [::2]:999
endpointA = new IPEndPoint(IPAddress.Parse("[::]"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("[::2]"), 999);
connectionManagerSettings.Port = 999;
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// IPV6: [::1] != [fe80::d111:a4c4:ce4:2bc7%21] (Localhost -> Network address).
endpointA = new IPEndPoint(IPAddress.Parse("[::1]"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("[fe80::d111:a4c4:ce4:2bc7%21]"), 16178);
connectionManagerSettings.Port = 16178;
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// 10.0.0.1:16178 != 192.168.1.1:16178 (Bound to any but whitelisting local).
endpointA = new IPEndPoint(IPAddress.Parse("192.168.1.1"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("10.0.0.1"), 16178);
networkEndpoints = new List <IPEndPoint>()
{
endpointB
};
connectionManagerSettings.Port = 16178;
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// Using whitebind = 0.0.0.0:16178 and connecting from local or remote IP address on port 16178 should be whitebinded.
endpointA = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("10.0.0.1"), 16178);
Assert.True(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// Using whitebind = 100.64.1.1:16178 and connecting from local or remote IP address(other than 100.64.1.1) on port 16178 should not be whitebinded.
endpointA = new IPEndPoint(IPAddress.Parse("100.64.1.1"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("100.64.1.2"), 16178);
Assert.False(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
// Using whitebind = 0.0.0.0:16178 and connecting from local or remote IP address on port other than 16178 should be not whitebinded.
endpointA = new IPEndPoint(IPAddress.Parse("0.0.0.0"), 16178);
endpointB = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 16179);
Assert.True(endpointA.CanBeMappedTo(networkEndpoints, out endpointOut));
}
/// <summary>
/// Initializes a new instance of the <see cref="WhitelistManager"/> class.
/// </summary>
/// <param name="dateTimeProvider">The provider for datetime.</param>
/// <param name="loggerFactory">The factory to create the logger.</param>
/// <param name="peerAddressManager">The manager implementation for peer addresses.</param>
/// <param name="dnsServer">The DNS server.</param>
/// <param name="connectionSettings">The connection settings.</param>
/// <param name="dnsSettings">The DNS settings.</param>
/// <param name="peerBanning">Peer banning component.</param>
public WhitelistManager(IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, IPeerAddressManager peerAddressManager, IDnsServer dnsServer, ConnectionManagerSettings connectionSettings, DnsSettings dnsSettings, IPeerBanning peerBanning)
{
Guard.NotNull(dateTimeProvider, nameof(dateTimeProvider));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(peerAddressManager, nameof(peerAddressManager));
Guard.NotNull(dnsServer, nameof(dnsServer));
Guard.NotNull(dnsSettings, nameof(dnsSettings));
Guard.NotNull(connectionSettings, nameof(connectionSettings));
Guard.NotNull(peerBanning, nameof(peerBanning));
this.dateTimeProvider = dateTimeProvider;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.peerAddressManager = peerAddressManager;
this.dnsServer = dnsServer;
this.dnsSettings = dnsSettings;
this.externalEndpoint = connectionSettings.ExternalEndpoint;
this.peerBanning = peerBanning;
}
public async Task InitializeAsync()
{
this.blockinfo = new List <Blockinfo>();
List <long> lst = blockinfoarr.Cast <long>().ToList();
for (int i = 0; i < lst.Count; i += 2)
{
this.blockinfo.Add(new Blockinfo {
extranonce = (int)lst[i], nonce = (uint)lst[i + 1]
});
}
// Note that by default, these tests run with size accounting enabled.
this.network = KnownNetworks.RegTest;
byte[] hex = Encoders.Hex.DecodeData("04678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5f");
this.scriptPubKey = new Script(new[] { Op.GetPushOp(hex), OpcodeType.OP_CHECKSIG });
this.entry = new TestMemPoolEntryHelper();
this.chain = new ConcurrentChain(this.network);
this.network.Consensus.Options = new ConsensusOptions();
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
var inMemoryCoinView = new InMemoryCoinView(this.chain.Tip.HashBlock);
this.cachedCoinView = new CachedCoinView(inMemoryCoinView, dateTimeProvider, new LoggerFactory(), new NodeStats(dateTimeProvider));
var loggerFactory = new ExtendedLoggerFactory();
loggerFactory.AddConsoleWithFilters();
var nodeSettings = new NodeSettings(args: new string[] { "-checkpoints" });
var consensusSettings = new ConsensusSettings(nodeSettings);
var networkPeerFactory = new NetworkPeerFactory(this.network, dateTimeProvider, loggerFactory, new PayloadProvider().DiscoverPayloads(), new SelfEndpointTracker(loggerFactory), new Mock <IInitialBlockDownloadState>().Object, new ConnectionManagerSettings());
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker(loggerFactory));
var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, this.network, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager);
var connectionSettings = new ConnectionManagerSettings(nodeSettings);
var selfEndpointTracker = new SelfEndpointTracker(loggerFactory);
var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, this.network, networkPeerFactory,
nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { },
peerDiscovery, selfEndpointTracker, connectionSettings, new VersionProvider(), new Mock <INodeStats>().Object);
var peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager);
var deployments = new NodeDeployments(this.network, this.chain);
var genesis = this.network.GetGenesis();
var chainState = new ChainState()
{
BlockStoreTip = new ChainedHeader(genesis.Header, genesis.GetHash(), 0)
};
this.ConsensusRules = new PowConsensusRuleEngine(this.network, loggerFactory, dateTimeProvider, this.chain, deployments, consensusSettings,
new Checkpoints(), this.cachedCoinView, chainState, new InvalidBlockHashStore(dateTimeProvider), new NodeStats(dateTimeProvider)).Register();
this.consensus = ConsensusManagerHelper.CreateConsensusManager(this.network, chainState: chainState, inMemoryCoinView: inMemoryCoinView, chain: this.chain);
await this.consensus.InitializeAsync(chainState.BlockStoreTip);
this.entry.Fee(11);
this.entry.Height(11);
var dateTimeProviderSet = new DateTimeProviderSet
{
time = dateTimeProvider.GetTime(),
timeutc = dateTimeProvider.GetUtcNow()
};
this.DateTimeProvider = dateTimeProviderSet;
this.mempool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(new MempoolSettings(nodeSettings), loggerFactory, nodeSettings), loggerFactory, nodeSettings);
this.mempoolLock = new MempoolSchedulerLock();
// We can't make transactions until we have inputs
// Therefore, load 100 blocks :)
this.baseheight = 0;
var blocks = new List <Block>();
this.txFirst = new List <Transaction>();
this.nonce = 0;
for (int i = 0; i < this.blockinfo.Count; ++i)
{
Block block = this.network.CreateBlock();
block.Header.HashPrevBlock = this.consensus.Tip.HashBlock;
block.Header.Version = 1;
block.Header.Time = Utils.DateTimeToUnixTime(this.chain.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = this.network.CreateTransaction();
txCoinbase.Version = 1;
txCoinbase.AddInput(new TxIn(new Script(new[] { Op.GetPushOp(this.blockinfo[i].extranonce), Op.GetPushOp(this.chain.Height) })));
// Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
txCoinbase.AddOutput(new TxOut(Money.Zero, new Script()));
block.AddTransaction(txCoinbase);
if (this.txFirst.Count == 0)
{
this.baseheight = this.chain.Height;
}
if (this.txFirst.Count < 4)
{
this.txFirst.Add(block.Transactions[0]);
}
block.Header.Bits = block.Header.GetWorkRequired(this.network, this.chain.Tip);
block.UpdateMerkleRoot();
while (!block.CheckProofOfWork())
{
block.Header.Nonce = ++this.nonce;
}
// Serialization sets the BlockSize property.
block = Block.Load(block.ToBytes(), this.network);
var res = await this.consensus.BlockMinedAsync(block);
if (res == null)
{
throw new InvalidOperationException();
}
blocks.Add(block);
}
// Just to make sure we can still make simple blocks
this.newBlock = AssemblerForTest(this).Build(this.chain.Tip, this.scriptPubKey);
Assert.NotNull(this.newBlock);
}
public PeerSelectorTests()
{
this.extendedLoggerFactory = ExtendedLoggerFactory.Create();
this.connectionManagerSettings = new ConnectionManagerSettings(NodeSettings.Default(new StraxRegTest()));
}
private bool ConnectToPeer(PeerAddressManager peerAddressManager, Mock <INetworkPeerFactory> networkPeerFactoryExisting, ConnectionManagerSettings connectionManagerSettingsExisting, PeerConnectorConnectNode peerConnector, IPEndPoint endpointNode, Mock <IConnectionManager> mockConnectionManager)
{
peerAddressManager.AddPeer(endpointNode, IPAddress.Loopback);
var networkPeer = new Mock <INetworkPeer>();
networkPeer.SetupGet(np => np.PeerEndPoint).Returns(new IPEndPoint(endpointNode.Address, endpointNode.Port));
networkPeer.SetupGet(np => np.RemoteSocketAddress).Returns(endpointNode.Address);
networkPeer.SetupGet(np => np.RemoteSocketPort).Returns(endpointNode.Port);
networkPeer.SetupGet(np => np.State).Returns(NetworkPeerState.HandShaked);
networkPeerFactoryExisting.Setup(npf =>
npf.CreateConnectedNetworkPeerAsync(It.Is <IPEndPoint>(x => Equals(x, endpointNode)),
It.IsAny <NetworkPeerConnectionParameters>(), It.IsAny <NetworkPeerDisposer>())).Returns(Task.FromResult(networkPeer.Object));
connectionManagerSettingsExisting.AddNode.Add(endpointNode);
connectionManagerSettingsExisting.Connect.Add(endpointNode);
NetworkPeerCollection connectedPeers = (NetworkPeerCollection)mockConnectionManager.Object.ConnectedPeers;
foreach (INetworkPeer peer in peerConnector.ConnectorPeers)
{
if (!connectedPeers.Contains(peer))
{
connectedPeers.Add(peer);
}
}
mockConnectionManager.SetupGet(np => np.ConnectedPeers).Returns(connectedPeers);
peerConnector.Initialize(mockConnectionManager.Object);
peerConnector.OnConnectAsync().GetAwaiter().GetResult();
return(peerConnector.ConnectorPeers.Select(p => p.PeerEndPoint).Contains(endpointNode));
}
public void PeerConnectorDiscovery_DoesNotConnectTo_NodeInSameNetworkGroup_WithIpRangeFilteringEnabled()
{
DataFolder peerFolder = CreateDataFolder(this);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, peerFolder, this.extendedLoggerFactory, new SelfEndpointTracker());
// IpRangeFiltering enabled by default.
var nodeSettings = new NodeSettings(this.Network, args: new[] { "-IpRangeFiltering" });
var connectionManagerSettingsExisting = new ConnectionManagerSettings(nodeSettings);
Mock <INetworkPeerFactory> networkPeerFactoryExisting = new Mock <INetworkPeerFactory>();
Mock <IConnectionManager> connectionManagerExisting = new Mock <IConnectionManager>();
connectionManagerExisting.SetupGet(np => np.Parameters).Returns(this.networkPeerParameters);
connectionManagerExisting.SetupGet(np => np.ConnectedPeers).Returns(new NetworkPeerCollection());
var peerConnector = new PeerConnectorConnectNode(this.asyncLoopFactory, DateTimeProvider.Default, this.extendedLoggerFactory, this.Network, networkPeerFactoryExisting.Object, this.nodeLifetime, nodeSettings, connectionManagerSettingsExisting, peerAddressManager, new SelfEndpointTracker());
peerConnector.Initialize(connectionManagerExisting.Object);
// Peer 1.
IPAddress originalAddressPeer1 = IPAddress.Parse("::ffff:57.48.183.81"); // ipv4
var endpointPeer1 = new IPEndPoint(originalAddressPeer1, 80);
peerAddressManager.AddPeer(endpointPeer1, IPAddress.Loopback);
bool connectedToThisPeer = ConnectToPeer(peerAddressManager, networkPeerFactoryExisting, connectionManagerSettingsExisting, peerConnector, endpointPeer1, connectionManagerExisting);
Assert.True(connectedToThisPeer);
// Peer 2 has different network group to Peer 1.
IPAddress addressInDifferentNetworkGroupPeer2 = IPAddress.Parse("99be:f5c5:adc2:525c:f6d7:7b30:5336:5a0f"); // ipv6
var endpointPeer2 = new IPEndPoint(addressInDifferentNetworkGroupPeer2, 80);
peerAddressManager.AddPeer(endpointPeer2, IPAddress.Loopback);
connectedToThisPeer = ConnectToPeer(peerAddressManager, networkPeerFactoryExisting, connectionManagerSettingsExisting, peerConnector, endpointPeer2, connectionManagerExisting);
Assert.True(connectedToThisPeer); // Different network group: connects.
// Peer 3 in same network group as Peer 2.
IPAddress addressInSameNetworkGroupPeer3 = IPAddress.Parse("99be:f5c5:adc2:525c:db45:d36e:ce01:a394"); // ipv6
var endpointPeer3 = new IPEndPoint(addressInSameNetworkGroupPeer3, 80);
peerAddressManager.AddPeer(endpointPeer3, IPAddress.Loopback);
connectedToThisPeer = ConnectToPeer(peerAddressManager, networkPeerFactoryExisting, connectionManagerSettingsExisting, peerConnector, endpointPeer3, connectionManagerExisting);
Assert.False(connectedToThisPeer); // Same network group: does not connect.
// Peer 4 has different network group to Peer 1.
IPAddress addressInDifferentNetworkGroupPeer4 = IPAddress.Parse("::ffff:58.48.183.81"); // ipv4
var endpointPeer4 = new IPEndPoint(addressInDifferentNetworkGroupPeer4, 80);
peerAddressManager.AddPeer(endpointPeer4, IPAddress.Loopback);
connectedToThisPeer = ConnectToPeer(peerAddressManager, networkPeerFactoryExisting, connectionManagerSettingsExisting, peerConnector, endpointPeer4, connectionManagerExisting);
Assert.True(connectedToThisPeer); // Different network group: connects.
// Peer 5 has same network group as Peer 1.
IPAddress addressInSameNetworkGroupPeer5 = IPAddress.Parse("::ffff:57.48.183.82"); // ipv4
var endpointPeer5 = new IPEndPoint(addressInSameNetworkGroupPeer5, 80);
peerAddressManager.AddPeer(endpointPeer5, IPAddress.Loopback);
connectedToThisPeer = ConnectToPeer(peerAddressManager, networkPeerFactoryExisting, connectionManagerSettingsExisting, peerConnector, endpointPeer5, connectionManagerExisting);
Assert.False(connectedToThisPeer); // Same network group: does not connect.
}
public void WhenRefreshWhitelist_AndOwnIPInPeers_AndAreRunningFullNode_ThenWhitelistDoesContainOwnIP()
{
// Arrange.
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockLogger = new Mock <ILogger>();
var mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 5000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var activeEndpointOne = new IPEndPoint(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var activeEndpointTwo = new IPEndPoint(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var activeEndpointThree = new IPEndPoint(activeIpAddressThree, 80);
IPAddress externalIPAdress = IPAddress.Parse("::ffff:192.168.99.99");
int externalPort = 80;
var externalEndpoint = new IPEndPoint(externalIPAdress, externalPort);
var activeTestDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset> (activeEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <IPEndPoint, DateTimeOffset> (externalEndpoint, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40))
};
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(activeTestDataSet);
var args = new string[] {
$"-dnspeeractivethreshold={inactiveTimePeriod.ToString()}",
$"-externalip={externalEndpoint.Address.ToString()}",
$"-port={externalPort.ToString()}",
};
IMasterFile spiedMasterFile = null;
var mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
Network network = KnownNetworks.StraxTest;
var nodeSettings = new NodeSettings(network, args: args);
DnsSettings dnsSettings = new DnsSettings(NodeSettings.Default(this.Network));
dnsSettings.DnsFullNode = true;
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings(nodeSettings);
var whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings, this.peerBanning);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
var question = new Question(new Domain(dnsSettings.DnsHostName), RecordType.A);
IList <IResourceRecord> resourceRecords = spiedMasterFile.Get(question);
resourceRecords.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords = resourceRecords.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords.Should().HaveSameCount(activeTestDataSet);
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in activeTestDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().NotBeNull();
}
}
public void WhenRefreshWhitelist_AndActivePeersAvailable_ThenWhitelistContainsActivePeers()
{
// Arrange.
Mock <IDateTimeProvider> mockDateTimeProvider = new Mock <IDateTimeProvider>();
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 2000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
NetworkAddress activeNetworkAddressOne = new NetworkAddress(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
NetworkAddress activeNetworkAddressTwo = new NetworkAddress(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
NetworkAddress activeNetworkAddressThree = new NetworkAddress(activeIpAddressThree, 80);
IPAddress activeIpAddressFour = IPAddress.Parse("::ffff:192.168.0.4");
NetworkAddress activeNetworkAddressFour = new NetworkAddress(activeIpAddressFour, 80);
List <Tuple <NetworkAddress, DateTimeOffset> > testDataSet = new List <Tuple <NetworkAddress, DateTimeOffset> >()
{
new Tuple <NetworkAddress, DateTimeOffset> (activeNetworkAddressOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressFour, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40))
};
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(testDataSet);
IMasterFile spiedMasterFile = null;
Mock <IDnsServer> mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
NodeSettings nodeSettings = NodeSettings.Default();
DnsSettings dnsSettings = new Mock <DnsSettings>().Object;
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
WhitelistManager whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
Question question = new Question(new Domain(dnsSettings.DnsHostName), RecordType.AAAA);
IList <IResourceRecord> resourceRecords = spiedMasterFile.Get(question);
resourceRecords.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords = resourceRecords.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords.Should().HaveSameCount(testDataSet);
foreach (Tuple <NetworkAddress, DateTimeOffset> testData in testDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Endpoint.Address)).Should().NotBeNull();
}
}
public void WhenRefreshWhitelist_AndInactivePeersInWhitelist_ThenWhitelistDoesNotContainInactivePeers()
{
// Arrange.
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockLogger = new Mock <ILogger>();
var mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 3000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var activeEndpointOne = new IPEndPoint(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var activeEndpointTwo = new IPEndPoint(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var activeEndpointThree = new IPEndPoint(activeIpAddressThree, 80);
IPAddress activeIpAddressFour = IPAddress.Parse("::ffff:192.168.0.4");
var activeEndpointFour = new IPEndPoint(activeIpAddressFour, 80);
var activeTestDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset> (activeEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointFour, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40))
};
IPAddress inactiveIpAddressOne = IPAddress.Parse("::ffff:192.168.100.1");
var inactiveEndpointOne = new IPEndPoint(inactiveIpAddressOne, 80);
IPAddress inactiveIpAddressTwo = IPAddress.Parse("::ffff:192.168.100.2");
var inactiveEndpointTwo = new IPEndPoint(inactiveIpAddressTwo, 80);
IPAddress inactiveIpAddressThree = IPAddress.Parse("::ffff:192.168.100.3");
var inactiveEndpointThree = new IPEndPoint(inactiveIpAddressThree, 80);
var inactiveTestDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset> (inactiveEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(-10)),
new Tuple <IPEndPoint, DateTimeOffset>(inactiveEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(-20)),
new Tuple <IPEndPoint, DateTimeOffset>(inactiveEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(-30))
};
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(activeTestDataSet.Concat(inactiveTestDataSet).ToList());
IMasterFile spiedMasterFile = null;
var mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
NodeSettings nodeSettings = NodeSettings.Default(this.Network);
DnsSettings dnsSettings = new DnsSettings(NodeSettings.Default(this.Network));
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings(nodeSettings);
var whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings, this.peerBanning);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
var question = new Question(new Domain(dnsSettings.DnsHostName), RecordType.A);
IList <IResourceRecord> resourceRecords = spiedMasterFile.Get(question);
resourceRecords.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords = resourceRecords.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords.Should().HaveSameCount(activeTestDataSet);
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in activeTestDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().NotBeNull("the ip address is active and should be in DNS");
}
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in inactiveTestDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().BeNull("the ip address is inactive and should not be returned from DNS");
}
}
public static ConsensusManager CreateConsensusManager(
Network network,
string dataDir = null,
ChainState chainState = null,
InMemoryCoinView inMemoryCoinView = null,
ChainIndexer chainIndexer = null,
ConsensusRuleEngine consensusRules = null)
{
string[] param = dataDir == null ? new string[] { } : new string[] { $"-datadir={dataDir}" };
var nodeSettings = new NodeSettings(network, args: param);
ILoggerFactory loggerFactory = nodeSettings.LoggerFactory;
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
var signals = new Signals.Signals(loggerFactory, null);
var asyncProvider = new AsyncProvider(loggerFactory, signals, new Mock <INodeLifetime>().Object);
network.Consensus.Options = new ConsensusOptions();
// Dont check PoW of a header in this test.
network.Consensus.ConsensusRules.HeaderValidationRules.RemoveAll(x => x == typeof(CheckDifficultyPowRule));
var consensusSettings = new ConsensusSettings(nodeSettings);
if (chainIndexer == null)
{
chainIndexer = new ChainIndexer(network);
}
if (inMemoryCoinView == null)
{
inMemoryCoinView = new InMemoryCoinView(chainIndexer.Tip.HashBlock);
}
var connectionManagerSettings = new ConnectionManagerSettings(nodeSettings);
var networkPeerFactory = new NetworkPeerFactory(network,
dateTimeProvider,
loggerFactory, new PayloadProvider().DiscoverPayloads(),
new SelfEndpointTracker(loggerFactory, connectionManagerSettings),
new Mock <IInitialBlockDownloadState>().Object,
connectionManagerSettings,
asyncProvider);
var connectionSettings = new ConnectionManagerSettings(nodeSettings);
var selfEndpointTracker = new SelfEndpointTracker(loggerFactory, connectionSettings);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, selfEndpointTracker);
var peerDiscovery = new PeerDiscovery(asyncProvider, loggerFactory, network, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager);
var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, network, networkPeerFactory, nodeSettings,
new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { },
peerDiscovery, selfEndpointTracker, connectionSettings, new VersionProvider(), new Mock <INodeStats>().Object, asyncProvider);
if (chainState == null)
{
chainState = new ChainState();
}
var peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager);
var deployments = new NodeDeployments(network, chainIndexer);
if (consensusRules == null)
{
consensusRules = new PowConsensusRuleEngine(network, loggerFactory, dateTimeProvider, chainIndexer, deployments, consensusSettings,
new Checkpoints(), inMemoryCoinView, chainState, new InvalidBlockHashStore(dateTimeProvider), new NodeStats(dateTimeProvider, loggerFactory), asyncProvider, new ConsensusRulesContainer()).SetupRulesEngineParent();
}
var tree = new ChainedHeaderTree(network, loggerFactory, new HeaderValidator(consensusRules, loggerFactory), new Checkpoints(),
new ChainState(), new Mock <IFinalizedBlockInfoRepository>().Object, consensusSettings, new InvalidBlockHashStore(new DateTimeProvider()));
var consensus = new ConsensusManager(tree, network, loggerFactory, chainState, new IntegrityValidator(consensusRules, loggerFactory),
new PartialValidator(asyncProvider, consensusRules, loggerFactory), new FullValidator(consensusRules, loggerFactory), consensusRules,
new Mock <IFinalizedBlockInfoRepository>().Object, new Signals.Signals(loggerFactory, null), peerBanning, new Mock <IInitialBlockDownloadState>().Object, chainIndexer,
new Mock <IBlockPuller>().Object, new Mock <IBlockStore>().Object, new Mock <IConnectionManager>().Object, new Mock <INodeStats>().Object, new NodeLifetime(), consensusSettings, dateTimeProvider);
return(consensus);
}
