public static bool TryGetInstallationState(JSONObject parent, out ILibraryInstallationState installationState) { installationState = null; if (parent == null) { return(false); } var state = new LibraryInstallationState(); foreach (JSONMember child in parent.Children.OfType <JSONMember>()) { switch (child.UnquotedNameText) { case "provider": state.ProviderId = child.UnquotedValueText; break; case "id": state.LibraryId = child.UnquotedValueText; break; case "path": state.DestinationPath = child.UnquotedValueText; break; case "files": state.Files = (child.Value as JSONArray)?.Elements.Select(e => e.UnquotedValueText).ToList(); break; } } // Check for defaultProvider if (string.IsNullOrEmpty(state.ProviderId)) { IEnumerable <JSONMember> rootMembers = parent.Parent?.FindType <JSONObject>()?.Children?.OfType <JSONMember>(); if (rootMembers != null) { foreach (JSONMember child in rootMembers) { if (child.UnquotedNameText == "defaultProvider") { state.ProviderId = child.UnquotedValueText; } } } } installationState = state; return(!string.IsNullOrEmpty(installationState.ProviderId)); }
/// <summary> /// Uninstalls the specified library and removes it from the <see cref="Libraries"/> collection. /// </summary> /// <param name="libraryId">The library identifier.</param> /// <param name="deleteFileAction"></param> public void Uninstall(string libraryId, Action <string> deleteFileAction) { ILibraryInstallationState state = Libraries.FirstOrDefault(l => l.LibraryId == libraryId); if (state != null) { DeleteLibraryFiles(state, deleteFileAction); _libraries.Remove(state); } }
private async Task <ILibraryOperationResult> DeleteLibraryFilesAsync(ILibraryInstallationState state, Func <IEnumerable <string>, Task <bool> > deleteFilesFunction, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); try { IProvider provider = _dependencies.GetProvider(state.ProviderId); ILibraryOperationResult updatedStateResult = await provider.UpdateStateAsync(state, CancellationToken.None).ConfigureAwait(false); if (updatedStateResult.Success) { List <string> filesToDelete = new List <string>(); state = updatedStateResult.InstallationState; foreach (string file in state.Files) { var url = new Uri(file, UriKind.RelativeOrAbsolute); if (!url.IsAbsoluteUri) { string relativePath = Path.Combine(state.DestinationPath, file).Replace('\\', '/'); filesToDelete.Add(relativePath); } } bool success = true; if (deleteFilesFunction != null) { success = await deleteFilesFunction.Invoke(filesToDelete).ConfigureAwait(false); } if (success) { return(LibraryOperationResult.FromSuccess(updatedStateResult.InstallationState)); } else { return(LibraryOperationResult.FromError(PredefinedErrors.CouldNotDeleteLibrary(state.LibraryId))); } } return(updatedStateResult); } catch (OperationCanceledException) { return(LibraryOperationResult.FromCancelled(state)); } catch (Exception) { return(LibraryOperationResult.FromError(PredefinedErrors.CouldNotDeleteLibrary(state.LibraryId))); } }
private async Task <Stream> GetStreamAsync(ILibraryInstallationState state, string sourceFile, CancellationToken cancellationToken) { string absolute = Path.Combine(CacheFolder, state.Name, state.Version, sourceFile); if (File.Exists(absolute)) { return(await HostInteraction.ReadFileAsync(absolute, cancellationToken).ConfigureAwait(false)); } return(null); }
/// <summary> /// Adds a library to the <see cref="Libraries"/> collection. /// </summary> /// <param name="state">An instance of <see cref="ILibraryInstallationState"/> representing the library to add.</param> public void AddLibrary(ILibraryInstallationState state) { ILibraryInstallationState existing = _libraries.Find(p => p.LibraryId == state.LibraryId && p.ProviderId == state.ProviderId); if (existing != null) { _libraries.Remove(existing); } _libraries.Add(state); }
/// <summary>Internal use only</summary> public static LibraryInstallationState FromInterface(ILibraryInstallationState state, string defaultProviderId = null) { string normalizedProviderId = state.ProviderId ?? defaultProviderId; return(new LibraryInstallationState { LibraryId = state.LibraryId, ProviderId = normalizedProviderId, Files = state.Files, DestinationPath = state.DestinationPath }); }
private static string GetDisplayText(SuggestedActionProvider provider) { ILibraryInstallationState state = provider.InstallationState; string cleanId = LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(state.Name, state.Version, state.ProviderId); if (cleanId.Length > MaxLength + 10) { cleanId = $"...{cleanId.Substring(cleanId.Length - MaxLength)}"; } return(string.Format(Resources.Text.UninstallLibrary, cleanId)); }
private static string GetLibraryId(IEnumerable <ILibraryOperationResult> totalResults, OperationType operation) { if (operation == OperationType.Uninstall || operation == OperationType.Upgrade) { if (totalResults != null && totalResults.Count() == 1) { ILibraryInstallationState state = totalResults.First().InstallationState; return(LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(state.Name, state.Version, state.ProviderId)); } } return(string.Empty); }
private void DeleteLibraryFiles(ILibraryInstallationState state, Action <string> deleteFileAction) { foreach (string file in state.Files) { var url = new Uri(file, UriKind.RelativeOrAbsolute); if (!url.IsAbsoluteUri) { string relativePath = Path.Combine(state.DestinationPath, file).Replace('\\', '/'); deleteFileAction?.Invoke(relativePath); } } }
protected virtual ILibraryOperationResult CheckForInvalidFiles(ILibraryInstallationState desiredState, string libraryId, ILibrary library) { IReadOnlyList <string> invalidFiles = library.GetInvalidFiles(desiredState.Files); if (invalidFiles.Count > 0) { IError invalidFilesError = PredefinedErrors.InvalidFilesInLibrary(libraryId, invalidFiles, library.Files.Keys); return(new LibraryOperationResult(desiredState, invalidFilesError)); } else { return(LibraryOperationResult.FromSuccess(desiredState)); } }
private Stream GetStream(ILibraryInstallationState state, string sourceFile) { string[] args = state.LibraryId.Split('@'); string name = args[0]; string version = args[1]; string absolute = Path.Combine(CacheFolder, name, version, sourceFile); if (File.Exists(absolute)) { return(File.Open(absolute, FileMode.Open, FileAccess.Read)); } return(null); }
private async Task <Stream> GetStreamAsync(ILibraryInstallationState state, string sourceFile, CancellationToken cancellationToken) { string[] args = state.LibraryId.Split('@'); string name = args[0]; string version = args[1]; string absolute = Path.Combine(CacheFolder, name, version, sourceFile); if (File.Exists(absolute)) { return(await FileHelpers.OpenFileAsync(absolute, cancellationToken).ConfigureAwait(false)); } return(null); }
/// <summary> /// Updates file set on the passed in ILibraryInstallationState in case user selected to have all files included /// </summary> /// <param name="desiredState"></param> /// <param name="cancellationToken"></param> /// <returns></returns> public async Task <ILibraryInstallationResult> UpdateStateAsync(ILibraryInstallationState desiredState, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(LibraryInstallationResult.FromCancelled(desiredState)); } try { ILibraryCatalog catalog = GetCatalog(); ILibrary library = await catalog.GetLibraryAsync(desiredState.LibraryId, cancellationToken).ConfigureAwait(false); if (library == null) { throw new InvalidLibraryException(desiredState.LibraryId, Id); } await HydrateCacheAsync(library, cancellationToken).ConfigureAwait(false); if (desiredState.Files != null && desiredState.Files.Count > 0) { return(LibraryInstallationResult.FromSuccess(desiredState)); } desiredState = new LibraryInstallationState { ProviderId = Id, LibraryId = desiredState.LibraryId, DestinationPath = desiredState.DestinationPath, Files = library.Files.Keys.ToList(), }; } catch (Exception ex) when(ex is InvalidLibraryException || ex.InnerException is InvalidLibraryException) { return(new LibraryInstallationResult(desiredState, PredefinedErrors.UnableToResolveSource(desiredState.LibraryId, desiredState.ProviderId))); } catch (UnauthorizedAccessException) { return(new LibraryInstallationResult(desiredState, PredefinedErrors.PathOutsideWorkingDirectory())); } catch (Exception ex) { HostInteraction.Logger.Log(ex.ToString(), LogLevel.Error); return(new LibraryInstallationResult(desiredState, PredefinedErrors.UnknownException())); } return(LibraryInstallationResult.FromSuccess(desiredState)); }
/// <summary> /// Copies ILibraryInstallationState files to cache /// </summary> /// <param name="state"></param> /// <param name="cancellationToken"></param> /// <returns></returns> private async Task <ILibraryOperationResult> RefreshCacheAsync(ILibraryInstallationState state, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return(LibraryOperationResult.FromCancelled(state)); } var tasks = new List <Task>(); try { if (!string.IsNullOrEmpty(state.Name) && !string.IsNullOrEmpty(state.Version)) { string libraryDir = Path.Combine(CacheFolder, state.Name); List <CacheServiceMetadata> librariesMetadata = new List <CacheServiceMetadata>(); foreach (string sourceFile in state.Files) { string cacheFile = Path.Combine(libraryDir, state.Version, sourceFile); string url = string.Format(_downloadUrlFormat, state.Name, state.Version, sourceFile); CacheServiceMetadata newEntry = new CacheServiceMetadata(url, cacheFile); if (!librariesMetadata.Contains(newEntry)) { librariesMetadata.Add(new CacheServiceMetadata(url, cacheFile)); } } await _cacheService.RefreshCacheAsync(librariesMetadata, cancellationToken); } } catch (ResourceDownloadException ex) { HostInteraction.Logger.Log(ex.ToString(), LogLevel.Error); return(new LibraryOperationResult(state, PredefinedErrors.FailedToDownloadResource(ex.Url))); } catch (OperationCanceledException) { return(LibraryOperationResult.FromCancelled(state)); } catch (Exception ex) { HostInteraction.Logger.Log(ex.InnerException.ToString(), LogLevel.Error); return(new LibraryOperationResult(state, PredefinedErrors.UnknownException())); } return(LibraryOperationResult.FromSuccess(state)); }
protected async override Task <int> ExecuteInternalAsync() { Manifest manifest = await GetManifestAsync(); IEnumerable <ILibraryInstallationState> installedLibraries = ValidateParametersAndGetLibrariesToUninstall(manifest); if (installedLibraries == null || !installedLibraries.Any()) { Logger.Log(string.Format(Resources.Text.NoLibraryToUninstall, LibraryId.Value), LogLevel.Operation); return(0); } ILibraryInstallationState libraryToUninstall = null; if (installedLibraries.Count() > 1) { Logger.Log(string.Format(Resources.Text.MoreThanOneLibraryFoundToUninstall, LibraryId.Value), LogLevel.Operation); libraryToUninstall = LibraryResolver.ResolveLibraryByUserChoice(installedLibraries, HostEnvironment); } else { libraryToUninstall = installedLibraries.First(); } Task <bool> deleteFileAction(IEnumerable <string> s) => HostInteractions.DeleteFilesAsync(s, CancellationToken.None); string libraryId = LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(libraryToUninstall.Name, libraryToUninstall.Version, libraryToUninstall.ProviderId); ILibraryOperationResult result = await manifest.UninstallAsync(libraryToUninstall.Name, libraryToUninstall.Version, deleteFileAction, CancellationToken.None); if (result.Success) { await manifest.SaveAsync(Settings.ManifestFileName, CancellationToken.None); Logger.Log(string.Format(Resources.Text.UninstalledLibrary, libraryId), LogLevel.Operation); } else { Logger.Log(string.Format(Resources.Text.UninstallFailed, libraryId), LogLevel.Error); foreach (IError error in result.Errors) { Logger.Log($"[{error.Code}]: {error.Message}", LogLevel.Error); } } return(0); }
private async Task <IEnumerable <string> > GetFilesAsync(ILibraryInstallationState state) { if (state.Files == null) { ILibraryCatalog catalog = _dependencies.GetProvider(state.ProviderId)?.GetCatalog(); if (catalog != null) { ILibrary library = await catalog?.GetLibraryAsync(state.LibraryId, CancellationToken.None); return(library?.Files.Keys.ToList()); } } return(state.Files.Distinct()); }
private async Task <Stream> GetStreamAsync(ILibraryInstallationState state, string file, CancellationToken cancellationToken) { string sourceFile = state.Name; try { if (!Uri.TryCreate(sourceFile, UriKind.RelativeOrAbsolute, out Uri url)) { return(null); } if (!url.IsAbsoluteUri) { sourceFile = new FileInfo(Path.Combine(HostInteraction.WorkingDirectory, sourceFile)).FullName; if (!Uri.TryCreate(sourceFile, UriKind.Absolute, out url)) { return(null); } } // File if (url.IsFile) { if (Directory.Exists(url.OriginalString)) { return(await FileHelpers.ReadFileAsStreamAsync(Path.Combine(url.OriginalString, file), cancellationToken).ConfigureAwait(false)); } else { return(await FileHelpers.ReadFileAsStreamAsync(sourceFile, cancellationToken).ConfigureAwait(false)); } } // Url else { return(await GetRemoteResourceAsync(sourceFile)); } } catch (ResourceDownloadException) { throw; } catch (Exception) { throw new InvalidLibraryException(state.Name, state.ProviderId); } }
private async Task <IEnumerable <FileIdentifier> > GetFilesWithVersionsAsync(ILibraryInstallationState state) { ILibraryCatalog catalog = _dependencies.GetProvider(state.ProviderId)?.GetCatalog(); ILibrary library = await catalog?.GetLibraryAsync(state.LibraryId, CancellationToken.None); IEnumerable <FileIdentifier> filesWithVersions = new List <FileIdentifier>(); if (library != null && library.Files != null) { IEnumerable <string> desiredStateFiles = state?.Files?.Where(f => library.Files.Keys.Contains(f)); if (desiredStateFiles != null && desiredStateFiles.Any()) { filesWithVersions = desiredStateFiles.Select(f => new FileIdentifier(Path.Combine(state.DestinationPath, f), library.Version)); } } return(filesWithVersions); }
private async Task <string> GetLatestVersionAsync(ILibraryInstallationState libraryToUpdate, CancellationToken cancellationToken) { ILibraryCatalog catalog = ManifestDependencies.GetProvider(libraryToUpdate.ProviderId)?.GetCatalog(); if (catalog == null) { throw new InvalidOperationException(PredefinedErrors.LibraryIdIsUndefined().Message); } try { return(await catalog.GetLatestVersion(libraryToUpdate.LibraryId, PreRelease.HasValue(), cancellationToken)); } catch (Exception ex) { throw new InvalidOperationException(string.Format(Resources.UnableToFindLatestVersionForLibrary, libraryToUpdate.LibraryId), ex); } }
/// <summary> /// Adds a library to the <see cref="Libraries"/> collection. /// </summary> /// <param name="state">An instance of <see cref="ILibraryInstallationState"/> representing the library to add.</param> internal void AddLibrary(ILibraryInstallationState state) { ILibraryInstallationState existing = _libraries.Find(p => p.Name == state.Name && p.Version == state.Version && p.ProviderId == state.ProviderId); if (existing != null) { _libraries.Remove(existing); } if (state is LibraryInstallationState desiredState) { _libraries.Add(SetDefaultProviderIfNeeded(desiredState)); } else { _libraries.Add(state); } }
/// <summary>Internal use only</summary> public static LibraryInstallationState FromInterface(ILibraryInstallationState state, string defaultProviderId = null, string defaultDestination = null) { string normalizedProviderId = state.ProviderId ?? defaultProviderId; string normalizedDestinationPath = state.DestinationPath ?? defaultDestination; return(new LibraryInstallationState { Name = state.Name, Version = state.Version, ProviderId = normalizedProviderId, Files = state.Files, DestinationPath = normalizedDestinationPath, IsUsingDefaultDestination = state.IsUsingDefaultDestination, IsUsingDefaultProvider = state.IsUsingDefaultProvider }); }
private async Task <IEnumerable <FileIdentifier> > GetFilesWithVersionsAsync(ILibraryInstallationState state) { IEnumerable <FileIdentifier> filesWithVersions = new List <FileIdentifier>(); ILibraryCatalog catalog = _dependencies.GetProvider(state.ProviderId)?.GetCatalog(); if (catalog == null) { return(filesWithVersions); } ILibraryOperationResult validationResult = await state.IsValidAsync(_dependencies).ConfigureAwait(false); if (validationResult.Success) { IProvider provider = _dependencies.GetProvider(state.ProviderId); if (provider != null) { ILibraryOperationResult updatedStateResult = await provider.UpdateStateAsync(state, CancellationToken.None).ConfigureAwait(false); if (updatedStateResult.Success) { ILibrary library = await catalog.GetLibraryAsync(state.Name, state.Version, CancellationToken.None).ConfigureAwait(false); if (library != null && library.Files != null) { IEnumerable <string> desiredStateFiles = updatedStateResult.InstallationState.Files; if (desiredStateFiles != null && desiredStateFiles.Any()) { filesWithVersions = desiredStateFiles.Select(f => new FileIdentifier(Path.Combine(state.DestinationPath, f), library.Version)); } } } } } else { // Assert disabled due to breaking unit test execution. See: https://github.com/Microsoft/testfx/issues/561 //Debug.Assert(validationResult.Success); } return(filesWithVersions); }
public async Task <bool> WriteFileAsync(string path, Func <Stream> content, ILibraryInstallationState state, CancellationToken cancellationToken) { var absolutePath = new FileInfo(Path.Combine(WorkingDirectory, path)); if (absolutePath.Exists) { return(true); } if (!absolutePath.FullName.StartsWith(WorkingDirectory)) { throw new UnauthorizedAccessException(); } if (absolutePath.Exists && (absolutePath.Attributes & FileAttributes.ReadOnly) != 0) { return(true); } absolutePath.Directory.Create(); using (Stream stream = content.Invoke()) { if (stream == null) { return(false); } using (FileStream writer = File.Create(absolutePath.FullName, 4096, FileOptions.Asynchronous)) { if (stream.CanSeek) { stream.Seek(0, SeekOrigin.Begin); } await stream.CopyToAsync(writer, 8192, cancellationToken).ConfigureAwait(false); } } Logger.Log(string.Format(Resources.Text.FileWrittenToDisk, path.Replace('\\', '/')), LogLevel.Operation); return(true); }
/// <summary> /// Copy files from the download cache to the desired installation state /// </summary> /// <remarks>Precondition: all files must already exist in the cache</remarks> protected async Task <ILibraryOperationResult> WriteToFilesAsync(ILibraryInstallationState state, CancellationToken cancellationToken) { if (state.Files != null) { try { foreach (string file in state.Files) { if (cancellationToken.IsCancellationRequested) { return(LibraryOperationResult.FromCancelled(state)); } if (string.IsNullOrEmpty(file)) { string id = LibraryNamingScheme.GetLibraryId(state.Name, state.Version); return(new LibraryOperationResult(state, PredefinedErrors.FileNameMustNotBeEmpty(id))); } string sourcePath = GetCachedFileLocalPath(state, file); string destinationPath = Path.Combine(state.DestinationPath, file); bool writeOk = await HostInteraction.CopyFileAsync(sourcePath, destinationPath, cancellationToken); if (!writeOk) { return(new LibraryOperationResult(state, PredefinedErrors.CouldNotWriteFile(file))); } } } catch (UnauthorizedAccessException) { return(new LibraryOperationResult(state, PredefinedErrors.PathOutsideWorkingDirectory())); } catch (Exception ex) { HostInteraction.Logger.Log(ex.ToString(), LogLevel.Error); return(new LibraryOperationResult(state, PredefinedErrors.UnknownException())); } } return(LibraryOperationResult.FromSuccess(state)); }
/// <summary> /// Installs a library as specified in the <paramref name="desiredState" /> parameter. /// </summary> /// <param name="desiredState">The details about the library to install.</param> /// <param name="cancellationToken">A token that allows for the operation to be cancelled.</param> /// <returns> /// The <see cref="T:Microsoft.Web.LibraryInstaller.Contracts.ILibraryInstallationResult" /> from the installation process. /// </returns> public async Task <ILibraryInstallationResult> InstallAsync(ILibraryInstallationState desiredState, CancellationToken cancellationToken) { if (!desiredState.IsValid(out IEnumerable <IError> errors)) { return(new LibraryInstallationResult(desiredState, errors.ToArray())); } try { foreach (string file in desiredState.Files) { if (cancellationToken.IsCancellationRequested) { return(LibraryInstallationResult.FromCancelled(desiredState)); } string path = Path.Combine(desiredState.DestinationPath, file); var sourceStream = new Func <Stream>(() => GetStreamAsync(desiredState, file, cancellationToken).Result); bool writeOk = await HostInteraction.WriteFileAsync(path, sourceStream, desiredState, cancellationToken).ConfigureAwait(false); if (!writeOk) { return(new LibraryInstallationResult(desiredState, PredefinedErrors.CouldNotWriteFile(file))); } } } catch (Exception ex) when(ex is InvalidLibraryException || ex.InnerException is InvalidLibraryException) { return(new LibraryInstallationResult(desiredState, PredefinedErrors.UnableToResolveSource(desiredState.LibraryId, desiredState.ProviderId))); } catch (UnauthorizedAccessException) { return(new LibraryInstallationResult(desiredState, PredefinedErrors.PathOutsideWorkingDirectory())); } catch (Exception ex) { HostInteraction.Logger.Log(ex.ToString(), LogLevel.Error); return(new LibraryInstallationResult(desiredState, PredefinedErrors.UnknownException())); } return(LibraryInstallationResult.FromSuccess(desiredState)); }
private async Task <ILibraryOperationResult> WriteToFilesAsync(ILibraryInstallationState state, CancellationToken cancellationToken) { if (state.Files != null) { try { foreach (string file in state.Files) { if (cancellationToken.IsCancellationRequested) { return(LibraryOperationResult.FromCancelled(state)); } if (string.IsNullOrEmpty(file)) { return(new LibraryOperationResult(state, PredefinedErrors.CouldNotWriteFile(file))); } string destinationPath = Path.Combine(state.DestinationPath, file); var sourceStream = new Func <Stream>(() => GetStreamAsync(state, file, cancellationToken).Result); bool writeOk = await HostInteraction.WriteFileAsync(destinationPath, sourceStream, state, cancellationToken).ConfigureAwait(false); if (!writeOk) { return(new LibraryOperationResult(state, PredefinedErrors.CouldNotWriteFile(file))); } } } catch (UnauthorizedAccessException) { return(new LibraryOperationResult(state, PredefinedErrors.PathOutsideWorkingDirectory())); } catch (Exception ex) { HostInteraction.Logger.Log(ex.ToString(), LogLevel.Error); return(new LibraryOperationResult(state, PredefinedErrors.UnknownException())); } } return(LibraryOperationResult.FromSuccess(state)); }
private static void UpdateLibraryProviderAndDestination(ILibraryInstallationState state, string defaultProvider, string defaultDestination) { LibraryInstallationState libraryState = state as LibraryInstallationState; if (libraryState == null) { return; } if (state.ProviderId == null) { libraryState.ProviderId = defaultProvider; libraryState.IsUsingDefaultProvider = true; } if (libraryState.DestinationPath == null) { libraryState.DestinationPath = defaultDestination; libraryState.IsUsingDefaultDestination = true; } }
/// <summary> /// Validates <see cref="ILibraryInstallationState"/> /// </summary> /// <param name="state">The <see cref="ILibraryInstallationState"/> to validate.</param> /// <param name="dependencies">The <see cref="IDependencies"/> used to validate <see cref="ILibraryInstallationState"/></param> /// <returns><see cref="ILibraryOperationResult"/> with the result of the validation</returns> public static async Task <ILibraryOperationResult> IsValidAsync(this ILibraryInstallationState state, IDependencies dependencies) { if (state == null) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.UnknownError() })); } if (string.IsNullOrEmpty(state.ProviderId)) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.ProviderIsUndefined() })); } IProvider provider = dependencies.GetProvider(state.ProviderId); if (provider == null) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.ProviderUnknown(state.ProviderId) })); } return(await IsValidAsync(state, provider).ConfigureAwait(false)); }
public async Task TestResolveByUserChoiceAsync() { string libmanjsonPath = Path.Combine(WorkingDir, "libman.json"); File.WriteAllText(libmanjsonPath, _manifestContents); Manifest manifest = await Manifest.FromFileAsync( libmanjsonPath, _dependencies, CancellationToken.None); var inputReader = HostEnvironment.InputReader as TestInputReader; string outputStr = "Select an option:\r\n-----------------\r\n1. {[email protected], cdnjs, wwwroot}\r\n2. {[email protected], cdnjs, lib}\r\n3. {jquery, filesystem, wwwroot}"; inputReader.Inputs[outputStr] = "1"; ILibraryInstallationState result = LibraryResolver.ResolveLibraryByUserChoice(manifest.Libraries, HostEnvironment); Assert.AreEqual("[email protected]", result.LibraryId); }
/// <summary> /// Validates <see cref="ILibraryInstallationState"/> /// </summary> /// <param name="state">The <see cref="ILibraryInstallationState"/> to validate.</param> /// <param name="provider">The <see cref="IProvider"/> used to validate <see cref="ILibraryInstallationState"/></param> /// <returns><see cref="ILibraryOperationResult"/> with the result of the validation</returns> public static async Task <ILibraryOperationResult> IsValidAsync(this ILibraryInstallationState state, IProvider provider) { if (state == null) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.UnknownError() })); } if (provider == null) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.ProviderUnknown(provider.Id) })); } if (string.IsNullOrEmpty(state.Name)) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.LibraryIdIsUndefined() })); } ILibraryCatalog catalog = provider.GetCatalog(); try { await catalog.GetLibraryAsync(state.Name, state.Version, CancellationToken.None).ConfigureAwait(false); } catch { return(new LibraryOperationResult(state, new[] { PredefinedErrors.UnableToResolveSource(state.Name, state.Version, provider.Id) })); } if (string.IsNullOrEmpty(state.DestinationPath)) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.PathIsUndefined() })); } if (state.DestinationPath.IndexOfAny(Path.GetInvalidPathChars()) >= 0) { return(new LibraryOperationResult(state, new[] { PredefinedErrors.DestinationPathHasInvalidCharacters(state.DestinationPath) })); } return(LibraryOperationResult.FromSuccess(state)); }