public GetFileInformationHandler
(
ILogger logger,
IMongoDb mongoDb
) : base(logger, mongoDb)
{
}
public FindFilesWithPatternHandler
(
ILogger logger,
IMongoDb mongoDb
) : base(logger, mongoDb)
{
}
public RichListSync(IOptions <IndexerSettings> configuration, ILogger <RichListSync> logger, IMongoDb data)
: base(configuration, logger)
{
db = data;
log = logger;
watch = new Stopwatch();
}
public ReadFileHandler
(
ILogger logger,
IMongoDb mongoDb
) : base(logger, mongoDb)
{
}
/// <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 BaseHandler
(
ILogger logger,
IMongoDb mongoDb
)
{
_logger = logger.ForContext(GetType());
_mongoDb = mongoDb;
}
public static async Task RewindBlockAsync(this IMongoDb storage, uint blockIndex)
{
await StoreRewindBlockAsync(storage, blockIndex);
FilterDefinition <OutputTable> outputFilter =
Builders <OutputTable> .Filter.Eq(addr => addr.BlockIndex, blockIndex);
Task <DeleteResult> output = storage.OutputTable.DeleteManyAsync(outputFilter);
// delete the transaction
FilterDefinition <TransactionBlockTable> transactionFilter =
Builders <TransactionBlockTable> .Filter.Eq(info => info.BlockIndex, blockIndex);
Task <DeleteResult> transactions = storage.TransactionBlockTable.DeleteManyAsync(transactionFilter);
// delete computed
FilterDefinition <AddressComputedTable> addrCompFilter =
Builders <AddressComputedTable> .Filter.Eq(addr => addr.ComputedBlockIndex, blockIndex);
Task <DeleteResult> addressComputed = storage.AddressComputedTable.DeleteManyAsync(addrCompFilter);
// delete computed history
FilterDefinition <AddressHistoryComputedTable> addrCompHistFilter =
Builders <AddressHistoryComputedTable> .Filter.Eq(addr => addr.BlockIndex, blockIndex);
Task <DeleteResult> addressHistoryComputed = storage.AddressHistoryComputedTable.DeleteManyAsync(addrCompHistFilter);
// this is an edge case, we delete from the utxo table in case a bath push failed half way and left
// item in the utxo table that where suppose to get deleted, to avoid duplicates in recovery processes
// we delete just in case (the utxo table has a unique key on outputs), there is no harm in deleting twice.
FilterDefinition <UnspentOutputTable> unspentOutputFilter1 =
Builders <UnspentOutputTable> .Filter.Eq(utxo => utxo.BlockIndex, blockIndex);
Task <DeleteResult> unspentOutput1 = storage.UnspentOutputTable.DeleteManyAsync(unspentOutputFilter1);
await Task.WhenAll(output, transactions, addressComputed, addressHistoryComputed, unspentOutput1);
await MergeRewindInputsToUnspentTransactionsAsync(storage, blockIndex);
FilterDefinition <InputTable> inputFilter =
Builders <InputTable> .Filter.Eq(addr => addr.BlockIndex, blockIndex);
Task <DeleteResult> inputs = storage.InputTable.DeleteManyAsync(inputFilter);
// TODO: if we filtered out outputs that where created and spent as part of the same block
// we may not need to delete again, however there is no harm in this extra delete.
FilterDefinition <UnspentOutputTable> unspentOutputFilter =
Builders <UnspentOutputTable> .Filter.Eq(utxo => utxo.BlockIndex, blockIndex);
Task <DeleteResult> unspentOutput = storage.UnspentOutputTable.DeleteManyAsync(unspentOutputFilter);
await Task.WhenAll(inputs, unspentOutput);
}
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>
/// Base class for most database access
/// </summary>
/// <param name="database">The database to be used</param>
/// <param name="collectionName">The name for the collection to be used</param>
/// <param name="eventLogRepository">collection where crud operations are logged</param>
protected RepositoryBase(
IMongoDb database,
string collectionName,
// IEventLogRepository eventLogRepository,
Func <string, MongoCollection> collectionGetter = null)
{
// _eventLogRepository = eventLogRepository;
if (collectionGetter == null)
{
collectionGetter = s => database.Database.GetCollection <TResource>(s);
}
ResourceCollection = collectionGetter(collectionName);
}
private async Task<IWatcherCheckResult> ExecuteForQueryAsync(IMongoDb mongoDb)
{
var queryResult = await mongoDb.QueryAsync(_configuration.CollectionName, _configuration.Query);
var isValid = true;
if (_configuration.EnsureThatAsync != null)
isValid = await _configuration.EnsureThatAsync?.Invoke(queryResult);
isValid = isValid && (_configuration.EnsureThat?.Invoke(queryResult) ?? true);
var description = $"MongoDB check has returned {(isValid ? "valid" : "invalid")} result for " +
$"database: '{_configuration.Database}' and given query.";
return MongoDbWatcherCheckResult.Create(this, isValid, _configuration.Database,
_configuration.ConnectionString, _configuration.Query, queryResult, description);
}
public MongoData(ILogger <MongoDb> dbLogger, SyncConnection connection, IOptions <ChainSettings> chainConfiguration,
GlobalState globalState, IMapMongoBlockToStorageBlock mongoBlockToStorageBlock, ICryptoClientFactory clientFactory,
IScriptInterpeter scriptInterpeter, IMongoDatabase mongoDatabase, IMongoDb db)
{
log = dbLogger;
this.chainConfiguration = chainConfiguration.Value;
this.globalState = globalState;
syncConnection = connection;
this.mongoBlockToStorageBlock = mongoBlockToStorageBlock;
this.clientFactory = clientFactory;
this.scriptInterpeter = scriptInterpeter;
this.mongoDatabase = mongoDatabase;
mongoDb = db;
}
public static void AddBadges(IEnumerable<int> buyerIds, List<Badge> badges, IMongoDb mongoDb, string badgeName)
{
foreach (var buyer in buyerIds)
{
var buyerBadge = badges.FirstOrDefault(x => x.Ansattnummer == buyer);
if (buyerBadge != null && buyerBadge.BadgesForUser.Contains(badgeName)) continue; // Badge exists
if (buyerBadge == null)
{
AddFirstBadge(mongoDb, buyer, badgeName, BadgeJob.CollectionName);
continue;
}
buyerBadge.BadgesForUser.Add(badgeName);
mongoDb.Save(buyerBadge, BadgeJob.CollectionName); // New badge
}
}
private async Task <IWatcherCheckResult> ExecuteForQueryAsync(IMongoDb mongoDb)
{
var queryResult = await mongoDb.QueryAsync(_configuration.CollectionName, _configuration.Query);
var isValid = true;
if (_configuration.EnsureThatAsync != null)
{
isValid = await _configuration.EnsureThatAsync?.Invoke(queryResult);
}
isValid = isValid && (_configuration.EnsureThat?.Invoke(queryResult) ?? true);
var description = $"MongoDB check has returned {(isValid ? "valid" : "invalid")} result for " +
$"database: '{_configuration.Database}' and given query.";
return(MongoDbWatcherCheckResult.Create(this, isValid, _configuration.Database,
_configuration.ConnectionString, _configuration.Query, queryResult, description));
}
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 MongoDbDokanOperations
(
ILogger logger,
CommandLineArguments commandLineArguments,
IPathParser pathParser,
IMongoDb mongoDb,
FindFilesWithPatternHandler findFilesWithPatternHander,
GetFileInformationHandler getFileInformationHandler,
ReadFileHandler readFileHandler
)
{
_logger = logger.ForContext <MongoDbDokanOperations>();
_commandLineArgs = commandLineArguments;
_pathParser = pathParser;
_mongoDb = mongoDb;
_findFilesWithPatternHander = findFilesWithPatternHander;
_getFileInformationHandler = getFileInformationHandler;
_readFileHandler = readFileHandler;
}
/// <summary>
/// Inputs spend outputs, when an output is spent it gets deleted from the UnspendOutput table and the action of the delete is represented in the inputs table,
/// when a rewind happens we need to bring back outputs that have been deleted from the UnspendOutput so we look for those outputs in the inputs table,
/// however the block index in the inputs table is the one representing the input not the output we are trying to restore so we have to look it up in the outputs table.
/// </summary>
private static async Task MergeRewindInputsToUnspentTransactionsAsync(IMongoDb storage, long blockIndex)
{
List <UnspentOutputTable> unspentOutputs = await storage.InputTable.Aggregate <UnspentOutputTable>(
new []
{
new BsonDocument("$match",
new BsonDocument("BlockIndex", blockIndex)),
new BsonDocument("$lookup",
new BsonDocument
{
{ "from", "Output" },
{ "localField", "Outpoint" },
{ "foreignField", "Outpoint" },
{ "as", "Output" }
}),
new BsonDocument("$unwind",
new BsonDocument("path", "$Output")),
new BsonDocument("$project",
new BsonDocument
{
{ "Value", "$Value" },
{ "Address", "$Address" },
{ "BlockIndex", "$Output.BlockIndex" },
{ "Outpoint", "$Outpoint" }
})
}).ToListAsync();
// this is to unsure the values are unique
unspentOutputs.ToDictionary(a => a.Outpoint.ToString());
// TODO: filter out any outputs that belong to the block being reorged.
// this can happen for outputs that are created and spent in the same block.
// if they get pushed now such outputs willjust get deleted in the next step.
if (unspentOutputs.Any())
{
await storage.UnspentOutputTable.InsertManyAsync(unspentOutputs);
}
}
/// <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);
}
private static Task StoreRewindBlockAsync(IMongoDb storage, uint blockIndex)
{
var blockTask = storage.BlockTable.FindAsync(_ => _.BlockIndex == blockIndex);
var inputsTask = storage.InputTable.FindAsync(_ => _.BlockIndex == blockIndex);
var outputsTask = storage.OutputTable.FindAsync(_ => _.BlockIndex == blockIndex);
var transactionIdsTask = storage.TransactionBlockTable.FindAsync(_ => _.BlockIndex == blockIndex);
Task.WhenAll(blockTask, inputsTask, outputsTask, transactionIdsTask);
BlockTable block = blockTask.Result.Single();
var reorgBlock = new ReorgBlockTable
{
Created = System.DateTime.UtcNow,
BlockIndex = blockIndex,
BlockHash = block.BlockHash,
Block = block,
Inputs = inputsTask.Result.ToList(),
Outputs = outputsTask.Result.ToList(),
TransactionIds = transactionIdsTask.Result.ToList()
};
return(storage.ReorgBlock.InsertOneAsync(reorgBlock));
}
public WeightsRepository(IMongoDb mongoDatabase)
: base(mongoDatabase, "weights")
{
}
public OneFavouriteBadge(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public ConsistentBadge(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public void Init()
{
_mongoDb = A.Fake<IMongoDb>();
_controller = new BuyController(_mongoDb);
}
public ToplistController(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public MongoController(IMongoDb repo)
{
_repo = repo;
}
public IceCreamController(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public BadgeController(IMongoDb mongoDb)
{
_db = mongoDb;
}
public MorningGloryBadge(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public EmpresaRepository(IMongoDb db)
{
Db = db;
}
public BuyController(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public FavouritesController(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public CustomersController(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public MedalsBadge(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public RouletteMongoDbRepository(IMongoDb mongoDb, IOptions <RouletteSettings> rouleteSettings)
{
_mongoDb = mongoDb;
_rouletteMongoDbSettings = rouleteSettings.Value.RouletteMongoDbSettings;
}
public CustomerInsertedEventProjector(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public RegisterSlackUserController(IMongoDb mongoDb)
{
_db = mongoDb;
}
public MixItUpBadge(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public CustomerCreatedEventProjector(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
private static void AddFirstBadge(IMongoDb mongoDb, int buyer, string badgeName, string collectionName)
{
var badge = new Badge { Ansattnummer = buyer, BadgesForUser = new List<string>() };
badge.BadgesForUser.Add(badgeName);
mongoDb.Insert(badge, collectionName); // First badge awarded
}
public BuyController(IMongoDb mongoDb, IBadgeService badgeService)
{
_mongoDb = mongoDb;
_badgeService = badgeService;
}
public void Init()
{
_mongoDb = A.Fake<IMongoDb>();
_controller = new BuyController(_mongoDb, A.Fake<IBadgeService>());
}
public BadgeService(IMongoDb mongoDb)
{
_mongoDb = mongoDb;
}
public CirrusMongoBuilder(ILogger <MongoBuilder> logger, IMongoDb data, IOptions <IndexerSettings> nakoConfiguration, IOptions <ChainSettings> chainSettings)
: base(logger, data, nakoConfiguration, chainSettings)
{
}
