protected async Task <Manifest> CreateManifestAsync(string defaultProvider,
string defaultDestination,
EnvironmentSettings settings,
CancellationToken cancellationToken)
{
if (File.Exists(Settings.ManifestFileName))
{
throw new InvalidOperationException(Resources.Text.InitFailedLibmanJsonFileExists);
}
Manifest manifest = await Manifest.FromFileAsync(Settings.ManifestFileName, ManifestDependencies, cancellationToken);
manifest.AddVersion(Manifest.SupportedVersions.Last().ToString());
manifest.DefaultDestination = string.IsNullOrEmpty(defaultDestination) ? null : defaultDestination;
defaultProvider = string.IsNullOrEmpty(defaultProvider)
? HostEnvironment.InputReader.GetUserInputWithDefault(nameof(settings.DefaultProvider), settings.DefaultProvider)
: defaultProvider;
if (ManifestDependencies.GetProvider(defaultProvider) == null)
{
IError unknownProviderError = PredefinedErrors.ProviderUnknown(defaultProvider);
string message = string.Format(Resources.Text.InitFailedUnknownProvider, unknownProviderError.Code, unknownProviderError.Message);
throw new InvalidOperationException(message);
}
manifest.DefaultProvider = defaultProvider;
await manifest.SaveAsync(Settings.ManifestFileName, cancellationToken);
return(manifest);
}
private async Task <ILibraryOperationResult> RestoreLibraryAsync(ILibraryInstallationState libraryState, CancellationToken cancellationToken)
{
string libraryId = LibraryIdToNameAndVersionConverter.Instance.GetLibraryId(libraryState.Name, libraryState.Version, libraryState.ProviderId);
_hostInteraction.Logger.Log(string.Format(Resources.Text.Restore_RestoreOfLibraryStarted, libraryId, libraryState.DestinationPath), LogLevel.Operation);
if (cancellationToken.IsCancellationRequested)
{
return(LibraryOperationResult.FromCancelled(libraryState));
}
IProvider provider = _dependencies.GetProvider(libraryState.ProviderId);
if (provider == null)
{
return(new LibraryOperationResult(libraryState, new IError[] { PredefinedErrors.ProviderUnknown(libraryState.ProviderId) }));
}
try
{
return(await provider.InstallAsync(libraryState, cancellationToken).ConfigureAwait(false));
}
catch (OperationCanceledException)
{
return(LibraryOperationResult.FromCancelled(libraryState));
}
}
public void Predefined()
{
TestError(PredefinedErrors.UnknownException(), "LIB000");
TestError(PredefinedErrors.ProviderUnknown("_prov_"), "LIB001", "_prov_");
TestError(PredefinedErrors.UnableToResolveSource("_libid_", "_prov_"), "LIB002", "_libid_", "_prov_");
TestError(PredefinedErrors.CouldNotWriteFile("file.js"), "LIB003", "file.js");
TestError(PredefinedErrors.ManifestMalformed(), "LIB004");
}
/// <summary>
/// Restores all libraries in the <see cref="Libraries"/> collection.
/// </summary>
/// <param name="cancellationToken">A token that allows for cancellation of the operation.</param>
public async Task <IEnumerable <ILibraryInstallationResult> > RestoreAsync(CancellationToken cancellationToken)
{
//TODO: This should have an "undo scope"
var results = new List <ILibraryInstallationResult>();
var tasks = new List <Task <ILibraryInstallationResult> >();
if (!IsValidManifestVersion(Version))
{
results.Add(LibraryInstallationResult.FromErrors(new IError[] { PredefinedErrors.VersionIsNotSupported(Version) }));
return(results);
}
foreach (ILibraryInstallationState state in Libraries)
{
if (cancellationToken.IsCancellationRequested)
{
results.Add(LibraryInstallationResult.FromCancelled(state));
_hostInteraction.Logger.Log(Resources.Text.RestoreCancelled, LogLevel.Task);
return(results);
}
if (!state.IsValid(out IEnumerable <IError> errors))
{
results.Add(new LibraryInstallationResult(state, errors.ToArray()));
continue;
}
_hostInteraction.Logger.Log(string.Format(Resources.Text.RestoringLibrary, state.LibraryId), LogLevel.Operation);
IProvider provider = _dependencies.GetProvider(state.ProviderId);
if (provider != null)
{
tasks.Add(provider.InstallAsync(state, cancellationToken));
}
else
{
results.Add(new LibraryInstallationResult(state, PredefinedErrors.ProviderUnknown(state.ProviderId)));
}
}
await Task.WhenAll(tasks).ConfigureAwait(false);
results.AddRange(tasks.Select(t => t.Result));
return(results);
}
/// <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));
}
/// <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));
}
/// <summary>
/// Installs a library with the given libraryId
/// </summary>
/// <param name="libraryName"></param>
/// <param name="version"></param>
/// <param name="providerId"></param>
/// <param name="files"></param>
/// <param name="destination"></param>
/// <param name="cancellationToken"></param>
/// <returns></returns>
public async Task <IEnumerable <ILibraryOperationResult> > InstallLibraryAsync(
string libraryName,
string version,
string providerId,
IReadOnlyList <string> files,
string destination,
CancellationToken cancellationToken)
{
ILibraryOperationResult result;
var desiredState = new LibraryInstallationState()
{
Name = libraryName,
Version = version,
Files = files,
ProviderId = providerId,
DestinationPath = destination
};
UpdateLibraryProviderAndDestination(desiredState, DefaultProvider, DefaultDestination);
ILibraryOperationResult validationResult = await desiredState.IsValidAsync(_dependencies);
if (!validationResult.Success)
{
return(new [] { validationResult });
}
IProvider provider = _dependencies.GetProvider(desiredState.ProviderId);
if (provider == null)
{
return(new [] { new LibraryOperationResult(desiredState, new IError[] { PredefinedErrors.ProviderUnknown(desiredState.ProviderId) }) });
}
IEnumerable <ILibraryOperationResult> conflictResults = await CheckLibraryForConflictsAsync(desiredState, cancellationToken).ConfigureAwait(false);
if (!conflictResults.All(r => r.Success))
{
return(conflictResults);
}
result = await provider.InstallAsync(desiredState, cancellationToken).ConfigureAwait(false);
if (result.Success)
{
AddLibrary(desiredState);
}
return(new [] { result });
}