private static string FetchNuGetApiKeyFromEnvVariable(ITaskContextInternal context, string environmentVariableName = DefaultNuGetApiKeyEnvVariable)
        {
            string apiKey = Environment.GetEnvironmentVariable(environmentVariableName);

            if (string.IsNullOrEmpty(apiKey))
            {
                context.Fail($"NuGet API key environment variable ('{environmentVariableName}') does not exist, cannot publish the package.", 1);
                return(null);
            }

            return(apiKey);
        }
Example #2
0
        protected override int DoExecute(ITaskContextInternal context)
        {
            var findPackageTask = new FindNuGetPackageInUserRepositoryTask(_packageId);

            findPackageTask.Execute(context);

            if (findPackageTask.PackageVersion != null && _packageVersion != null &&
                findPackageTask.PackageVersion > _packageVersion)
            {
                PackageDirectory = findPackageTask.PackageDirectory;
                return(0);
            }

            if (findPackageTask.PackageDirectory != null)
            {
                PackageDirectory = findPackageTask.PackageDirectory;
                return(0);
            }

            var task = new NuGetCmdLineTask("install")
                       .WithArguments(_packageId)
                       .WithArguments($"-Source {PackageSource}")
                       .WithArguments("-NonInteractive")
                       .WithArguments($"-OutputDirectory {NuGetPackagesCacheDir}");

            if (_packageVersion != null)
            {
                task.WithArguments($"-Version {_packageVersion}");
            }

            if (ConfigFile != null)
            {
                task.WithArguments($"-ConfigFile {ConfigFile}");
            }

            if (Verbosity.HasValue)
            {
                task.Verbosity = Verbosity.Value;
            }

            task.Execute(context);

            findPackageTask.Execute(context);
            PackageDirectory = findPackageTask.PackageDirectory;

            context.LogError(
                PackageDirectory == null
                    ? $"Something is wrong, after downloading it the NuGet package '{_packageId}' still could not be found."
                    : "Package downloaded to '{packageDirectory}'");

            return(0);
        }
Example #3
0
        protected override void BeforeExecute(ITaskContextInternal context, IRunProgramTask runProgramTask)
        {
            if (!GetArguments().Exists(x => x == "-c" || x == "--configuration"))
            {
                var configuration = context.Properties.Get <string>(BuildProps.BuildConfiguration, null);
                if (configuration != null)
                {
                    Configuration(configuration);
                }
            }

            base.BeforeExecute(context, runProgramTask);
        }
Example #4
0
        protected override GitVersion DoExecute(ITaskContextInternal context)
        {
            base.DoExecute(context);

            if (!string.IsNullOrEmpty(ProgramOutput))
            {
                var gitVersion = JsonConvert.DeserializeObject <GitVersion>(ProgramOutput);
                context.Properties.Set(BuildProps.BuildVersion, new Version(gitVersion.AssemblySemVer));
                return(gitVersion);
            }

            return(null);
        }
Example #5
0
        private void TasksHelp(ITaskContextInternal context)
        {
            context.LogInfo("Tasks:");

            // first sort the targets
            IEnumerable <ITask> tasks = _provider.GetServices <ITask>();

            // now display them in sorted order
            foreach (ITask task in tasks)
            {
                context.LogInfo($"  {task.GetType().FullName}");
            }
        }
Example #6
0
        protected override int DoExecute(ITaskContextInternal context)
        {
            StringBuilder builder = new StringBuilder();

            for (int i = 0; i < _sourceFiles.Count; i++)
            {
                string file    = _sourceFiles[i];
                string current = File.ReadAllText(file);
            }

            File.WriteAllText(_destinationConfiguration, builder.ToString(), Encoding.UTF8);
            return(0);
        }
Example #7
0
        protected override int DoExecute(ITaskContextInternal context)
        {
            _packagePath.MustNotBeNullOrEmpty("packagePath (path to .nupkg) must not be null or empty.");

            // do not push new packages from a local build
            if (context.BuildServers().IsLocalBuild&& _skipPushOnLocalBuild)
            {
                context.LogInfo("pushing package on local build is disabled in build script...Skiping.");
                return(1);
            }

            return(base.DoExecute(context));
        }
 public DirectorySource(
     ITaskContextInternal taskContext,
     IDirectoryFilesLister directoryFilesLister,
     string id,
     FullPath directoryName,
     bool recursive)
 {
     _taskContext          = taskContext;
     _directoryFilesLister = directoryFilesLister;
     _id            = id;
     _recursive     = recursive;
     _directoryPath = directoryName;
 }
        protected override void BeforeExecute(ITaskContextInternal context)
        {
            var args = GetArguments();

            if (args.Count == 0 || args[0].StartsWith("-"))
            {
                var solustionFileName = context.Properties.Get <string>(BuildProps.SolutionFileName, null);
                if (solustionFileName != null)
                {
                    Project(solustionFileName);
                }
            }
        }
        public void CheckLbStatus(ITaskContextInternal context, string enviroment)
        {
            if (enviroment != "Production" && enviroment != "Test")
            {
                context.LogInfo($"Switch healthcheck http status for enviroment {enviroment} is not turned on.");
                return;
            }

            WebClient client = new WebClient();

            client.BaseAddress = WebApiBaseUrl(enviroment);
            var resposne = client.DownloadString("HealthCheck/Lb");
        }
Example #11
0
        public static DirectorySource WebFilterSource(
            ITaskContextInternal taskContext,
            IDirectoryFilesLister directoryFilesLister,
            string id,
            FullPath directoryName,
            bool recursive)
        {
            DirectorySource source = new DirectorySource(taskContext, directoryFilesLister, id, directoryName, recursive, null);

            source.SetFileFilter(new NegativeFilter(
                                     new RegexFilter(@"^.*\.(svc|asax|config|aspx|ascx|css|js|gif|PNG)$")));

            return(source);
        }
Example #12
0
        public static bool LogIfFilteredOut(string fileName, IFilter filter, ITaskContextInternal taskContext, bool logFiles)
        {
            if (filter != null && !filter.IsPassedThrough(fileName))
            {
                if (logFiles)
                {
                    taskContext.LogInfo($"File '{fileName}' has been filtered out.");
                }

                return(false);
            }

            return(true);
        }
        public ITargetFluentInterface GetTargetFluentInterface(ITarget target, ITaskContextInternal taskContext)
        {
            ITargetFluentInterface t            = _sp.GetRequiredService <ITargetFluentInterface>();
            TargetFluentInterface  targetFluent = (TargetFluentInterface)t;

            targetFluent.Target                   = target;
            targetFluent.Context                  = taskContext;
            targetFluent.CoreTaskFluent           = GetCoreTaskFluentInterface(taskContext);
            targetFluent.TaskExtensionsFluent     = GetTaskExtensionsFluentInterface(t, taskContext);
            targetFluent.CoreTaskExtensionsFluent = GetCoreTaskExtensionsFluentInterface(t, taskContext);
            targetFluent.TaskFluent               = GetTaskFluentInterface(taskContext);

            return(targetFluent);
        }
        public virtual void LogTargetsHelp(ITaskContextInternal context)
        {
            context.DecreaseDepth();
            context.LogInfo("Targets:");

            // first sort the targets
            var sortedTargets = new SortedList <string, ITargetInternal>();

            foreach (var target in _targets.Values)
            {
                sortedTargets.Add(target.TargetName, target);
            }

            // now display them in sorted order
            foreach (ITargetInternal target in sortedTargets.Values)
            {
                if (target.IsHidden == false)
                {
                    string help = $"  {target.TargetName.Capitalize()}";

                    if (target.Dependencies != null && target.Dependencies.Count != 0)
                    {
                        help = $"{help} ({string.Join(", ", target.Dependencies.GetKeys())})";
                    }

                    help = $"{help} : {target.Description}";

                    if (DefaultTargets.Contains(target))
                    {
                        context.LogInfo(help, Color.DarkOrange);
                    }
                    else
                    {
                        context.LogInfo(help);
                    }
                }
            }

            if (ScriptArgsHelp?.Count > 0)
            {
                context.LogInfo(" ");
                context.LogInfo("Global build script arguments:");
                foreach (var argHelp in ScriptArgsHelp)
                {
                    context.LogInfo($"  {argHelp}");
                }
            }

            context.IncreaseDepth();
        }
Example #15
0
        protected override int DoExecute(ITaskContextInternal context)
        {
            IRunProgramTask task = context
                                   .Tasks()
                                   .RunProgramTask("systemctl")
                                   .WithArguments(_command, _service);

            if (DoNotFail)
            {
                task.DoNotFailOnError();
            }

            return(task.Execute(context));
        }
Example #16
0
        /// <inheritdoc />
        protected override TResult DoExecute(ITaskContextInternal context)
        {
            if (string.IsNullOrEmpty(ExecutablePath))
            {
                throw new TaskExecutionException($"{nameof(ExecutablePath)} must be set.", 5);
            }

            _task = context.Tasks()
                    .RunProgramTask(ExecutablePath)
                    .DoNotLogTaskExecutionInfo()
                    .WorkingFolder(ExecuteWorkingFolder);

            _task.WithOutputLogLevel(OutputLogLevel);

            _task.WithLogLevel(TaskLogLevel);

            if (KeepProgramOutput)
            {
                _task.CaptureOutput();
            }

            if (KeepProgramErrorOutput)
            {
                _task.CaptureErrorOutput();
            }

            BeforeExecute(context, _task);
            AddOrOverrideArgumentsFromConsole(context);
            var argumentsFlat = ValidateAndGetArgumentsFlat();

            foreach (var arg in argumentsFlat)
            {
                _task.WithArguments(arg.arg, arg.maskArg);
            }

            var result = _task
                         .ChangeDefaultAdditionalOptionPrefix(AdditionalOptionPrefix)
                         .AddPrefixToAdditionalOptionKey(_prefixToAdditionalOptionKeyFunc)
                         .ChangeAdditionalOptionKeyValueSeperator(_additionalOptionKeyValueSeperator)
                         .AddNewAdditionalOptionPrefix(_additionalOptionPrefixes)
                         .Execute(context);

            if (typeof(TResult) == typeof(int))
            {
                return((TResult)(object)result);
            }

            return(default(TResult));
        }
Example #17
0
        protected override async Task <int> DoExecuteAsync(ITaskContextInternal context)
        {
            var client   = WebApiClientFactory.Create(context.Properties.Get <string>(BuildProps.LastWebApiBaseUrl));
            var response = await client.ExecuteAsync(c => c.UploadScriptAsync(new UploadScriptRequest
            {
                FilePath = _scriptFilePath
            }));

            if (response != null)
            {
                throw new TaskExecutionException($"Upload script failed: ErrorCode: {response.ErrorCode} ErrorMessage: {response.ErrorMessage}", 99);
            }

            return(0);
        }
Example #18
0
 public ZipProcessor(
     ITaskContextInternal taskContext,
     IZipper zipper,
     FileFullPath zipFileName,
     FullPath baseDir,
     bool optimizeFiles,
     params string[] sources)
 {
     _taskContext   = taskContext;
     _zipper        = zipper;
     _zipFileName   = zipFileName;
     _baseDir       = baseDir;
     _optimizeFiles = optimizeFiles;
     _sourcesToZip.AddRange(sources);
 }
Example #19
0
        public void TargetHelp(ITaskContextInternal context)
        {
            _targetTree.MarkTargetAsExecuted(this);
            context.LogInfo(" ");
            context.LogInfo($"Target {TargetName} will execute next tasks:");

            for (int i = 0; i < _taskGroups.Count; i++)
            {
                for (int j = 0; j < _taskGroups[i].Tasks.Count; j++)
                {
                    var task = (TaskHelp)_taskGroups[i].Tasks[j].task;
                    task.LogTaskHelp(context);
                }
            }
        }
        protected override int DoExecute(ITaskContextInternal context)
        {
            if (string.IsNullOrEmpty(ExecutablePath))
            {
                ExecutablePath = context.Properties.GetDotnetExecutable();
                if (string.IsNullOrEmpty(ExecutablePath))
                {
                    context.Fail("Dotnet executable not set!", -1);
                    return(-1);
                }
            }

            KeepProgramErrorOutput = true;
            KeepProgramOutput      = true;
            return(base.DoExecute(context));
        }
        protected override async Task <int> DoExecuteAsync(ITaskContextInternal context)
        {
            var json = JsonSerializer.Serialize(_message, serializeOptions);

            using (var client = new HttpClient())
            {
                var result = await client.PostAsync(_webhookUrl, new StringContent(json, Encoding.UTF8, "application/json"));

                if (result.IsSuccessStatusCode)
                {
                    return(0);
                }

                throw new TaskExecutionException(await result.Content.ReadAsStringAsync(), 20);
            }
        }
        private static (List <string> targetsToRun, bool unknownTarget, List <string> notFoundTargets) ParseCmdLineArgs(
            ITaskContextInternal context, TargetTree targetTree)
        {
            if (context.Args.MainCommands == null || context.Args.MainCommands.Count == 0)
            {
                return(null, false, null);
            }

            if (targetTree.HasAllTargets(context.Args.MainCommands, out var notFoundTargets))
            {
                return(context.Args.MainCommands, false, null);
            }

            return(new List <string> {
                "help"
            }, true, notFoundTargets);
        }
Example #23
0
 public DirectorySource(
     ITaskContextInternal taskContext,
     IDirectoryFilesLister directoryFilesLister,
     string id,
     FullPath directoryName,
     bool recursive,
     IFilter filter,
     bool logFiles = true)
 {
     _taskContext          = taskContext;
     _directoryFilesLister = directoryFilesLister;
     _id             = id;
     _recursive      = recursive;
     DirectoryFilter = filter;
     _directoryPath  = directoryName;
     _logFiles       = logFiles;
 }
Example #24
0
        protected override int DoExecute(ITaskContextInternal context)
        {
            string program = ExecutablePath;

            if (string.IsNullOrEmpty(program))
            {
                program = context.Properties.GetDotnetExecutable();
            }

            if (string.IsNullOrEmpty(program))
            {
                context.Fail("Dotnet executable not set!", -1);
                return(-1);
            }

            IRunProgramTask task = context.Tasks().RunProgramTask(program);

            if (NoOutputLog)
            {
                task.DoNotLogOutput();
            }

            if (DoNotLog)
            {
                task.NoLog();
            }

            BeforeExecute(context);
            var argumentsFlat = ValidateAndGetArgumentsFlat();

            task
            .WithArguments(Command);

            foreach (var arg in argumentsFlat)
            {
                task.WithArguments(arg.arg, arg.maskArg);
            }

            task
            .WorkingFolder(ExecuteWorkingFolder)
            .CaptureErrorOutput()
            .CaptureOutput()
            .ExecuteVoid(context);

            return(0);
        }
Example #25
0
        protected override GitVersion DoExecute(ITaskContextInternal context)
        {
            AddPrefixToAdditionalOptionKey(PrefixProcessors.AddSlashPrefixToAdditionalOptionKey);
            ChangeAdditionalOptionKeyValueSeperator(' ');
            base.DoExecute(context);

            var output = GetOutput();

            if (!string.IsNullOrEmpty(output))
            {
                var gitVersion = JsonConvert.DeserializeObject <GitVersion>(output);
                context.Properties.Set(BuildProps.BuildVersion, new Version(gitVersion.AssemblySemVer));
                return(gitVersion);
            }

            return(null);
        }
Example #26
0
 public ZipProcessor(
     ITaskContextInternal taskContext,
     IZipper zipper,
     FileFullPath zipFileName,
     FullPath baseDir,
     bool optimizeFiles,
     List <string> sources,
     bool logFiles = true)
 {
     _taskContext   = taskContext;
     _zipper        = zipper;
     _zipFileName   = zipFileName;
     _baseDir       = baseDir;
     _optimizeFiles = optimizeFiles;
     _sourcesToZip.AddRange(sources);
     _logFiles = logFiles;
 }
        protected override async Task <int> DoExecuteAsync(ITaskContextInternal context)
        {
            if (string.IsNullOrEmpty(_saveAs))
            {
                throw new ArgumentNullException(nameof(_saveAs));
            }

            var extension = Path.GetExtension(_saveAs);

            if (string.IsNullOrEmpty(extension) || !extension.Equals(".zip", StringComparison.OrdinalIgnoreCase))
            {
                throw new TaskExecutionException("SaveAs file extension must be .zip", 99);
            }

            var client = WebApiClientFactory.Create(context.Properties.Get <string>(BuildProps.LastWebApiBaseUrl));

            try
            {
                var reports = await client.DownloadReportsAsync(new DownloadReportsRequest()
                {
                    DownloadFromSubDirectory = _subDirectory
                }) as MemoryStream;

                using (FileStream file = new FileStream(_saveAs, FileMode.Create, FileAccess.Write))
                {
                    reports.WriteTo(file);

#if !NETSTANDARD1_6
                    reports.Close();
                    file.Close();
#endif
                }
            }
            catch (WebApiException e)
            {
                if (e.ErrorCode == "NoReportsFound" && !_failWhenNoReportsFound)
                {
                    context.LogInfo("No reports found on server.");
                    return(0);
                }

                throw;
            }

            return(0);
        }
Example #28
0
        protected override Version DoExecute(ITaskContextInternal context)
        {
            _productRootDir = context.Properties.Get <string>(BuildProps.ProductRootDir, ".");

            if (string.IsNullOrEmpty(_productRootDir))
            {
                _productRootDir = ".";
            }

            string projectVersionFileName;

            if (!string.IsNullOrEmpty(_projectVersionFileName))
            {
                projectVersionFileName = Path.Combine(_productRootDir, _projectVersionFileName);
            }
            else
            {
                _productId             = context.Properties.Get <string>(BuildProps.ProductId);
                projectVersionFileName = Path.Combine(_productRootDir, $"{_productId}.ProjectVersion.txt");
            }

            if (!File.Exists(projectVersionFileName))
            {
                throw new InvalidOperationException($"Project version file '{projectVersionFileName}' is missing.");
            }

            Version buildVersion;

            using (Stream stream = File.Open(projectVersionFileName, FileMode.Open))
            {
                using (StreamReader reader = new StreamReader(stream))
                {
                    string versionAsString = reader.ReadLine();
                    buildVersion = new Version(versionAsString);
                }
            }

            if (!_doNotSaveVersionToSession)
            {
                context.SetBuildVersion(buildVersion);
            }

            DoLogInfo($"Project build version (from file): {buildVersion}");
            return(buildVersion);
        }
Example #29
0
        protected override int DoExecute(ITaskContextInternal context)
        {
            var    urlWithAccessToken = $"https://{_account}.slack.com/services/hooks/incoming-webhook?token={_token}";
            var    uri         = new Uri(urlWithAccessToken);
            string payloadJson = JsonConvert.SerializeObject(_slackMessage);

            using (WebClient client = new WebClient())
            {
                NameValueCollection data = new NameValueCollection();
                data["payload"] = payloadJson;

                var response = client.UploadValues(uri, "POST", data);

                string responseText = _encoding.GetString(response);
            }

            return(0);
        }
        protected override int DoExecute(ITaskContextInternal context)
        {
            JObject dest = new JObject();

            foreach (string file in _sourceFiles)
            {
                JObject src = JObject.Parse(File.ReadAllText(file));

                foreach (JToken child in src.Children())
                {
                    dest.Add(child);
                }
            }

            File.WriteAllText(_fileName, dest.ToString(Formatting.Indented), Encoding.UTF8);

            return(0);
        }