/// <summary> /// Initializes a new instance of the <see cref="MongoBuilder"/> class. /// </summary> public MongoBuilder(ILogger <MongoBuilder> logger, IStorage data, IOptions <IndexerSettings> nakoConfiguration) : base(logger) { log = logger; mongoData = (MongoData)data; configuration = nakoConfiguration.Value; }
public MongoStorageOperations(IStorage storage, IOptions <IndexerSettings> configuration, SyncConnection syncConnection) { data = (MongoData)storage; this.configuration = configuration.Value; this.storage = storage; this.syncConnection = syncConnection; }
/// <summary> /// Initializes a new instance of the <see cref="SyncConnection"/> class. /// </summary> public SyncConnection(IOptions <IndexerSettings> config, IOptions <ChainSettings> chainConfig, IOptions <NetworkSettings> networkConfig) { IndexerSettings configuration = config.Value; ChainSettings chainConfiguration = chainConfig.Value; NetworkSettings networkConfiguration = networkConfig.Value; Symbol = chainConfiguration.Symbol; Password = configuration.RpcPassword; // Take the RPC Port from the Indexer configuration, if it is specified. Otherwise we'll use the default for this chain. RpcAccessPort = configuration.RpcAccessPort != 0 ? configuration.RpcAccessPort : networkConfiguration.RPCPort; ApiAccessPort = networkConfiguration.APIPort; ServerDomain = configuration.RpcDomain.Replace("{Symbol}", chainConfiguration.Symbol.ToLower()); User = configuration.RpcUser; Secure = configuration.RpcSecure; if (string.IsNullOrWhiteSpace(networkConfiguration.NetworkType)) { Network = new NetworkConfig(configuration, chainConfiguration, networkConfiguration); HasNetworkType = false; } else { Network = (Network)Activator.CreateInstance(Type.GetType(networkConfiguration.NetworkType)); HasNetworkType = true; } RecentItems = new Buffer <(DateTime Inserted, TimeSpan Duration, long Size)>(5000); }
private void SetDefaultSettings() { if (Program.DefaultTaskSettings != null) { TaskSettings defaultTaskSettings = Program.DefaultTaskSettings.Copy(); if (UseDefaultAfterCaptureJob) { AfterCaptureJob = defaultTaskSettings.AfterCaptureJob; } if (UseDefaultAfterUploadJob) { AfterUploadJob = defaultTaskSettings.AfterUploadJob; } if (UseDefaultDestinations) { ImageDestination = defaultTaskSettings.ImageDestination; TextDestination = defaultTaskSettings.TextDestination; FileDestination = defaultTaskSettings.FileDestination; URLShortenerDestination = defaultTaskSettings.URLShortenerDestination; SocialNetworkingServiceDestination = defaultTaskSettings.SocialNetworkingServiceDestination; } if (UseDefaultGeneralSettings) { GeneralSettings = defaultTaskSettings.GeneralSettings; } if (UseDefaultImageSettings) { ImageSettings = defaultTaskSettings.ImageSettings; } if (UseDefaultCaptureSettings) { CaptureSettings = defaultTaskSettings.CaptureSettings; } if (UseDefaultUploadSettings) { UploadSettings = defaultTaskSettings.UploadSettings; } if (UseDefaultActions) { ExternalPrograms = defaultTaskSettings.ExternalPrograms; } if (UseDefaultIndexerSettings) { IndexerSettings = defaultTaskSettings.IndexerSettings; } if (UseDefaultAdvancedSettings) { AdvancedSettings = defaultTaskSettings.AdvancedSettings; } } }
/// <summary> /// Initializes a new instance of the <see cref="SyncServer"/> class. /// </summary> public SyncServer(ILogger <SyncServer> logger, IOptions <IndexerSettings> configuration, IOptions <ChainSettings> chainConfiguration, IServiceScopeFactory scopeFactory) { log = logger; this.configuration = configuration.Value; this.chainConfiguration = chainConfiguration.Value; this.scopeFactory = scopeFactory; }
/// <summary> /// Initializes a new instance of the <see cref="StatsHandler"/> class. /// </summary> public StatsHandler(SyncConnection connection, IStorage storage, IOptions <IndexerSettings> configuration, IOptions <ChainSettings> chainConfiguration) { this.storage = storage; syncConnection = connection; this.configuration = configuration.Value; this.chainConfiguration = chainConfiguration.Value; }
/// <summary> /// Initializes a new instance of the <see cref="MongoBuilder"/> class. /// </summary> public MongoBuilder(ILogger <MongoBuilder> logger, IMongoDb data, IOptions <IndexerSettings> nakoConfiguration, IOptions <ChainSettings> chainSettings) : base(logger) { log = logger; mongoDb = data; configuration = nakoConfiguration.Value; chainConfiguration = chainSettings.Value; }
protected IndexerTableTask( AzureStorageClient storageClient, IndexerSettings settings) : base(settings) { StorageClient = storageClient ?? throw new ArgumentNullException(nameof(storageClient)); _retry = Policy.Handle <StorageException>() .WaitAndRetryAsync(15, backoff => TimeSpan.FromSeconds(Math.Pow(2, backoff))); }
/// <summary> /// Initializes a new instance of the <see cref="BlockFinder"/> class. /// </summary> public BlockFinder(IOptions <IndexerSettings> configuration, ISyncOperations syncOperations, SyncConnection syncConnection, ILogger <BlockFinder> logger) : base(configuration, logger) { log = logger; this.syncConnection = syncConnection; this.syncOperations = syncOperations; config = configuration.Value; watch = Stopwatch.Start(); }
public CheckpointStore( IFullNode node, AzureStorageClient storageClient, IndexerSettings settings) { _network = node.Network; _storageClient = storageClient; _saveProgress = !settings.IgnoreCheckpoints; _cancellationToken = node.NodeLifetime.ApplicationStopping; }
public AddressTask( Network network, IBlockRepository blockRepository, AzureStorageClient storageClient, IndexerSettings settings) : base(storageClient, settings) { _network = network; _blockRepository = blockRepository; }
public AzureStorageClient( IFullNode node, IndexerSettings settings, ILoggerFactory loggerFactory) { Network = node.Network; _settings = settings; _logger = loggerFactory.CreateLogger <AzureStorageClient>(); SetStorageDefaults(); }
public NetworkConfig(IndexerSettings config, ChainSettings chainConfig, NetworkSettings networkConfig) { CoinTicker = chainConfig.Symbol; var consensusFactory = (ConsensusFactory)Activator.CreateInstance(Type.GetType(networkConfig.NetworkConsensusFactoryType)); Consensus = new Consensus.Consensus( consensusFactory: consensusFactory, consensusOptions: null, coinType: 0, hashGenesisBlock: uint256.Zero, subsidyHalvingInterval: 0, majorityEnforceBlockUpgrade: 0, majorityRejectBlockOutdated: 0, majorityWindow: 0, buriedDeployments: null, bip9Deployments: null, bip34Hash: uint256.Zero, minerConfirmationWindow: 0, maxReorgLength: 0, defaultAssumeValid: uint256.Zero, maxMoney: 0, coinbaseMaturity: 0, premineHeight: 0, premineReward: 0, proofOfWorkReward: 0, targetTimespan: TimeSpan.Zero, targetSpacing: TimeSpan.Zero, powAllowMinDifficultyBlocks: false, posNoRetargeting: false, powNoRetargeting: false, powLimit: new Target(uint256.Zero), minimumChainWork: null, isProofOfStake: consensusFactory is PosConsensusFactory, lastPowBlock: 0, proofOfStakeLimit: null, proofOfStakeLimitV2: null, proofOfStakeReward: 0, proofOfStakeTimestampMask: 0x0000003F // 64 sec ); Base58Prefixes = new byte[12][]; Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (networkConfig.NetworkPubkeyAddressPrefix) }; Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (networkConfig.NetworkScriptAddressPrefix) }; Bech32Encoders = new Bech32Encoder[2]; var encoder = new Bech32Encoder(networkConfig.NetworkWitnessPrefix); Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder; Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder; // TODO //StandardScripts.RegisterStandardScriptTemplate(ColdStakingScriptTemplate); }
public IndexerTaskFactory( FullNode node, IBlockRepository blockRepository, AzureStorageClient storageClient, IndexerSettings settings) { _network = node.Network; _blockRepository = blockRepository; _storageClient = storageClient; _settings = settings; }
/// <summary> /// Initializes a new instance of the <see cref="Notifier"/> class. /// </summary> public Notifier(IOptions <IndexerSettings> configuration, IOptions <ChainSettings> chainConfiguration, ILogger <Notifier> logger, IStorage storage) : base(configuration, logger) { this.configuration = configuration.Value; this.chainConfiguration = chainConfiguration.Value; log = logger; this.storage = storage; watch = Stopwatch.Start(); client = new Lazy <HttpClient>(() => new HttpClient(new HttpClientHandler { ServerCertificateCustomValidationCallback = (sender, certificate, chain, errors) => errors == SslPolicyErrors.None || errors == SslPolicyErrors.RemoteCertificateNameMismatch })); }
public BlockIndexer( IOptions <IndexerSettings> configuration, ILogger <BlockIndexer> logger, IStorage data, IMongoDb db) : base(configuration, logger) { log = logger; this.data = data; this.db = db; config = configuration.Value; watch = Stopwatch.Start(); }
/// <summary> /// Initializes a new instance of the <see cref="SyncOperations"/> class. /// </summary> public SyncOperations(IStorage storage, ILogger <SyncOperations> logger, IOptions <IndexerSettings> configuration, IMemoryCache cache) { this.configuration = configuration.Value; log = logger; this.storage = storage; this.cache = cache; // Register the cold staking template. StandardScripts.RegisterStandardScriptTemplate(ColdStakingScriptTemplate.Instance); watch = Stopwatch.Start(); cacheOptions = new MemoryCacheEntryOptions().SetAbsoluteExpiration(CacheKeys.BlockCountTime); }
/// <summary> /// Initializes a new instance of the <see cref="MempoolPuller"/> class. /// </summary> public MempoolPuller( IOptions <IndexerSettings> configuration, ISyncOperations syncOperations, SyncConnection syncConnection, ILogger <MempoolPuller> logger, IStorageOperations storageOperations) : base(configuration, logger) { log = logger; this.storageOperations = storageOperations; this.syncConnection = syncConnection; this.syncOperations = syncOperations; config = configuration.Value; watch = Stopwatch.Start(); }
public Indexer( INodeBlockFetcherFactory blockFetcherFactory, IIndexerTaskFactory taskFactory, ICheckpointStore checkpointStore, ConcurrentChain chain, IndexerSettings settings, ILoggerFactory loggerFactor) { this._blockFetcherFactory = blockFetcherFactory; this._chain = chain; this._settings = settings; this._logger = loggerFactor.CreateLogger <Indexer>(); this._taskFactory = taskFactory; this._checkpointStore = checkpointStore; }
public MongoData(ILogger <MongoStorageOperations> logger, SyncConnection connection, IOptions <IndexerSettings> nakoConfiguration, IOptions <ChainSettings> chainConfiguration) { configuration = nakoConfiguration.Value; this.chainConfiguration = chainConfiguration.Value; syncConnection = connection; log = logger; mongoClient = new MongoClient(configuration.ConnectionString.Replace("{Symbol}", this.chainConfiguration.Symbol.ToLower())); string dbName = configuration.DatabaseNameSubfix ? "Blockchain" + this.chainConfiguration.Symbol : "Blockchain"; mongoDatabase = mongoClient.GetDatabase(dbName); MemoryTransactions = new ConcurrentDictionary <string, NBitcoin.Transaction>(); // Make sure we only create a single instance of the watcher. watch = Stopwatch.Start(); }
/// <summary> /// Initializes a new instance of the <see cref="StatsHandler"/> class. /// </summary> public StatsHandler( SyncConnection connection, IStorage storage, IOptions <NetworkSettings> networkConfig, IOptions <IndexerSettings> configuration, IOptions <ChainSettings> chainConfiguration, ICryptoClientFactory clientFactory, GlobalState globalState) { this.storage = storage; this.clientFactory = clientFactory; this.globalState = globalState; syncConnection = connection; this.configuration = configuration.Value; this.chainConfiguration = chainConfiguration.Value; this.networkConfig = networkConfig.Value; }
/// <summary> /// Creates a new instance of the Azure Indexer feature /// </summary> /// <param name="fullNode"></param> /// <param name="storageClient"></param> /// <param name="azureIndexerLoop"></param> /// <param name="nodeSettings"></param> /// <param name="indexerSettings"></param> /// <param name="storeSettings"></param> /// <param name="loggerFactory"></param> public AzureIndexerFeature( FullNode fullNode, AzureStorageClient storageClient, AzureIndexerLoop azureIndexerLoop, NodeSettings nodeSettings, IndexerSettings indexerSettings, StoreSettings storeSettings, ILoggerFactory loggerFactory) { this._fullNode = fullNode; this._storageClient = storageClient; this._indexerLoop = azureIndexerLoop; this._nodeSettings = nodeSettings; this._indexerSettings = indexerSettings; this._storeSettings = storeSettings; this._logger = loggerFactory.CreateLogger <AzureIndexerFeature>(); }
public MongoStorageOperations( SyncConnection syncConnection, IMongoDb storage, IUtxoCache utxoCache, IOptions <IndexerSettings> configuration, GlobalState globalState, IMapMongoBlockToStorageBlock mongoBlockToStorageBlock, IScriptInterpeter scriptInterpeter, IStorage storage1) { this.syncConnection = syncConnection; this.globalState = globalState; this.scriptInterpeter = scriptInterpeter; this.storage = storage1; this.mongoBlockToStorageBlock = mongoBlockToStorageBlock; this.configuration = configuration.Value; db = storage; }
public static void OpenDirectoryIndexer(TaskSettings taskSettings = null) { if (taskSettings == null) { taskSettings = TaskSettings.GetDefaultTaskSettings(); } IndexerSettings indexerSettings = taskSettings.ToolsSettingsReference.IndexerSettings; indexerSettings.BinaryUnits = Program.Settings.BinaryUnits; DirectoryIndexerForm form = new DirectoryIndexerForm(indexerSettings); form.UploadRequested += source => { WorkerTask task = WorkerTask.CreateTextUploaderTask(source, taskSettings); task.Info.FileName = Path.ChangeExtension(task.Info.FileName, indexerSettings.Output.ToString().ToLowerInvariant()); TaskManager.Start(task); }; form.Show(); }
public NetworkConfig(IndexerSettings config, ChainSettings chainConfig, NetworkSettings networkConfig) { CoinTicker = chainConfig.Symbol; var consensusFactory = (ConsensusFactory)Activator.CreateInstance(Type.GetType(networkConfig.NetworkConsensusFactoryType)); Consensus = new ConsensusConfig(config, consensusFactory); Base58Prefixes = new byte[12][]; Base58Prefixes[(int)Base58Type.PUBKEY_ADDRESS] = new byte[] { (networkConfig.NetworkPubkeyAddressPrefix) }; Base58Prefixes[(int)Base58Type.SCRIPT_ADDRESS] = new byte[] { (networkConfig.NetworkScriptAddressPrefix) }; Bech32Encoders = new Bech32Encoder[2]; var encoder = new Bech32Encoder(networkConfig.NetworkWitnessPrefix); Bech32Encoders[(int)Bech32Type.WITNESS_PUBKEY_ADDRESS] = encoder; Bech32Encoders[(int)Bech32Type.WITNESS_SCRIPT_ADDRESS] = encoder; // TODO //StandardScripts.RegisterStandardScriptTemplate(ColdStakingScriptTemplate); }
/// <summary> /// Initializes a new instance of the <see cref="SyncOperations"/> class. /// </summary> public SyncOperations( IStorage storage, ILogger <SyncOperations> logger, IOptions <IndexerSettings> configuration, IMemoryCache cache, GlobalState globalState, ICryptoClientFactory clientFactory, ISyncBlockTransactionOperationBuilder blockInfoEnrichment, IMongoDb db) { this.configuration = configuration.Value; log = logger; this.storage = storage; this.cache = cache; this.globalState = globalState; this.clientFactory = clientFactory; transactionOperationBuilder = blockInfoEnrichment; this.db = db; // Register the cold staking template. StandardScripts.RegisterStandardScriptTemplate(ColdStakingScriptTemplate.Instance); cacheOptions = new MemoryCacheEntryOptions().SetAbsoluteExpiration(CacheKeys.BlockCountTime); }
/// <summary> /// Initializes a new instance of the <see cref="SyncConnection"/> class. /// </summary> public SyncConnection(IOptions <IndexerSettings> config, IOptions <ChainSettings> chainConfig, IOptions <NetworkSettings> networkConfig) { IndexerSettings configuration = config.Value; ChainSettings chainConfiguration = chainConfig.Value; NetworkSettings networkConfiguration = networkConfig.Value; Symbol = chainConfiguration.Symbol; Password = configuration.RpcPassword; // Take the RPC Port from the Indexer configuration, if it is specified. Otherwise we'll use the default for this chain. RpcAccessPort = configuration.RpcAccessPort != 0 ? configuration.RpcAccessPort : networkConfiguration.RPCPort; ServerDomain = configuration.RpcDomain.Replace("{Symbol}", chainConfiguration.Symbol.ToLower()); User = configuration.RpcUser; Secure = configuration.RpcSecure; StartBlockIndex = configuration.StartBlockIndex; // This can be replaced with a specific the network class of a specific coin // Or use the config values to simulate the network class. Network = new NetworkConfig(configuration, chainConfiguration, networkConfiguration); RecentItems = new Buffer <(DateTime Inserted, TimeSpan Duration, long Size)>(5000); }
public ConsensusConfig(IndexerSettings config, ConsensusFactory consensusFactory) : base( consensusFactory: consensusFactory, consensusOptions: null, coinType: 0, hashGenesisBlock: uint256.Zero, subsidyHalvingInterval: 0, majorityEnforceBlockUpgrade: 0, majorityRejectBlockOutdated: 0, majorityWindow: 0, buriedDeployments: null, bip9Deployments: null, bip34Hash: uint256.Zero, ruleChangeActivationThreshold: 0, minerConfirmationWindow: 0, maxReorgLength: 0, defaultAssumeValid: uint256.Zero, maxMoney: 0, coinbaseMaturity: 0, premineHeight: 0, premineReward: 0, proofOfWorkReward: 0, powTargetTimespan: TimeSpan.Zero, powTargetSpacing: TimeSpan.Zero, powAllowMinDifficultyBlocks: false, posNoRetargeting: false, powNoRetargeting: false, powLimit: new Target(uint256.Zero), minimumChainWork: null, isProofOfStake: consensusFactory is PosConsensusFactory, lastPowBlock: 0, proofOfStakeLimit: null, proofOfStakeLimitV2: null, proofOfStakeReward: 0 ) { }
protected IndexerTask( IndexerSettings settings) { Settings = settings; }
public BlockSummaryTask( AzureStorageClient storageClient, IndexerSettings settings) : base(storageClient, settings) { }