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