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); }