internal static IPrivateKeyProvider Create(
IPublicKeyDataProvider publicKeyDataProvider,
TimeSpan keyLifetime,
TimeSpan keyRotationPeriod,
IDateTimeProvider dateTimeProvider = null
) {
if( keyLifetime < keyRotationPeriod ) {
throw new ArgumentException( "Private key lifetime must exceed the rotation period", "keyLifetime" );
}
dateTimeProvider = dateTimeProvider ?? new DateTimeProvider();
ID2LSecurityTokenFactory d2lSecurityTokenFactory = new D2LSecurityTokenFactory(
dateTimeProvider,
keyLifetime
);
IPrivateKeyProvider privateKeyProvider = new RsaPrivateKeyProvider(
d2lSecurityTokenFactory
);
privateKeyProvider = new SavingPrivateKeyProvider(
privateKeyProvider,
PublicKeyDataProviderFactory.CreateInternal( publicKeyDataProvider )
);
privateKeyProvider = new RotatingPrivateKeyProvider(
privateKeyProvider,
dateTimeProvider,
keyRotationPeriod
);
return privateKeyProvider;
}
public BatchCodelineRequestMapHelper(
IDateTimeProvider dateTimeProvider,
IAdapterConfiguration adapterConfiguration)
{
this.dateTimeProvider = dateTimeProvider;
this.adapterConfiguration = adapterConfiguration;
}
public DirectoryChangeWatcher(IFileSystem fileSystem, IDateTimeProvider dateTimeProvider) {
_fileSystem = fileSystem;
_dateTimeProvider = dateTimeProvider;
_simplePathChangesPolling = new PollingDelayPolicy(dateTimeProvider, TimeSpan.FromSeconds(2.0), TimeSpan.FromSeconds(10.0));
_pathChangesPolling = new PollingDelayPolicy(dateTimeProvider, TimeSpan.FromSeconds(2.0), TimeSpan.FromSeconds(60.0));
_checkRootsPolling = new PollingDelayPolicy(dateTimeProvider, TimeSpan.FromSeconds(15.0), TimeSpan.FromSeconds(60.0));
}
private OverrideDateTimeProvider(StaticDateTimeProvider staticProvider)
{
_staticProvider = staticProvider;
_originalProvider = DateTimeProvider.Provider;
DateTimeProvider.Provider = _staticProvider;
}
public CssStatsStorageService(IStorageService storageService, IDateTimeProvider dateTimeProvider, IHumanInterface ux, ICssStatsFileNameEvaluator cssStatsFileNameEvaluator)
{
CssStatsFileNameEvaluator = cssStatsFileNameEvaluator;
Ux = ux;
DateTimeProvider = dateTimeProvider;
StorageService = storageService;
}
public GenerateCorrespondingVoucherRequestMapHelper(
IDateTimeProvider dateTimeProvider,
IAdapterConfiguration adapterConfiguration)
{
this.dateTimeProvider = dateTimeProvider;
this.adapterConfiguration = adapterConfiguration;
}
public SingleNodeConnectionPool(Uri uri, IDateTimeProvider dateTimeProvider = null)
{
var node = new Node(uri);
this.UsingSsl = node.Uri.Scheme == Uri.UriSchemeHttps;
this.Nodes = new List<Node> { node };
this.LastUpdate = (dateTimeProvider ?? DateTimeProvider.Default).Now();
}
public WashClothesService(IWashSessionFactory washSessionFactory, IWashSessionRepository washSessionRepository,
IDateTimeProvider dateTimeProvider)
{
_washSessionFactory = washSessionFactory;
_washSessionRepository = washSessionRepository;
_dateTimeProvider = dateTimeProvider;
}
public void SetDateTimeProvider(IDateTimeProvider dateTimeProvider)
{
if (dateTimeProvider == null)
throw new ArgumentNullException("dateTimeProvider");
CallContext.LogicalSetData(s_dateTimeProviderKey, dateTimeProvider);
}
public SniffingConnectionPool(
IEnumerable<Uri> uris,
bool randomizeOnStartup = true,
IDateTimeProvider dateTimeProvider = null)
: base(uris, randomizeOnStartup, dateTimeProvider)
{
}
public D2LSecurityTokenFactory(
IDateTimeProvider dateTimeProvider,
TimeSpan keyLifetime
) {
m_dateTimeProvider = dateTimeProvider;
m_keyLifetime = keyLifetime;
}
public GenerateBulkCreditRequestMapHelper(
IDateTimeProvider dateTimeProvider,
IAdapterConfiguration adapterConfiguration)
{
this.dateTimeProvider = dateTimeProvider;
this.adapterConfiguration = adapterConfiguration;
}
public BatchCheckThirdPartyRequestMapHelper(
IDateTimeProvider dateTimeProvider,
IAdapterConfiguration adapterConfiguration)
{
this.dateTimeProvider = dateTimeProvider;
this.adapterConfiguration = adapterConfiguration;
}
internal LoggedReliableOutboundChannel(IModel model,
EnvironmentConfiguration configuration,
IDateTimeProvider dateTimeProvider,
NotConfirmedMessageHandler notConfirmedMessageHandler) // TODO: check if I can access this by EnvironmentConfiguration
: base(model, configuration, dateTimeProvider, notConfirmedMessageHandler)
{
}
public WearOutfitService(IOutfitFactory outfitFactory, IOutfitRepository outfitRepository,
IDateTimeProvider dateTimeProvider)
{
_outfitFactory = outfitFactory;
_outfitRepository = outfitRepository;
_dateTimeProvider = dateTimeProvider;
}
public JavaScriptStatsStorageService(IStorageService storageService, IDateTimeProvider dateTimeProvider, IHumanInterface ux, IRelevantAttributesEvaluator relevantAttributesEvaluator, IJavaScriptStatsFileNameEvaluator javaScriptStatsFileNameEvaluator)
{
JavaScriptStatsFileNameEvaluator = javaScriptStatsFileNameEvaluator;
StorageService = storageService;
DateTimeProvider = dateTimeProvider;
Ux = ux;
RelevantAttributesEvaluator = relevantAttributesEvaluator;
}
public HttpResponseCacher(IDateTimeProvider dateTimeProvider)
{
if (dateTimeProvider == null)
{
throw new ArgumentNullException("dateTimeProvider");
}
m_DateTimeProvider = dateTimeProvider;
}
public FixedPipelineFactory(IConnectionSettingsValues connectionSettings, IDateTimeProvider dateTimeProvider)
{
this.DateTimeProvider = dateTimeProvider;
this.MemoryStreamFactory = new MemoryStreamFactory();
this.Settings = connectionSettings;
this.Pipeline = this.Create(this.Settings, this.DateTimeProvider, this.MemoryStreamFactory, new SearchRequestParameters());
}
public Auditable(AuditEvent type, List<Audit> auditTrail, IDateTimeProvider dateTimeProvider)
{
this._dateTimeProvider = dateTimeProvider;
var started = _dateTimeProvider.Now();
this._audit = new Audit(type, started);
auditTrail.Add(this._audit);
}
public UserService(INoSqlDb db, IHistoryService history, IImageService image, ILogger logger, IDateTimeProvider dtp)
{
_db = db;
_history = history;
_image = image;
_logger = logger;
_dtp = dtp;
}
public FileNameCreator(IDateTimeProvider dateTimeProvider, IOutboundConfiguration configuration)
{
this.dateTimeProvider = dateTimeProvider;
sendingOrganisation = configuration.CoinSendingOrganisation;
environment = configuration.Environment;
}
private IRequestPipeline CreatePipeline(
Func<IEnumerable<Uri>, IConnectionPool> setupPool, Func<ConnectionSettings, ConnectionSettings> settingsSelector = null, IDateTimeProvider dateTimeProvider = null)
{
var pool = setupPool(new[] { TestClient.CreateNode(), TestClient.CreateNode(9201) });
var settings = new ConnectionSettings(pool, TestClient.CreateConnection());
settings = settingsSelector?.Invoke(settings) ?? settings;
return new FixedPipelineFactory(settings, dateTimeProvider ?? DateTimeProvider.Default).Pipeline;
}
public FreshnessRepositoryFilter(IDateTimeProvider dateTimeProvider, int freshnessInMinutes)
{
if (dateTimeProvider == null)
throw new ArgumentNullException("dateTimeProvider");
this.dateTimeProvider = dateTimeProvider;
this.freshnessInMinutes = freshnessInMinutes;
}
public WeatherGrabberBusinessService(IRepository<WeatherInfo> weatherInfoRepository,
IDateTimeProvider dateTimeProvider,
IWeatherServiceAggregator weatherWeatherServiceAggregator)
{
_weatherInfoRepository = weatherInfoRepository;
_dateTimeProvider = dateTimeProvider;
_weatherWeatherServiceAggregator = weatherWeatherServiceAggregator;
_cache = new ConcurrentDictionary<string, WeatherInfo>();
}
public AppContextBootstrapper(IDateTimeProvider dateTimeProvider)
{
if (dateTimeProvider == null)
throw new ArgumentNullException("DefaultDateTimeProvider");
SetDateTimeProvider(dateTimeProvider);
AppContext.SetContextService(this);
}
public User(IDateTimeProvider dateTimeProvider, PersonalDetails personalDetails, PostalAddress postalAddress, Password password)
{
CreatedDate = dateTimeProvider.Now();
LastModifiedDate = dateTimeProvider.Now();
PersonalDetails = personalDetails.OrThrowIfMissing("personalDetails");
PostalAddress = postalAddress.OrThrowIfMissing("postalAddress");
Password = password.OrThrowIfMissing("password");
Active = true;
}
public override void Setup()
{
ContainerBuilder = new ContainerBuilder();
_dateTimeProvider = Substitute.For<IDateTimeProvider>();
_pingRepository = Substitute.For<IPingRepository>();
ContainerBuilder.Register(c => _dateTimeProvider);
ContainerBuilder.Register(c => _pingRepository);
base.Setup();
}
public void Setup()
{
// dependencies
_datetimeProvider = Substitute.For<IDateTimeProvider>();
_issuesRepository = Substitute.For<IIssuesRepository>();
// system under test
_controller = new IssuesController(_issuesRepository, _datetimeProvider);
}
public RotatingPrivateKeyProvider(
IPrivateKeyProvider inner,
IDateTimeProvider dateTimeProvider,
TimeSpan keyRotationPeriod
) {
m_inner = inner;
m_dateTimeProvider = dateTimeProvider;
m_keyRotationPeriod = keyRotationPeriod;
}
public AuthenticationService(
IEntitiesContext entities, IAppConfiguration config, IDiagnosticsService diagnostics,
AuditingService auditing, IEnumerable<Authenticator> providers, ICredentialBuilder credentialBuilder,
ICredentialValidator credentialValidator, IDateTimeProvider dateTimeProvider)
{
if (entities == null)
{
throw new ArgumentNullException(nameof(entities));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (diagnostics == null)
{
throw new ArgumentNullException(nameof(diagnostics));
}
if (auditing == null)
{
throw new ArgumentNullException(nameof(auditing));
}
if (providers == null)
{
throw new ArgumentNullException(nameof(providers));
}
if (credentialBuilder == null)
{
throw new ArgumentNullException(nameof(credentialBuilder));
}
if (credentialValidator == null)
{
throw new ArgumentNullException(nameof(credentialValidator));
}
if (dateTimeProvider == null)
{
throw new ArgumentNullException(nameof(dateTimeProvider));
}
InitCredentialFormatters();
Entities = entities;
_config = config;
Auditing = auditing;
_trace = diagnostics.SafeGetSource("AuthenticationService");
Authenticators = providers.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
_credentialBuilder = credentialBuilder;
_credentialValidator = credentialValidator;
_dateTimeProvider = dateTimeProvider;
}
public CachingProjectFileResolver(IProjectFileResolver projectFileResolver,
IDateTimeProvider dateTimeProvider, TimeSpan cacheTimeSpan)
: base(dateTimeProvider, cacheTimeSpan)
{
_projectFileResolver = projectFileResolver ?? throw new ArgumentNullException(nameof(projectFileResolver));
}
public void UpdateFromExisting(Session existingSession, IDateTimeProvider dateTimeProvider)
{
Id = existingSession.Id;
CreatedDate = existingSession.CreatedDate;
ModifiedDate = dateTimeProvider.Now();
}
public TweetTagService(IUnitOfWork unitOfWork, ITagService tagService, IDateTimeProvider dateTimeProvider)
{
this.unitOfWork = unitOfWork ?? throw new ArgumentNullException(nameof(unitOfWork));
this.tagService = tagService ?? throw new ArgumentNullException(nameof(tagService));
this.dateTimeProvider = dateTimeProvider ?? throw new ArgumentNullException(nameof(dateTimeProvider));
}
public RecurringJobRunPlaner(JobbrRepository repository, IDateTimeProvider dateTimeProvider)
{
this.jobbrRepository = repository;
this.dateTimeProvider = dateTimeProvider;
}
public AddRuleCommandHandler(IApplicationDbContext dbContext, IDateTimeProvider dateTimeProvider)
{
_dbContext = dbContext;
_dateTimeProvider = dateTimeProvider;
}
/// <summary>
/// Creates new instance of User repository
/// </summary>
/// <param name="provider">Uow provider</param>
/// <param name="dateTimeProvider">DateTime provider</param>
public UserRepository(IUnitOfWorkProvider provider, IDateTimeProvider dateTimeProvider) : base(provider, dateTimeProvider)
{
}
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.Main;
byte[] 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 ConsensusOptions();
this.network.Consensus.Rules = new FullNodeBuilderConsensusExtension.PowConsensusRulesRegistration().GetRules();
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
this.cachedCoinView = new CachedCoinView(new InMemoryCoinView(this.chain.Tip.HashBlock), dateTimeProvider, new LoggerFactory());
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());
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, new SelfEndpointTracker());
var peerDiscovery = new PeerDiscovery(new AsyncLoopFactory(loggerFactory), loggerFactory, this.network, networkPeerFactory, new NodeLifetime(), nodeSettings, peerAddressManager);
var connectionSettings = new ConnectionManagerSettings(nodeSettings);
var selfEndpointTracker = new SelfEndpointTracker();
var connectionManager = new ConnectionManager(dateTimeProvider, loggerFactory, this.network, networkPeerFactory, nodeSettings, new NodeLifetime(), new NetworkPeerConnectionParameters(), peerAddressManager, new IPeerConnector[] { }, peerDiscovery, selfEndpointTracker, connectionSettings, new VersionProvider());
var blockPuller = new LookaheadBlockPuller(this.chain, connectionManager, new LoggerFactory());
var peerBanning = new PeerBanning(connectionManager, loggerFactory, dateTimeProvider, peerAddressManager);
var deployments = new NodeDeployments(this.network, this.chain);
this.ConsensusRules = new PowConsensusRules(this.network, loggerFactory, dateTimeProvider, this.chain, deployments, consensusSettings, new Checkpoints(), this.cachedCoinView, blockPuller).Register();
this.consensus = new ConsensusLoop(new AsyncLoopFactory(loggerFactory), 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, this.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 PowRuleContext(new ValidationContext {
Block = this.newBlock.Block
}, this.network.Consensus, this.consensus.Tip, this.DateTimeProvider.GetTimeOffset()) { MinedBlock = true });
// 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>();
for (int i = 0; i < this.blockinfo.Count; ++i)
{
Block block = Block.Load(this.newBlock.Block.ToBytes(this.network.Consensus.ConsensusFactory), this.network);
block.Header.HashPrevBlock = this.chain.Tip.HashBlock;
block.Header.Version = 1;
block.Header.Time = Utils.DateTimeToUnixTime(this.chain.Tip.GetMedianTimePast()) + 1;
Transaction txCoinbase = this.network.CreateTransaction(block.Transactions[0].ToBytes());
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()));
block.Transactions[0] = txCoinbase;
if (this.txFirst.Count == 0)
{
this.baseheight = this.chain.Height;
}
if (this.txFirst.Count < 4)
{
this.txFirst.Add(block.Transactions[0]);
}
block.UpdateMerkleRoot();
block.Header.Nonce = this.blockinfo[i].nonce;
this.chain.SetTip(block.Header);
await this.consensus.ValidateAndExecuteBlockAsync(new PowRuleContext(new ValidationContext {
Block = block
}, this.network.Consensus, this.consensus.Tip, this.DateTimeProvider.GetTimeOffset()) { MinedBlock = true });
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 TokenGenerator(IHashGenerator hashGenerator, IDateTimeProvider dateTimeProvider)
{
_hashGenerator = hashGenerator ?? throw new ArgumentNullException(nameof(hashGenerator));
_dateTimeProvider = dateTimeProvider ?? throw new ArgumentNullException(nameof(dateTimeProvider));
}
public CrudService(IRepository <TEntity> repository, Expression <Func <TEntity, object> > idNameFactory = null, IDateTimeProvider dateTimeProvider = null)
{
_repository = repository;
_repoIdentityProperty = ReflectionHelper.TryGetIdProperty(idNameFactory);
_dataTimeProvider = dateTimeProvider ?? new DefaultDateTimeProvider();
}
public CocktailService(CocktailMagicianContext context, IDtoMapper <Cocktail, CocktailDto> cocktailDtoMapper, IDateTimeProvider provider, ICocktailIngredientService cocktailIngredientService, IIngredientService ingredientService)
{
this._context = context ?? throw new ArgumentNullException(nameof(context));
this._cocktailDtoMapper = cocktailDtoMapper ?? throw new ArgumentNullException(nameof(cocktailDtoMapper));
this._provider = provider ?? throw new ArgumentNullException(nameof(provider));
this._cocktailIngredientService = cocktailIngredientService ?? throw new ArgumentNullException(nameof(cocktailIngredientService));
this._ingredientService = ingredientService ?? throw new ArgumentNullException(nameof(ingredientService));
}
public BlockPullerBehavior(IBlockPuller blockPuller, IInitialBlockDownloadState ibdState, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory)
{
this.ibdState = ibdState;
this.dateTimeProvider = dateTimeProvider;
this.QualityScore = SamplelessQualityScore;
this.averageSizeBytes = new AverageCalculator(IbdSamplesCount);
this.averageDelaySeconds = new AverageCalculator(IbdSamplesCount);
this.SpeedBytesPerSecond = 0;
this.lastDeliveryTime = null;
this.blockPuller = blockPuller;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName, $"[{this.GetHashCode():x}] ");
this.loggerFactory = loggerFactory;
}
public TestConsensusRules(Network network, ILoggerFactory loggerFactory, IDateTimeProvider dateTimeProvider, ChainIndexer chainIndexer, NodeDeployments nodeDeployments,
ConsensusSettings consensusSettings, ICheckpoints checkpoints, IChainState chainState, IInvalidBlockHashStore invalidBlockHashStore, INodeStats nodeStats, ConsensusRulesContainer consensusRulesContainer)
: base(network, loggerFactory, dateTimeProvider, chainIndexer, nodeDeployments, consensusSettings, checkpoints, chainState, invalidBlockHashStore, nodeStats, consensusRulesContainer)
{
this.ruleRegistrationHelper = new RuleRegistrationHelper(this, consensusRulesContainer);
}
/// <summary>
/// Initializes a new instance of the <see cref="DnsSeedServer"/> class with the port to listen on.
/// </summary>
/// <param name="client">The UDP client to use to receive DNS requests and send DNS responses.</param>
/// <param name="masterFile">The initial DNS masterfile.</param>
/// <param name="asyncLoopFactory">The async loop factory.</param>
/// <param name="loggerFactory">The logger factory.</param>
/// <param name="dateTimeProvider">The <see cref="DateTime"/> provider.</param>
/// <param name="dataFolders">The data folders of the system.</param>
public DnsSeedServer(IUdpClient client, IMasterFile masterFile, IAsyncLoopFactory asyncLoopFactory, INodeLifetime nodeLifetime, ILoggerFactory loggerFactory, IDateTimeProvider dateTimeProvider, DnsSettings dnsSettings, DataFolder dataFolders)
{
Guard.NotNull(client, nameof(client));
Guard.NotNull(masterFile, nameof(masterFile));
Guard.NotNull(asyncLoopFactory, nameof(asyncLoopFactory));
Guard.NotNull(nodeLifetime, nameof(nodeLifetime));
Guard.NotNull(loggerFactory, nameof(loggerFactory));
Guard.NotNull(dateTimeProvider, nameof(dateTimeProvider));
Guard.NotNull(dnsSettings, nameof(dnsSettings));
Guard.NotNull(dataFolders, nameof(dataFolders));
this.udpClient = client;
this.masterFile = masterFile;
this.asyncLoopFactory = asyncLoopFactory;
this.nodeLifetime = nodeLifetime;
this.logger = loggerFactory.CreateLogger(this.GetType().FullName);
this.dateTimeProvider = dateTimeProvider;
this.dnsSettings = dnsSettings;
this.dataFolders = dataFolders;
this.metrics = new DnsMetric();
}
/// <summary>
/// Initializes an instance of the object.
/// </summary>
public PosConsensusRules(Network network, ILoggerFactory loggerFactory, IDateTimeProvider dateTimeProvider, ConcurrentChain chain, NodeDeployments nodeDeployments, ConsensusSettings consensusSettings, ICheckpoints checkpoints, IStakeChain stakeChain, IStakeValidator stakeValidator)
: base(network, loggerFactory, dateTimeProvider, chain, nodeDeployments, consensusSettings, checkpoints)
{
this.StakeChain = stakeChain;
this.StakeValidator = stakeValidator;
}
public InnerPlayerControl(Game game, ILogger <InnerPlayerControl> logger, IServiceProvider serviceProvider, IEventManager eventManager, IDateTimeProvider dateTimeProvider) : base(game)
{
_logger = logger;
_eventManager = eventManager;
_dateTimeProvider = dateTimeProvider;
Physics = ActivatorUtilities.CreateInstance <InnerPlayerPhysics>(serviceProvider, this, _eventManager, game);
NetworkTransform = ActivatorUtilities.CreateInstance <InnerCustomNetworkTransform>(serviceProvider, this, game);
Components.Add(this);
Components.Add(Physics);
Components.Add(NetworkTransform);
PlayerId = byte.MaxValue;
}
public FasterCoindb(Network network, DataFolder dataFolder, IDateTimeProvider dateTimeProvider, ILoggerFactory loggerFactory, INodeStats nodeStats, DBreezeSerializer dBreezeSerializer)
: this(network, dataFolder.CoindbPath, dateTimeProvider, loggerFactory, nodeStats, dBreezeSerializer)
{
}
/// <summary>
/// Creates a proof of work block assembler.
/// </summary>
/// <param name="network">Network running on.</param>
/// <param name="consensusLoop">Consensus loop.</param>
/// <param name="chain">Block chain.</param>
/// <param name="mempoolLock">Async lock for memory pool.</param>
/// <param name="mempool">Memory pool for transactions.</param>
/// <param name="consensusRules">The rules.</param>
/// <param name="dateTimeProvider">Date and time provider.</param>
/// <returns>Proof of work block assembler.</returns>
private static PowBlockDefinition CreatePowBlockAssembler(IConsensusLoop consensusLoop, IConsensusRules consensusRules, IDateTimeProvider dateTimeProvider, LoggerFactory loggerFactory, TxMempool mempool, MempoolSchedulerLock mempoolLock, Network network)
{
var options = new BlockDefinitionOptions
{
BlockMaxWeight = network.Consensus.Option <PowConsensusOptions>().MaxBlockWeight,
BlockMaxSize = network.Consensus.Option <PowConsensusOptions>().MaxBlockSerializedSize
};
var blockMinFeeRate = new FeeRate(PowMining.DefaultBlockMinTxFee);
options.BlockMinFeeRate = blockMinFeeRate;
return(new PowBlockDefinition(consensusLoop, dateTimeProvider, loggerFactory, mempool, mempoolLock, network, consensusRules, options));
}
public TaskQueue(string description, ICustomThreadPool customThreadPool, IDateTimeProvider dateTimeProvider)
{
_description = description;
_customThreadPool = customThreadPool;
_dateTimeProvider = dateTimeProvider;
}
public WorkflowExecutor(IWorkflowRegistry registry, IServiceProvider serviceProvider, IScopeProvider scopeProvider, IDateTimeProvider datetimeProvider, IExecutionResultProcessor executionResultProcessor, ILifeCycleEventPublisher publisher, ICancellationProcessor cancellationProcessor, WorkflowOptions options, ILoggerFactory loggerFactory)
{
_serviceProvider = serviceProvider;
_scopeProvider = scopeProvider;
_registry = registry;
_datetimeProvider = datetimeProvider;
_publisher = publisher;
_cancellationProcessor = cancellationProcessor;
_options = options;
_logger = loggerFactory.CreateLogger <WorkflowExecutor>();
_executionResultProcessor = executionResultProcessor;
}
public EmailMessageRepository(NotificationDbContext dbContext,
IDateTimeProvider dateTimeProvider)
: base(dbContext, dateTimeProvider)
{
}
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");
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;
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();
// Check for A records (IPv4 embedded in IPv6 and IPv4 addresses).
Question 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).
Question 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 MempoolManager CreateTestMempool(NodeSettings settings, out TxMempool txMemPool)
{
var mempoolSettings = new MempoolSettings(settings);
IDateTimeProvider dateTimeProvider = DateTimeProvider.Default;
NodeSettings nodeSettings = NodeSettings.Default(settings.Network);
ILoggerFactory loggerFactory = nodeSettings.LoggerFactory;
var consensusSettings = new ConsensusSettings(nodeSettings);
txMemPool = new TxMempool(dateTimeProvider, new BlockPolicyEstimator(mempoolSettings, loggerFactory, nodeSettings), loggerFactory, nodeSettings);
var mempoolLock = new MempoolSchedulerLock();
var coins = new InMemoryCoinView(new HashHeightPair(settings.Network.GenesisHash, 0));
var chain = new ChainIndexer(settings.Network);
var deployments = new NodeDeployments(this.network, chain);
var chainState = new ChainState();
var mempoolPersistence = new MempoolPersistence(settings, loggerFactory);
this.network.Consensus.Options = new PosConsensusOptions();
var consensusRulesContainer = new ConsensusRulesContainer();
foreach (var ruleType in this.network.Consensus.ConsensusRules.HeaderValidationRules)
{
consensusRulesContainer.HeaderValidationRules.Add(Activator.CreateInstance(ruleType) as HeaderValidationConsensusRule);
}
foreach (var ruleType in this.network.Consensus.ConsensusRules.FullValidationRules)
{
FullValidationConsensusRule rule = null;
if (ruleType == typeof(FlushUtxosetRule))
{
rule = new FlushUtxosetRule(new Mock <IInitialBlockDownloadState>().Object);
}
else
{
rule = Activator.CreateInstance(ruleType) as FullValidationConsensusRule;
}
consensusRulesContainer.FullValidationRules.Add(rule);
}
var asyncProvider = new AsyncProvider(nodeSettings.LoggerFactory, new Mock <ISignals>().Object, new NodeLifetime());
ConsensusRuleEngine consensusRules = new PowConsensusRuleEngine(this.network, loggerFactory, dateTimeProvider, chain, deployments,
consensusSettings, new Checkpoints(), coins, chainState, new InvalidBlockHashStore(dateTimeProvider), new NodeStats(dateTimeProvider, loggerFactory), asyncProvider, consensusRulesContainer).SetupRulesEngineParent();
// The mempool rule constructors aren't parameterless, so we have to manually inject the dependencies for every rule
var mempoolRules = new List <MempoolRule>
{
new CheckConflictsMempoolRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
new CheckCoinViewMempoolRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
new CreateMempoolEntryMempoolRule(this.network, txMemPool, mempoolSettings, chain, consensusRules, loggerFactory),
new CheckSigOpsMempoolRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
new CheckFeeMempoolRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
new CheckRateLimitMempoolRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
new CheckAncestorsMempoolRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
new CheckReplacementMempoolRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
new CheckAllInputsMempoolRule(this.network, txMemPool, mempoolSettings, chain, consensusRules, deployments, loggerFactory),
new CheckTxOutDustRule(this.network, txMemPool, mempoolSettings, chain, loggerFactory),
};
// We also have to check that the manually instantiated rules match the ones in the network, or the test isn't valid
for (int i = 0; i < this.network.Consensus.MempoolRules.Count; i++)
{
if (this.network.Consensus.MempoolRules[i] != mempoolRules[i].GetType())
{
throw new Exception("Mempool rule type mismatch");
}
}
var mempoolValidator = new MempoolValidator(txMemPool, mempoolLock, dateTimeProvider, mempoolSettings, chain, coins, loggerFactory, settings, consensusRules, mempoolRules, deployments);
return(new MempoolManager(mempoolLock, txMemPool, mempoolValidator, dateTimeProvider, mempoolSettings, mempoolPersistence, coins, loggerFactory, settings.Network));
}
public InitialTestDataConfiguration(IDependencyManager dependencyManager, IDateTimeProvider dateTimeProvider)
{
if (dependencyManager == null)
{
throw new ArgumentNullException(nameof(dependencyManager));
}
if (dateTimeProvider == null)
{
throw new ArgumentNullException(nameof(dateTimeProvider));
}
_dependencyManager = dependencyManager;
var dateTimeProvider1 = dateTimeProvider;
_parentEntities = new List <ParentEntity>
{
new ParentEntity
{
Name = "A",
Version = 1,
Date = dateTimeProvider1.GetCurrentUtcDateTime(),
ChildEntities = new List <ChildEntity>
{
new ChildEntity {
Name = "a1", Version = 7
},
new ChildEntity {
Name = "a2", Version = 8
},
new ChildEntity {
Name = "a3", Version = 9
}
}
},
new ParentEntity
{
Name = "B",
Version = 2,
Date = dateTimeProvider1.GetCurrentUtcDateTime(),
ChildEntities = new List <ChildEntity>
{
new ChildEntity {
Name = "b1", Version = 4
},
new ChildEntity {
Name = "b2", Version = 5
},
new ChildEntity {
Name = "b3", Version = 6
}
}
},
new ParentEntity
{
Name = "C",
Version = 3,
Date = dateTimeProvider1.GetCurrentUtcDateTime(),
ChildEntities = new List <ChildEntity>
{
new ChildEntity {
Name = "c1", Version = 1
},
new ChildEntity {
Name = "c2", Version = 2
},
new ChildEntity {
Name = "c3", Version = 3
}
}
}
};
}
public void WhenRefreshWhitelist_AndOwnIPInPeers_AndAreRunningFullNode_ThenWhitelistDoesContainOwnIP()
{
// 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");
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);
string[] args = new string[] {
$"-dnspeeractivethreshold={inactiveTimePeriod.ToString()}",
$"-externalip={externalEndpoint.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, args: args);
DnsSettings dnsSettings = new Mock <DnsSettings>().Object;
dnsSettings.DnsFullNode = true;
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.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 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(new HashHeightPair(chainIndexer.Tip));
}
var connectionManagerSettings = new ConnectionManagerSettings(nodeSettings);
var connectionSettings = new ConnectionManagerSettings(nodeSettings);
var selfEndpointTracker = new SelfEndpointTracker(loggerFactory, connectionSettings);
var peerAddressManager = new PeerAddressManager(DateTimeProvider.Default, nodeSettings.DataFolder, loggerFactory, selfEndpointTracker);
var networkPeerFactory = new NetworkPeerFactory(network,
dateTimeProvider,
loggerFactory, new PayloadProvider().DiscoverPayloads(),
new SelfEndpointTracker(loggerFactory, connectionManagerSettings),
new Mock <IInitialBlockDownloadState>().Object,
connectionManagerSettings,
asyncProvider,
peerAddressManager);
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);
}
public void WhenRefreshWhitelist_AndInactivePeersInWhitelist_ThenWhitelistDoesNotContainInactivePeers()
{
// 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 = 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;
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.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 Repository(ConfigurationDbContext dbContext, IDateTimeProvider dateTimeProvider)
{
_dbContext = dbContext;
_dateTimeProvider = dateTimeProvider;
}
public WorkflowConsumer(IPooledObjectPolicy <IPersistenceProvider> persistencePoolPolicy, IQueueProvider queueProvider, ILoggerFactory loggerFactory, IServiceProvider serviceProvider, IWorkflowRegistry registry, IDistributedLockProvider lockProvider, IPooledObjectPolicy <IWorkflowExecutor> executorPoolPolicy, IDateTimeProvider datetimeProvider, WorkflowOptions options)
: base(queueProvider, loggerFactory, options)
{
_persistenceStorePool = new DefaultObjectPool <IPersistenceProvider>(persistencePoolPolicy);
_executorPool = new DefaultObjectPool <IWorkflowExecutor>(executorPoolPolicy);
_lockProvider = lockProvider;
_datetimeProvider = datetimeProvider;
}
/// <summary>
/// Initializes a default instance of the object.
/// </summary>
static DateTimeProvider()
{
Default = new DateTimeProvider();
}
/// <summary>
/// Initializes an instance of the object.
/// </summary>
public PowConsensusRules(Network network, ILoggerFactory loggerFactory, IDateTimeProvider dateTimeProvider, ConcurrentChain chain, NodeDeployments nodeDeployments, ConsensusSettings consensusSettings, ICheckpoints checkpoints)
: base(network, loggerFactory, dateTimeProvider, chain, nodeDeployments, consensusSettings, checkpoints)
{
}
