Example #1
0
        public Package ScanPackageDirectory(string directory)
        {
            try
            {
                var headerPath = Path.Combine(directory, "pkg.json");

                Package discoveredPkg;

                // get the package name and the installed version
                if (File.Exists(headerPath))
                {
                    discoveredPkg = Package.FromJson(headerPath, AsLogger());
                    if (discoveredPkg == null)
                    {
                        throw new Exception(String.Format(Properties.Resources.MalformedHeaderPackage, headerPath));
                    }
                }
                else
                {
                    throw new Exception(String.Format(Properties.Resources.NoHeaderPackage, headerPath));
                }

                // prevent duplicates
                if (LocalPackages.All(pkg => pkg.Name != discoveredPkg.Name))
                {
                    this.Add(discoveredPkg);
                    return(discoveredPkg); // success
                }
                throw new Exception(String.Format(Properties.Resources.DulicatedPackage, discoveredPkg.Name, discoveredPkg.RootDirectory));
            }
            catch (Exception e)
            {
                Log(String.Format(Properties.Resources.ExceptionEncountered, directory), WarningLevel.Error);
                Log(e);
            }

            return(null);
        }
Example #2
0
        /// <summary>
        /// This method is called when custom nodes and packages need to be reloaded if there are new package paths.
        /// </summary>
        /// <param name="newPaths"></param>
        /// <param name="preferences"></param>
        /// <param name="customNodeManager"></param>
        public void LoadCustomNodesAndPackages(IEnumerable <string> newPaths, IPreferences preferences, CustomNodeManager customNodeManager)
        {
            foreach (var path in preferences.CustomPackageFolders)
            {
                // Append the definitions subdirectory for custom nodes.
                var dir = path == DynamoModel.BuiltInPackagesToken ? PathManager.BuiltinPackagesDirectory : path;
                dir = TransformPath(dir, PathManager.DefinitionsDirectoryName);

                customNodeManager.AddUninitializedCustomNodesInPath(dir, false, false);
            }

            foreach (var path in newPaths)
            {
                var packageDirectory = pathManager.PackagesDirectories.FirstOrDefault(x => x.StartsWith(path));
                if (packageDirectory != null)
                {
                    ScanPackageDirectories(packageDirectory, preferences);
                }
            }

            if (pathManager != null)
            {
                foreach (var pkg in LocalPackages)
                {
                    if (Directory.Exists(pkg.BinaryDirectory))
                    {
                        pathManager.AddResolutionPath(pkg.BinaryDirectory);
                    }
                }
            }

            if (LocalPackages.Any())
            {
                // Load only those recently addeed local packages (that are located in any of the new paths)
                var newPackages = LocalPackages.Where(x => newPaths.Any(y => x.RootDirectory.Contains(y)));
                LoadPackages(newPackages);
            }
        }
Example #3
0
        public async Task <bool> Execute()
        {
            Reports       = Options.Reports;
            LocalPackages = Options.SourcePackages ??
                            NuGetDependencyResolver.ResolveRepositoryPath(Directory.GetCurrentDirectory());

            Options.Reports.Quiet.WriteLine(string.Format("Adding NuGet package {0} to {1}",
                                                          Options.NuGetPackage.Bold(), LocalPackages.Bold()));

            var sw = new Stopwatch();

            sw.Start();

            var library = NuGetPackageUtils.CreateLibraryFromNupkg(Options.NuGetPackage);

            using (var stream = File.OpenRead(Options.NuGetPackage))
            {
                string packageHash = null;
                if (!string.IsNullOrEmpty(Options.PackageHashFilePath) && File.Exists(Options.PackageHashFilePath))
                {
                    packageHash = File.ReadAllText(Options.PackageHashFilePath);
                }
                else if (!string.IsNullOrEmpty(Options.PackageHash))
                {
                    packageHash = Options.PackageHash;
                }

                await NuGetPackageUtils.InstallFromStream(stream, library, LocalPackages, Reports.Quiet, packageHash);
            }

            Reports.Quiet.WriteLine(
                "{0}, {1}ms elapsed",
                "Add complete".Green().Bold(),
                sw.ElapsedMilliseconds);

            return(true);
        }
Example #4
0
 public Package GetOwnerPackage(string path)
 {
     return(LocalPackages.FirstOrDefault(ele => ele.ContainsFile(path)));
 }
Example #5
0
 public Package GetOwnerPackage(Type t)
 {
     return(LocalPackages.FirstOrDefault(package => package.LoadedTypes.Contains(t)));
 }
Example #6
0
 public Package GetPackageFromRoot(string path)
 {
     return(LocalPackages.FirstOrDefault(pkg => pkg.RootDirectory == path));
 }
Example #7
0
 public bool IsUnderPackageControl(Assembly t)
 {
     return(LocalPackages.Any(package => package.LoadedAssemblies.Any(x => x.Assembly == t)));
 }
Example #8
0
 public bool IsUnderPackageControl(Type t)
 {
     return(LocalPackages.Any(package => package.LoadedTypes.Contains(t)));
 }
Example #9
0
 public bool IsUnderPackageControl(string path)
 {
     return(LocalPackages.Any(ele => ele.ContainsFile(path)));
 }
Example #10
0
        public Package ScanPackageDirectory(string directory, bool checkCertificates)
        {
            try
            {
                var headerPath = Path.Combine(directory, "pkg.json");

                Package discoveredPackage;

                // get the package name and the installed version
                if (PathHelper.IsValidPath(headerPath))
                {
                    discoveredPackage = Package.FromJson(headerPath, AsLogger());
                    if (discoveredPackage == null)
                    {
                        throw new LibraryLoadFailedException(directory, String.Format(Properties.Resources.MalformedHeaderPackage, headerPath));
                    }
                }
                else
                {
                    throw new LibraryLoadFailedException(directory, String.Format(Properties.Resources.NoHeaderPackage, headerPath));
                }

                // prevent loading unsigned packages if the certificates are required on package dlls
                if (checkCertificates)
                {
                    CheckPackageNodeLibraryCertificates(directory, discoveredPackage);
                }

                var discoveredVersion = CheckAndGetPackageVersion(discoveredPackage.VersionName, discoveredPackage.Name, discoveredPackage.RootDirectory);

                var existingPackage = LocalPackages.FirstOrDefault(package =>
                                                                   (package.Name == discoveredPackage.Name) &&
                                                                   (package.LoadState.State != PackageLoadState.StateTypes.Unloaded));

                // Is this a new package?
                if (existingPackage == null)
                {
                    Add(discoveredPackage);
                    return(discoveredPackage); // success
                }

                // Conflict invloving a built-in package
                if (discoveredPackage.BuiltInPackage || existingPackage.BuiltInPackage)
                {
                    // We show both packages but we mark the new one as unloaded.
                    discoveredPackage.LoadState.SetAsUnloaded();
                    Add(discoveredPackage);
                }

                var existingVersion = CheckAndGetPackageVersion(existingPackage.VersionName, existingPackage.Name, existingPackage.RootDirectory);

                // Is this a duplicated package?
                if (existingVersion == discoveredVersion)
                {
                    // Duplicated with the same version
                    throw new LibraryLoadFailedException(directory,
                                                         String.Format(Properties.Resources.DulicatedPackage,
                                                                       discoveredPackage.Name,
                                                                       discoveredPackage.RootDirectory));
                }

                // Is the existing version newer?
                if (existingVersion > discoveredVersion)
                {
                    // Older version found, show notification
                    throw new LibraryLoadFailedException(directory, String.Format(Properties.Resources.DuplicatedOlderPackage,
                                                                                  existingPackage.Name,
                                                                                  discoveredPackage.RootDirectory,
                                                                                  existingVersion.ToString(),
                                                                                  discoveredVersion.ToString()));
                }

                // Newer version found, show notification.
                throw new LibraryLoadFailedException(directory, String.Format(Properties.Resources.DuplicatedNewerPackage,
                                                                              existingPackage.Name,
                                                                              discoveredPackage.RootDirectory,
                                                                              existingVersion.ToString(),
                                                                              discoveredVersion.ToString()));
            }
            catch (Exception e)
            {
                Log(String.Format(Properties.Resources.ExceptionEncountered, directory), WarningLevel.Error);
                Log(e);
            }

            return(null);
        }
Example #11
0
        public bool Execute()
        {
            Reports       = Options.Reports;
            LocalPackages = Options.SourcePackages ?? Directory.GetCurrentDirectory();

            Options.Reports.Information.WriteLine(string.Format("Committing artifacts in {0}", LocalPackages.Bold()));

            var sw = new Stopwatch();

            sw.Start();

            var local = new FileSystemRepositoryPublisher(LocalPackages)
            {
                Reports = Reports
            };

            // Read entire index starting with 1
            var index = local.MergeRepositoryChangeRecordsStartingWithIndex(1);

            if (index == null)
            {
                // no index at all - provide a fake "empty before 1" record
                index = new RepositoryChangeRecord
                {
                    Next   = 1,
                    Add    = new string[0],
                    Remove = new string[0],
                };
            }

            // Read file system
            var artifacts = local.EnumerateArtifacts(FolderPredicate, FilePredicate);

            // Determine difference of index and file system
            var record = new RepositoryChangeRecord
            {
                Next   = index.Next + 1,
                Add    = artifacts.Except(index.Add).ToArray(),
                Remove = index.Add.Except(artifacts).ToArray()
            };

            // Create new index entry if not empty
            if (record.Add.Any() || record.Remove.Any())
            {
                Reports.Information.WriteLine(
                    "Creating record #{0}, {1} artifacts added, {2} artifacts removed",
                    index.Next,
                    record.Add.Count(),
                    record.Remove.Count());

                local.ApplyFileChanges(record);

                local.StoreRepositoryChangeRecord(index.Next, record);
            }

            Reports.Information.WriteLine(
                "{0}, {1}ms elapsed",
                "Commit complete".Green().Bold(),
                sw.ElapsedMilliseconds);

            return(true);
        }
Example #12
0
        public bool Execute()
        {
            Reports        = Options.Reports;
            LocalPackages  = Options.SourcePackages ?? Directory.GetCurrentDirectory();
            RemotePackages = Options.RemotePackages;

            Options.Reports.Information.WriteLine(
                "Pushing artifacts");
            Options.Reports.Information.WriteLine(
                "  from {0}",
                LocalPackages.Bold());
            Options.Reports.Information.WriteLine(
                "  to {0}",
                RemotePackages.Bold());

            var sw = new Stopwatch();

            sw.Start();

            IRepositoryPublisher local = new FileSystemRepositoryPublisher(
                LocalPackages);

            IRepositoryPublisher remote = RepositoryPublishers.Create(
                RemotePackages,
                Reports);

            // Recall what index to start pushing to remote
            var transmitRecord = FillOut(local.GetRepositoryTransmitRecord());

            int nextIndex;

            if (!transmitRecord.Push.TryGetValue(RemotePackages, out nextIndex))
            {
                nextIndex = 1;
            }

            // Read change index from that point forward
            var changeRecord = FillOut(local.MergeRepositoryChangeRecordsStartingWithIndex(nextIndex));

            if (!changeRecord.Add.Any() &&
                !changeRecord.Remove.Any())
            {
                Reports.Information.WriteLine("There are no changes to push");
            }
            else
            {
                Reports.Information.WriteLine(
                    "Pushing {0} added and {1} removed artifacts",
                    changeRecord.Add.Count().ToString().Bold(),
                    changeRecord.Remove.Count().ToString().Bold());

                // We now know where to start from next time
                transmitRecord.Push[RemotePackages] = changeRecord.Next;

                // Determine the latest remote change number
                var remoteZeroRecord = FillOut(remote.GetRepositoryChangeRecord(0));
                var remoteIndexNext  = remoteZeroRecord.Next;

                // Point remote records to point to the following remote change number
                changeRecord.Next     = remoteIndexNext + 1;
                remoteZeroRecord.Next = remoteIndexNext + 1;

                // Apply the file changes to remote
                remote.ApplyFileChanges(changeRecord, local);

                // Correct /{id}/{version}/$index.json files based on file changes

                // Commit new change record to remote
                remote.StoreRepositoryChangeRecord(0, remoteZeroRecord);
                remote.StoreRepositoryChangeRecord(remoteIndexNext, changeRecord);

                // Locally commit where to push remotely next
                local.StoreRepositoryTransmitRecord(transmitRecord);
            }

            Reports.Information.WriteLine(
                "{0}, {1}ms elapsed",
                "Push complete".Green().Bold(),
                sw.ElapsedMilliseconds);

            return(true);
        }
Example #13
0
        /// <summary>
        /// Saves all packages and assets.
        /// </summary>
        /// <param name="log">The <see cref="LoggerResult"/> in which to report result.</param>
        public void Save(LoggerResult log)
        {
            bool packagesSaved = false;

            //var clock = Stopwatch.StartNew();
            using (var profile = Profiler.Begin(PackageSessionProfilingKeys.Saving))
            {
                try
                {
                    // Grab all previous assets
                    var previousAssets = new Dictionary <Guid, AssetItem>();
                    foreach (var assetItem in packagesCopy.SelectMany(package => package.Assets))
                    {
                        previousAssets[assetItem.Id] = assetItem;
                    }

                    // Grab all new assets
                    var newAssets = new Dictionary <Guid, AssetItem>();
                    foreach (var assetItem in LocalPackages.SelectMany(package => package.Assets))
                    {
                        newAssets[assetItem.Id] = assetItem;
                    }

                    // Compute all assets that were removed
                    var assetsOrPackagesToRemove = new Dictionary <UFile, object>();
                    foreach (var assetIt in previousAssets)
                    {
                        var asset = assetIt.Value;

                        AssetItem newAsset;
                        if (!newAssets.TryGetValue(assetIt.Key, out newAsset) || newAsset.Location != asset.Location)
                        {
                            assetsOrPackagesToRemove[asset.FullPath] = asset;
                        }
                    }

                    // Compute packages that have been renamed
                    // TODO: Disable for now, as not sure if we want to delete a previous package
                    //foreach (var package in packagesCopy)
                    //{
                    //    var newPackage = packages.Find(package.Id);
                    //    if (newPackage != null && package.PackagePath != null && newPackage.PackagePath != package.PackagePath)
                    //    {
                    //        assetsOrPackagesToRemove[package.PackagePath] = package;
                    //    }
                    //}

                    // If package are not modified, return immediately
                    if (!CheckModifiedPackages() && assetsOrPackagesToRemove.Count == 0)
                    {
                        return;
                    }

                    // Suspend tracking when saving as we don't want to receive
                    // all notification events
                    if (dependencies != null)
                    {
                        dependencies.BeginSavingSession();
                    }

                    // Return immediately if there is any error
                    if (log.HasErrors)
                    {
                        return;
                    }

                    // Delete previous files
                    foreach (var fileIt in assetsOrPackagesToRemove)
                    {
                        var assetPath          = fileIt.Key;
                        var assetItemOrPackage = fileIt.Value;

                        if (File.Exists(assetPath))
                        {
                            try
                            {
                                File.Delete(assetPath);
                            }
                            catch (Exception ex)
                            {
                                var assetItem = assetItemOrPackage as AssetItem;
                                if (assetItem != null)
                                {
                                    log.Error(assetItem.Package, assetItem.ToReference(), AssetMessageCode.AssetCannotDelete, ex, assetPath);
                                }
                                else
                                {
                                    var package = assetItemOrPackage as Package;
                                    if (package != null)
                                    {
                                        log.Error(package, null, AssetMessageCode.AssetCannotDelete, ex, assetPath);
                                    }
                                }
                            }
                        }
                    }

                    // Save all dirty assets
                    packagesCopy.Clear();
                    foreach (var package in LocalPackages)
                    {
                        // Save the package to disk and all its assets
                        package.Save(log);

                        // Clone the package (but not all assets inside, just the structure)
                        var packageClone = package.Clone(false);
                        packagesCopy.Add(packageClone);
                    }

                    packagesSaved = true;
                }
                finally
                {
                    if (dependencies != null)
                    {
                        dependencies.EndSavingSession();
                    }

                    // Once all packages and assets have been saved, we can save the solution (as we need to have fullpath to
                    // be setup for the packages)
                    if (packagesSaved)
                    {
                        PackageSessionHelper.SaveSolution(this, log);
                    }
                }

                //System.Diagnostics.Trace.WriteLine("Elapsed saved: " + clock.ElapsedMilliseconds);
                IsDirty = false;
            }
        }
Example #14
0
 public void UpdateLocalDependency(BaseVersion dependency)
 {
     CurrentLocalDependency = dependency == null
         ? _globalJoker
         : (LocalPackages.FirstOrDefault(x => x.Equals(dependency)) ?? _globalJoker);
 }
Example #15
0
 private async Task UpdateNuGetInfoAsync(NuGetExecutor nuGetExecutor)
 {
     await Task.WhenAll(LocalPackages.Select(t => Task.Run(() => nuGetExecutor.Update(t))));
 }
Example #16
0
        public async Task <bool> Execute()
        {
            Reports       = Options.Reports;
            LocalPackages = Options.SourcePackages ??
                            NuGetDependencyResolver.ResolveRepositoryPath(Directory.GetCurrentDirectory());

            Options.Reports.Information.WriteLine(string.Format("Adding NuGet package {0} to {1}",
                                                                Options.NuGetPackage.Bold(), LocalPackages.Bold()));

            var sw = new Stopwatch();

            sw.Start();

            var library = NuGetPackageUtils.CreateLibraryFromNupkg(Options.NuGetPackage);

            using (var sha512 = SHA512.Create())
                using (var stream = File.OpenRead(Options.NuGetPackage))
                {
                    Reports.Information.WriteLine("Installing {0} {1}", library.Name.Bold(), library.Version);
                    await NuGetPackageUtils.InstallFromStream(stream, library, LocalPackages, sha512);
                }

            Reports.Information.WriteLine(
                "{0}, {1}ms elapsed",
                "Add complete".Green().Bold(),
                sw.ElapsedMilliseconds);

            return(true);
        }