Пример #1
0
 /// <summary>
 /// Restore package lock
 /// </summary>
 static async Task RestorePackageLockAsync(
     Path packagesDirectory,
     Path stagingDirectory,
     PackageLock packageLock)
 {
     foreach (var languageProjects in packageLock.GetProjects())
     {
         foreach (var project in languageProjects.Value.AsList())
         {
             var projectTable     = project.AsTable();
             var packageReference = PackageReference.Parse(projectTable["Version"].AsString());
             if (!packageReference.IsLocal)
             {
                 await EnsurePackageDownloadedAsync(
                     languageProjects.Key,
                     packageReference.GetName,
                     packageReference.Version,
                     packagesDirectory,
                     stagingDirectory);
             }
         }
     }
 }
Пример #2
0
        /// <summary>
        /// Restore packages
        /// </summary>
        public static async Task RestorePackagesAsync(Path workingDirectory)
        {
            var packageStore = LifetimeManager.Get <IFileSystem>().GetUserProfileDirectory() +
                               new Path(".soup/packages/");

            Log.Diag("Using Package Store: " + packageStore.ToString());

            // Create the staging directory
            var stagingPath = EnsureStagingDirectoryExists(packageStore);

            try
            {
                var packageLockPath =
                    workingDirectory +
                    BuildConstants.PackageLockFileName;
                var loadPackageLock = await PackageLockExtensions.TryLoadFromFileAsync(packageLockPath);

                if (loadPackageLock.IsSuccess)
                {
                    Log.Info("Restore from package lock");
                    await RestorePackageLockAsync(
                        packageStore,
                        stagingPath,
                        loadPackageLock.Result);
                }
                else
                {
                    Log.Info("Discovering full closure");
                    var closure = new Dictionary <string, IDictionary <string, PackageReference> >();
                    await CheckRestoreRecursiveDependenciesAsync(
                        workingDirectory,
                        packageStore,
                        stagingPath,
                        closure);

                    // Build up the package lock file
                    var packageLock = new PackageLock();
                    foreach (var languageClosure in closure)
                    {
                        foreach (var package in languageClosure.Value)
                        {
                            Log.Diag($"{languageClosure.Key} {package.Key} -> {package.Value}");
                            packageLock.AddProject(languageClosure.Key, package.Key, package.Value.ToString());
                        }
                    }

                    // Save the updated package lock
                    await PackageLockExtensions.SaveToFileAsync(packageLockPath, packageLock);
                }

                // Cleanup the working directory
                Log.Diag("Deleting staging directory");
                LifetimeManager.Get <IFileSystem>().DeleteDirectory(stagingPath, true);
            }
            catch (Exception)
            {
                // Cleanup the staging directory and accept that we failed
                LifetimeManager.Get <IFileSystem>().DeleteDirectory(stagingPath, true);
                throw;
            }
        }