Esempio n. 1
0
        public static async System.Threading.Tasks.Task PublishAsync(
            TaskLoggingHelper log,
            string symbolServerPath,
            string personalAccessToken,
            IEnumerable <string> inputPackages,
            IEnumerable <string> inputFiles,
            HashSet <string> packageExcludeFiles,
            int expirationInDays,
            bool convertPortablePdbsToWindowsPdbs,
            bool publishSpecialClrFiles,
            HashSet <int> pdbConversionTreatAsWarning,
            bool treatPdbConversionIssuesAsInfo,
            bool dryRun,
            bool timer,
            bool verboseLogging)
        {
            var tracer = new Tracer(log, verboseLogging);

            PublishOperation publishOperation = new PublishOperation(tracer)
            {
                SymbolServerPath            = symbolServerPath,
                PersonalAccessToken         = personalAccessToken,
                PdbConversionTreatAsWarning = pdbConversionTreatAsWarning,
                PublishSpecialClrFiles      = publishSpecialClrFiles,
                Timer = timer,
                TreatPdbConversionIssuesAsInfo = treatPdbConversionIssuesAsInfo
            };

            using (publishOperation)
            {
                if (expirationInDays != 0)
                {
                    publishOperation.ExpirationInDays = (uint)expirationInDays;
                }

                IEnumerable <PublishFileInfo> fileInfos = new PublishFileInfo[0];
                if (inputFiles != null)
                {
                    fileInfos = fileInfos.Concat(
                        publishOperation.GetPublishFileInfo(inputFiles, convertPortablePdbsToWindowsPdbs));
                }

                if (inputPackages != null)
                {
                    fileInfos = fileInfos.Concat(
                        publishOperation.GetPublishFileInfoFromPackages(inputPackages,
                                                                        convertPortablePdbsToWindowsPdbs));
                }

                if (packageExcludeFiles != null)
                {
                    publishOperation.PackageExcludeFiles = packageExcludeFiles;
                }

                if (dryRun)
                {
                    publishOperation.StartTimer();
                    try
                    {
                        foreach (PublishFileInfo fileInfo in fileInfos)
                        {
                            fileInfo.Dispose();
                        }
                    }
                    catch (Exception ex)
                    {
                        tracer.Error("Dry Run FAILED: {0}", ex.Message);
                        tracer.Information(ex.ToString());
                    }

                    publishOperation.StopTimer();
                }
                else
                {
                    try
                    {
                        await publishOperation.PublishFiles(fileInfos);
                    }
                    catch (Exception ex)
                    {
                        tracer.Error("Publishing symbols failed : ", ex.Message);
                        tracer.Information(ex.ToString());
                    }
                }
            }
        }