private async ValueTask <Module> GetModuleAsync(IModuleSource source,
ModuleReleaseIdentifier releaseId,
CancellationToken cancellation)
{
var moduleId = releaseId.Module;
var moduleVersion = releaseId.Version;
Module module;
do
{
module = await _entityStorageEngine.GetByIdAsync <Module>(moduleId.ToString(), cancellation);
if (module == null)
{
var metadata = await source.GetMetadataAsync(releaseId, _metadataReader, cancellation);
module = new Module(metadata, source);
}
else if (module.GetRelease(moduleVersion) is var release && release != null)
{
if (release.TryAddSource(source))
{
break;
}
}
else
{
var metadata = await source.GetMetadataAsync(releaseId, _metadataReader, cancellation);
module.AddRelease(metadata, source);
}
}while (!await _entityStorageEngine.TryStoreAsync(module, cancellation));
public async Task <IActionResult> Install(ModuleReleaseIdentifier id)
{
var queryResult = await _messageDispatcher.QueryByIdAsync <ModuleReleaseIdentifier, ModuleInstallModel>(id);
if (queryResult.IsSuccessWithResult <ModuleInstallModel>(out var model))
{
return(View(model));
}
return(GetActionResult(queryResult));
}
private bool TryCombine(ModuleReleaseIdentifier matchingRelease,
IEnumerable <ModuleDependency> dependencies,
out ImmutableDictionary <ModuleIdentifier, ModuleVersionRange> unresolved)
{
Assert(_unresolved != null);
var builder = _unresolved.ToBuilder();
builder.Remove(matchingRelease.Module);
foreach (var dependency in dependencies)
{
if (_resolved != null &&
_resolved.TryGetValue(dependency.Module, out var resolvedDependency))
{
if (dependency.VersionRange.IsMatch(resolvedDependency))
{
continue;
}
unresolved = null;
return(false); // We have a resolved dependency that does not match our version filter => This is a version conflict
}
if (matchingRelease.Module == dependency.Module)
{
if (dependency.VersionRange.IsMatch(matchingRelease.Version))
{
continue;
}
unresolved = null;
return(false);
}
if (!builder.TryGetValue(dependency.Module, out var existingVersion))
{
builder.Add(dependency.Module, dependency.VersionRange);
}
else if (existingVersion.TryCombine(dependency.VersionRange, out var combinedVersion))
{
builder[dependency.Module] = combinedVersion;
}
else
{
unresolved = null;
return(false); // We have an unresolved dependency that does not match our version filter => This is a version conflict
}
}
unresolved = builder.ToImmutable();
return(true);
}
private async Task InstallAsync(ModuleReleaseIdentifier moduleRelease, CancellationToken cancellation)
{
var moduleInstallationDirectory = await _moduleInstaller.InstallAsync(_installationDirectory, moduleRelease, cancellation);
if (moduleInstallationDirectory == null)
{
// TODO
throw new Exception();
}
var supervisor = _moduleSupervisorFactory.CreateSupervisor(moduleInstallationDirectory);
_supervisors.Add(supervisor);
}
public static ValueTask <IModuleMetadata> GetMetadataAsync(this IModuleSource moduleSource,
ModuleReleaseIdentifier moduleRelease,
IMetadataReader moduleMetadataReader,
CancellationToken cancellation = default)
{
if (moduleSource == null)
{
throw new ArgumentNullException(nameof(moduleSource));
}
if (moduleRelease == default)
{
throw new ArgumentDefaultException(nameof(moduleRelease));
}
return(moduleSource.GetMetadataAsync(moduleRelease.Module, moduleRelease.Version, moduleMetadataReader, cancellation));
}
private async Task <IEnumerable <IModuleSource> > GetSourcesAsync(ModuleReleaseIdentifier moduleRelease, CancellationToken cancellation)
{
var module = await GetModuleAsync(moduleRelease.Module, cancellation);
if (module == null)
{
return(Enumerable.Empty <IModuleSource>());
}
var release = module.GetRelease(moduleRelease.Version);
if (release == null)
{
return(Enumerable.Empty <IModuleSource>());
}
return(await release.GetSourcesAsync(cancellation));
}
public async Task <DirectoryInfo> InstallAsync(DirectoryInfo directory,
ModuleReleaseIdentifier moduleRelease,
CancellationToken cancellation)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
var sources = await GetSourcesAsync(moduleRelease, cancellation);
foreach (var source in sources)
{
var result = await source.ExtractAsync(directory, moduleRelease, _metadataReader, cancellation);
if (result != null)
{
return(result);
}
}
return(null);
}
public async ValueTask <IEnumerable <ModuleDependency> > GetDependenciesAsync(ModuleReleaseIdentifier moduleRelease, CancellationToken cancellation)
{
var module = await _storageEngine.GetByIdAsync(typeof(Module), moduleRelease.Module.ToString(), cancellation) as Module;
if (module == null)
{
throw new Exception(); // TODO
}
var release = module.GetRelease(moduleRelease.Version);
if (release == null)
{
throw new Exception(); // TODO
}
return(release.Dependencies);
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
if (bindingContext == null)
{
throw new ArgumentNullException(nameof(bindingContext));
}
// _logger?.AttemptingToBindModel(bindingContext);
var modelName = bindingContext.ModelName;
var valueProviderResult = bindingContext.ValueProvider.GetValue(modelName);
if (valueProviderResult == ValueProviderResult.None)
{
//_logger?.FoundNoValueInRequest(bindingContext);
// no entry
//_logger?.DoneAttemptingToBindModel(bindingContext);
return(Task.CompletedTask);
}
var modelState = bindingContext.ModelState;
modelState.SetModelValue(modelName, valueProviderResult);
var metadata = bindingContext.ModelMetadata;
var type = metadata.UnderlyingOrModelType;
try
{
var value = valueProviderResult.FirstValue;
var culture = valueProviderResult.Culture;
object model;
if (string.IsNullOrWhiteSpace(value))
{
model = null;
}
else if (type == typeof(ModuleReleaseIdentifier))
{
var parts = value.Trim().Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
model = null;
}
else
{
var module = new ModuleIdentifier(parts[0]);
var version = ModuleVersion.Parse(parts[1]);
model = new ModuleReleaseIdentifier(module, version);
}
}
else
{
// unreachable
throw new NotSupportedException();
}
if (model == null && !metadata.IsReferenceOrNullableType)
{
modelState.TryAddModelError(
modelName,
metadata.ModelBindingMessageProvider.ValueMustNotBeNullAccessor(
valueProviderResult.ToString()));
}
else
{
bindingContext.Result = ModelBindingResult.Success(model);
}
}
catch (Exception exception)
{
modelState.TryAddModelError(modelName, exception, metadata);
}
//_logger?.DoneAttemptingToBindModel(bindingContext);
return(Task.CompletedTask);
}
