private async System.Threading.Tasks.Task Worker(string key, string operationId, ExclusiveBlockType blockType,
List <string> log, TimeSpan timeout = default)
{
var config = new ExclusiveBlockConfiguration
{
//LockTimeout = TimeSpan.FromSeconds(1),
//PollingTime = TimeSpan.FromSeconds(0.1),
LockTimeout = TimeSpan.FromSeconds(2.5),
PollingTime = TimeSpan.FromSeconds(1),
};
if (timeout != default)
{
config.WaitTimeout = timeout;
}
Log(log, "before block " + operationId);
Trace.WriteLine($"SnTrace: TEST: before block {key} #{operationId}");
await ExclusiveBlock.RunAsync(key, operationId, blockType, config, CancellationToken.None, async() =>
{
Log(log, "in block " + operationId);
//await System.Threading.Tasks.Task.Delay(1500);
await System.Threading.Tasks.Task.Delay(3000);
Trace.WriteLine($"SnTrace: TEST: in block {key} #{operationId}");
});
Log(log, "after block " + operationId);
Trace.WriteLine($"SnTrace: TEST: after block {key} #{operationId}");
}
public WorkerPool(int workerMinimum, int workerMaximum, IWorkerFactory <T> workerFactory)
{
if (workerMinimum < 1)
{
throw new ArgumentException(nameof(workerMinimum));
}
if (workerMaximum < 1)
{
throw new ArgumentException(nameof(workerMaximum));
}
if (workerMinimum > workerMaximum)
{
throw new ArgumentException(nameof(workerMinimum), $"{nameof(workerMinimum)} should not be greater thant {nameof(workerMaximum)}");
}
WorkerMinimum = workerMinimum;
WorkerMaximum = workerMaximum;
_workerFactory = workerFactory;
_exclusiveBlock = new ExclusiveBlock(_workerIdentifier.ToString());
InitializeWorkers(workerMinimum, workerFactory);
}
private async Task <DatabaseUsage> LoadDatabaseUsageAsync(CancellationToken cancel)
{
await ExclusiveBlock.RunAsync(ExclusiveBlockKey, Guid.NewGuid().ToString(),
ExclusiveBlockType.WaitForReleased, new ExclusiveLockOptions(), cancel,
async() =>
{
var loader = new DatabaseUsageLoader(Providers.Instance.DataProvider); //UNDONE:<?usage: GetService
var dbUsage = await loader.LoadAsync(cancel).ConfigureAwait(false);
_loadedDatabaseUsage = dbUsage;
});
return(_loadedDatabaseUsage);
}
public static RepositoryInstance Start(RepositoryBuilder builder)
{
// Required early configuration
BlobStorageComponents.DataProvider = Providers.Instance.BlobMetaDataProvider;
BlobStorageComponents.ProviderSelector = Providers.Instance.BlobProviderSelector;
var initialData = builder.InitialData;
if (initialData != null)
{
DataStore.InstallInitialDataAsync(initialData, CancellationToken.None)
.GetAwaiter().GetResult();
}
RepositoryInstance repositoryInstance = null;
var exclusiveLockOptions = builder.Services?.GetService <IOptions <ExclusiveLockOptions> >()?.Value;
ExclusiveBlock.RunAsync("SenseNet.PatchManager", Guid.NewGuid().ToString(),
ExclusiveBlockType.WaitAndAcquire, exclusiveLockOptions, CancellationToken.None, () =>
{
var logger = Providers.Instance.GetProvider <ILogger <SnILogger> >();
var patchManager = new PatchManager(builder, logRecord => { logRecord.WriteTo(logger); });
patchManager.ExecutePatchesOnBeforeStart();
repositoryInstance = Start((RepositoryStartSettings)builder);
var permissions = initialData?.Permissions;
if (permissions != null && permissions.Count > 0)
{
SecurityHandler.SecurityInstaller.InstallDefaultSecurityStructure(initialData);
}
var indexingEngine = Providers.Instance.SearchEngine.IndexingEngine;
if (indexingEngine.Running && initialData?.IndexDocuments != null)
{
indexingEngine.ClearIndexAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
indexingEngine.WriteIndexAsync(null, null,
initialData.IndexDocuments, CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
}
patchManager.ExecutePatchesOnAfterStart();
RepositoryVersionInfo.Reset();
return(System.Threading.Tasks.Task.CompletedTask);
}).GetAwaiter().GetResult();
return(repositoryInstance);
}
private async System.Threading.Tasks.Task Worker(string operationId, ExclusiveBlockType blockType,
List <string> log, TimeSpan timeout = default)
{
var config = new ExclusiveBlockConfiguration
{
LockTimeout = TimeSpan.FromSeconds(1),
PollingTime = TimeSpan.FromSeconds(0.1),
};
if (timeout != default)
{
config.WaitTimeout = timeout;
}
log.Add("before block " + operationId);
await ExclusiveBlock.RunAsync("MyFeature", operationId, blockType, config, CancellationToken.None, async() =>
{
await System.Threading.Tasks.Task.Delay(1500);
log.Add("in block " + operationId);
});
log.Add("after block " + operationId);
}
public static RepositoryInstance Start(RepositoryBuilder builder)
{
var connectionStrings = builder.Services?.GetRequiredService <IOptions <ConnectionStringOptions> >();
Providers.Instance.InitializeBlobProviders(connectionStrings?.Value ?? new ConnectionStringOptions());
EnsureDatabase(builder);
var initialData = builder.InitialData;
if (initialData != null)
{
Providers.Instance.DataStore.InstallInitialDataAsync(initialData, CancellationToken.None)
.GetAwaiter().GetResult();
}
RepositoryInstance repositoryInstance = null;
var exclusiveLockOptions = builder.Services?.GetService <IOptions <ExclusiveLockOptions> >()?.Value;
ExclusiveBlock.RunAsync("SenseNet.PatchManager", Guid.NewGuid().ToString(),
ExclusiveBlockType.WaitAndAcquire, exclusiveLockOptions, CancellationToken.None, () =>
{
var logger = Providers.Instance.GetProvider <ILogger <SnILogger> >();
var patchManager = new PatchManager(builder, logRecord => { logRecord.WriteTo(logger); });
patchManager.ExecutePatchesOnBeforeStart();
repositoryInstance = Start((RepositoryStartSettings)builder);
var permissions = initialData?.Permissions;
if (permissions != null && permissions.Count > 0)
{
new SecurityInstaller(Providers.Instance.SecurityHandler, Providers.Instance.StorageSchema,
Providers.Instance.DataStore).InstallDefaultSecurityStructure(initialData);
}
var indexingEngine = Providers.Instance.SearchEngine.IndexingEngine;
if (indexingEngine.Running)
{
if (initialData?.IndexDocuments != null)
{
// Build the index from an in-memory structure. This is a developer use case.
indexingEngine.ClearIndexAsync(CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
indexingEngine.WriteIndexAsync(null, null,
initialData.IndexDocuments, CancellationToken.None)
.ConfigureAwait(false).GetAwaiter().GetResult();
}
else
{
// make sure the index exists and contains documents
EnsureIndex(builder);
}
}
patchManager.ExecutePatchesOnAfterStart();
RepositoryVersionInfo.Reset();
return(System.Threading.Tasks.Task.CompletedTask);
}).GetAwaiter().GetResult();
return(repositoryInstance);
}
public void Setup() => ExclusiveBlock = new ExclusiveBlock(ExclusiveBlockFeatures.SupportsRecursion);