コード例 #1
0
        public async void installPackagesFromProvidedAppSettingsFileAsync()
        {
            var serachResult = await _packageSearcher.GetSinglePackageMetaDataAsync();

            var                       identity = serachResult.Identity;
            var                       rootPath = @"myPathToTheFolder";
            ISettings                 settings = Settings.LoadDefaultSettings(rootPath, null, new MachineWideSettings());
            PackageSourceProvider     packageSourceProvider    = new PackageSourceProvider(settings);
            ISourceRepositoryProvider sourceRepositoryProvider =
                new SourceRepositoryProvider(packageSourceProvider, GetV3AndV2Providers());
            var    project      = new FolderNuGetProject(rootPath);
            string packagesPath = "...";
            NuGetPackageManager packageManager = new NuGetPackageManager(sourceRepositoryProvider, settings, packagesPath)
            {
                PackagesFolderNuGetProject = project
            };

            bool allowPrereleaseVersions = true;
            bool allowUnlisted           = false;

            ResolutionContext resolutionContext = new ResolutionContext(
                DependencyBehavior.Lowest, allowPrereleaseVersions, allowUnlisted, VersionConstraints.None);
            INuGetProjectContext projectContext = new DefaultProjectContext();

            IEnumerable <SourceRepository> sourceRepositories = Enumerable.Repeat(_packageSearcher.GetSourceRepository(), 1);
            await packageManager.InstallPackageAsync(packageManager.PackagesFolderNuGetProject,
                                                     identity, resolutionContext, projectContext, sourceRepositories,
                                                     Array.Empty <SourceRepository>(),
                                                     CancellationToken.None);
        }
コード例 #2
0
        static void Main(string[] args)
        {
            WriteInfo("".PadRight(79, '*'));
            WriteInfo("ezPacker, Copyright (C) 2016 Sascha-Christian Hensel");
            WriteInfo("ezPacker comes with ABSOLUTELY NO WARRANTY.");
            WriteInfo("This is free software, and you are welcome to redistribute it");
            WriteInfo("under certain conditions; see LICENSE.");
            WriteInfo("".PadRight(79, '*'));
            WriteInfo("");

            if (args.Length != 1)
            {
                WriteError("No configuration file given!");
            }
            else
            {
                FileInfo projectFile = new FileInfo(args[0]);

                WriteInfo("Trying to load configuration file '{0}'...", projectFile);

                IProject project = null;

                IProjectContext projectContext = new DefaultProjectContext(projectFile);

                IProjectParser parser = new XmlProjectParser();
                using (FileStream stream = projectFile.OpenRead())
                {
                    project = parser.Parse(projectContext, stream);
                }

                IMatcherContext context = new MatcherContext()
                {
                    Project = project
                };

                IFileCollector collector = new DefaultFileCollector();
                foreach (FileInfo item in Matcher.GetMatches(context))
                {
                    collector.Add(item);
                }

                WriteInfo("Success! Found  '{0}' possible file(s) to include for packing.", collector.Count);

                if (project.Replacements.Count == 0)
                {
                    WriteInfo("No files need to replaced.");
                }
                else
                {
                    WriteInfo("Trying to replace '{0}' file(s)...", project.Replacements.Count);

                    foreach (Replacement replacement in project.Replacements)
                    {
                        WriteInfo("  Attempt to replace file '{0}'...", replacement.FileName);
                        if (!replacement.Exists())
                        {
                            WriteWarning("  ... failed: replacement file '{0}' does not exist!", replacement.ReplacementFile.FullName);
                            continue;
                        }

                        bool replaced = collector.Replace(context, replacement.FileName, replacement.ReplacementFile, replacement.Mode);
                        if (replaced)
                        {
                            WriteInfo("  ... succeeded!");
                        }
                        else
                        {
                            WriteWarning("  ... failed: file to be replaced wasn't found in list of files to be packed.");
                        }
                    }

                    WriteInfo("Replacement procedure completed.");
                }

                WriteInfo("Begin packing...");

                if (!project.OutPath.Exists)
                {
                    project.OutPath.Create();
                }

                string outputFilePath = Path.Combine(project.OutPath.FullName, project.PackedName + ".zip");

                using (IPacker packer = new ZipPacker())
                {
                    foreach (var pair in collector.GetAll())
                    {
                        if (pair.Item2.FullName == outputFilePath)
                        {
                            continue;
                        }

                        string archiveFileName = context.GetRelativePath(pair.Item1.FullName);

                        packer.Add(archiveFileName, pair.Item2.OpenRead());

                        WriteInfo("  Added '{0}'.", archiveFileName);
                    }

                    WriteInfo("Writing archive to '{0}'...", outputFilePath);

                    using (FileStream output = new FileStream(outputFilePath, FileMode.Create, FileAccess.Write, FileShare.Read))
                    {
                        packer.Save(output);
                    }

                    WriteInfo("... success!");
                }
            }

            WriteInfo("");

            if (Properties.Settings.Default.InteractiveMode)
            {
                WriteInfo("");
                WriteInfo("Press any key to quit . . .");
                Console.ReadKey();
            }
        }