Beispiel #1
0
        public void FocusAndSelectTeamBuild(IQueuedBuild queuedBuild)
        {
            EnsureSelectedTeamProject(queuedBuild.BuildDefinition.TeamProject, false);
            ButtonClick(this.btnTeamBuilds, EventArgs.Empty);

            ControlTeamBuildList.FocusAndSelectTeamBuild(queuedBuild);
        }
Beispiel #2
0
        public BuildViewModel(IQueuedBuild build)
        {
            this.QueuedBuildDetail = build;
            if (build.Build != null)
            {
                this.Name = build.Build.BuildNumber;
            }
            else
            {
                this.Name = build.Id.ToString();
            }

            this.BuildDefinition    = build.BuildDefinition != null ? build.BuildDefinition.Name : "n/a";
            this.BuildDefinitionUri = build.BuildDefinition != null ? build.BuildDefinitionUri : null;
            this.TeamProject        = build.TeamProject;
            this.BuildStatus        = build.Status.ToString();
            this.BuildController    = build.BuildController != null ? build.BuildController.Name : "n/a";
            this.RequestedBy        = build.RequestedFor;
            this.Priority           = build.Priority.ToString();

            if (build.Build != null)
            {
                this.StartTime = build.Build.StartTime.ToString("g");
                if (build.Build.BuildFinished)
                {
                    this.FinishTime = build.Build.FinishTime.ToString("g");
                }

                this.Uri = build.Build.Uri;
            }
        }
Beispiel #3
0
 public JsonQueuedBuild(IQueuedBuild model)
 {
     build       = model.Build != null ? new JsonBuildDetail(model.Build) : null;
     definition  = model.BuildDefinition != null ? model.BuildDefinition.Name : null;
     id          = model.Id;
     position    = model.QueuePosition;
     queueTime   = model.QueueTime;
     requestedBy = model.RequestedBy;
     projectName = model.TeamProject;
 }
Beispiel #4
0
        public void Promote(int buildNumber)
        {
            IBuildRequest request = BuildDefinition.CreateBuildRequest();

            IDictionary <string, object> processParams = WorkflowHelpers.DeserializeProcessParameters(request.ProcessParameters);

            processParams["PriorBuild"] = buildNumber.ToString();

            request.ProcessParameters = WorkflowHelpers.SerializeProcessParameters(processParams);

            IQueuedBuild queuedBuild = BuildDefinition.BuildServer.QueueBuild(request);
        }
Beispiel #5
0
        /// <summary>
        /// http://stackoverflow.com/questions/10557814/how-to-get-a-specific-build-with-the-tfs-api
        /// </summary>
        /// <param name="TeamProject"></param>
        /// <param name="BuildDefinition"></param>
        /// <param name="BuildID"></param>
        /// <returns></returns>
        public string GetBuildStatus(TfsTeamProjectCollection tfs, string TeamProject, string BuildDefinition, int BuildID)
        {
            IBuildServer            buildServer = (IBuildServer)tfs.GetService(typeof(IBuildServer));
            string                  status      = string.Empty;
            IQueuedBuildSpec        qbSpec      = buildServer.CreateBuildQueueSpec(TeamProject, BuildDefinition);
            IQueuedBuildQueryResult qbResults   = buildServer.QueryQueuedBuilds(qbSpec);

            if (qbResults.QueuedBuilds.Length > 0)
            {
                IQueuedBuild build = qbResults.QueuedBuilds.Where(x => x.Id == BuildID).FirstOrDefault();
                status = build.Status.ToString();
            }
            return(status);
        }
Beispiel #6
0
        private bool IsQueuedBuildRunning(IQueuedBuild build)
        {
            bool     isQueuedBuildRunning      = false;
            DateTime timeStampIfBuildIsRunning = new DateTime();

            if (build != null)
            {
                if (build.Status == QueueStatus.Queued || build.Status == QueueStatus.InProgress || (build.Build != null && (build.Build.Status == BuildStatus.InProgress && (build.Build.FinishTime == timeStampIfBuildIsRunning || build.Build.Status == BuildStatus.NotStarted))))
                {
                    isQueuedBuildRunning = true;
                }
            }

            return(isQueuedBuildRunning);
        }
Beispiel #7
0
        private void PopulateListItem(ListViewCCH listView, BuildInfo buildInfo)
        {
            ListViewItem viewItem;

            if (IsQueuedSelected)
            {
                IQueuedBuild queuedBuild = buildInfo.queuedBuild;
                //IBuildDetail detail = queuedBuild.Build;

                viewItem = listView.Items.Add(queuedBuild.BuildDefinition.Name);
                viewItem.UseItemStyleForSubItems = false;
                viewItem.StateImageIndex         = GetBuildStatusImage(queuedBuild.Status, queuedBuild.Build);
                viewItem.SubItems.Add(queuedBuild.Priority.ToString());
                viewItem.SubItems.Add(queuedBuild.QueueTime.ToString());
                viewItem.SubItems.Add(queuedBuild.RequestedBy);
                //viewItem.SubItems.Add(queuedBuild.BuildAgent.Name);
                viewItem.SubItems.Add(string.Empty);

                viewItem.Group = listView.Groups[queuedBuild.BuildDefinition.TeamProject];
            }
            else
            {
                IBuildDetail buildDetail = buildInfo.buildDetail;

                viewItem = listView.Items.Add(buildDetail.Status.ToString());
                viewItem.UseItemStyleForSubItems = false;
                viewItem.StateImageIndex         = GetBuildStatusImage(buildDetail.Status);
                viewItem.SubItems.Add(buildDetail.StartTime.ToString());
                viewItem.SubItems.Add(buildDetail.BuildNumber);
                viewItem.SubItems.Add(buildDetail.BuildDefinition.Name);
                //viewItem.SubItems.Add(buildDetail.BuildAgent.Name);
                viewItem.SubItems.Add(string.Empty);
                viewItem.SubItems.Add(buildDetail.RequestedBy);
                viewItem.SubItems.Add(buildDetail.Quality);
                viewItem.SubItems.Add(buildDetail.FinishTime.ToString());

                bool logFileExists = !string.IsNullOrEmpty(buildDetail.LogLocation) &&
                                     File.Exists(buildDetail.LogLocation);

                ListViewItem.ListViewSubItem subItem = viewItem.SubItems.Add(logFileExists ? "Has log" : "No log");
                subItem.ForeColor = logFileExists
                    ? Color.FromKnownColor(KnownColor.WindowText) : Color.FromKnownColor(KnownColor.ControlLight);

                viewItem.Group = listView.Groups[buildDetail.BuildDefinition.TeamProject];
            }

            viewItem.Tag = buildInfo;
        }
        public BuildViewModel(IQueuedBuild build)
        {
            this.QueuedBuildDetail = build;
            if (build.Build != null)
            {
                string[] refreshAllDetails = { InformationTypes.AgentScopeActivityTracking };
                build.Build.Refresh(refreshAllDetails, QueryOptions.Agents | QueryOptions.BatchedRequests);
                this.Name = build.Build.BuildNumber;
            }
            else
            {
                this.Name = build.Id.ToString(CultureInfo.CurrentCulture);
            }

            this.FullBuildDefinition = build.BuildDefinition;
            this.BuildDefinition = build.BuildDefinition != null ? build.BuildDefinition.Name : "n/a";
            this.BuildDefinitionUri = build.BuildDefinition != null ? build.BuildDefinitionUri : null;
            this.TeamProject = build.TeamProject;
            this.BuildStatus = build.Status.ToString();
            this.BuildController = build.BuildController != null ? build.BuildController.Name : "n/a";
            this.RequestedBy = build.RequestedFor;
            this.Priority = build.Priority.ToString();

            if (build.Build != null)
            {
                this.StartTime = build.Build.StartTime.ToString("g");
                this.SortableStartTime = build.Build.StartTime.ToString("s");
                if (build.Build.BuildFinished)
                {
                    this.FinishTime = build.Build.FinishTime.ToString("g");
                    this.SortableFinishTime = build.Build.FinishTime.ToString("s");
                    this.Duration = string.Format("{0:dd\\:hh\\:mm\\:ss}", build.Build.FinishTime - build.Build.StartTime);
                }
                else
                {
                    if (build.Build.StartTime != Convert.ToDateTime("01/01/0001 00:00:00"))
                    {
                        this.Duration = string.Format("{0:dd\\:hh\\:mm\\:ss}", DateTime.Now - build.Build.StartTime);
                    }
                }

                this.QueuedTime = build.Build.Requests.Count > 0 ? build.Build.Requests[0].QueueTime.ToString("g") : build.Build.StartTime.ToString("g");
                this.SortableQueuedTime = build.Build.Requests.Count > 0 ? build.Build.Requests[0].QueueTime.ToString("s") : build.Build.StartTime.ToString("s");
                this.BuildAgent = GetBuildAgentName(build.Build);
                this.Uri = build.Build.Uri;
            }
        }
Beispiel #9
0
        public BuildViewModel(IQueuedBuild build)
        {
            this.QueuedBuildDetail = build;
            if (build.Build != null)
            {
                string[] refreshAllDetails = { InformationTypes.AgentScopeActivityTracking };
                build.Build.Refresh(refreshAllDetails, QueryOptions.Agents | QueryOptions.BatchedRequests);
                this.Name = build.Build.BuildNumber;
            }
            else
            {
                this.Name = build.Id.ToString(CultureInfo.CurrentCulture);
            }

            this.FullBuildDefinition = build.BuildDefinition;
            this.BuildDefinition     = build.BuildDefinition != null ? build.BuildDefinition.Name : "n/a";
            this.BuildDefinitionUri  = build.BuildDefinition != null ? build.BuildDefinitionUri : null;
            this.TeamProject         = build.TeamProject;
            this.BuildStatus         = build.Status.ToString();
            this.BuildController     = build.BuildController != null ? build.BuildController.Name : "n/a";
            this.RequestedBy         = build.RequestedFor;
            this.Priority            = build.Priority.ToString();

            if (build.Build != null)
            {
                this.StartTime         = build.Build.StartTime.ToString("g");
                this.SortableStartTime = build.Build.StartTime.ToString("s");
                if (build.Build.BuildFinished)
                {
                    this.FinishTime         = build.Build.FinishTime.ToString("g");
                    this.SortableFinishTime = build.Build.FinishTime.ToString("s");
                    this.Duration           = string.Format("{0:dd\\:hh\\:mm\\:ss}", build.Build.FinishTime - build.Build.StartTime);
                }
                else
                {
                    if (build.Build.StartTime != Convert.ToDateTime("01/01/0001 00:00:00"))
                    {
                        this.Duration = string.Format("{0:dd\\:hh\\:mm\\:ss}", DateTime.Now - build.Build.StartTime);
                    }
                }

                this.QueuedTime         = build.Build.Requests.Count > 0 ? build.Build.Requests[0].QueueTime.ToString("g") : build.Build.StartTime.ToString("g");
                this.SortableQueuedTime = build.Build.Requests.Count > 0 ? build.Build.Requests[0].QueueTime.ToString("s") : build.Build.StartTime.ToString("s");
                this.BuildAgent         = GetBuildAgentName(build.Build);
                this.Uri = build.Build.Uri;
            }
        }
Beispiel #10
0
 public TeamBuildStatusChangeHandler(IQueuedBuild build)
 {
     this.build = build;
 }
Beispiel #11
0
        private void RefreshStatus()
        {
            bool isQueued = false;

            _queuedBuildsView.Refresh(false);

            if (_queuedBuildsView.QueuedBuilds.Length > 0)
            {
                IQueuedBuild nextQueuedBuild = _queuedBuildsView.QueuedBuilds.OrderBy(b => b.QueuePosition).First();

                if (nextQueuedBuild.Build != null)
                {
                    LastBuildUri = nextQueuedBuild.Build.Uri;
                }

                LastStatus = new PipelineEnvironmentBuildStatus(BuildStatus.InProgress);

                isQueued = true;
            }

            if (!isQueued)
            {
                IOrderedEnumerable <IBuildDetail> existingBuilds = BuildDefinition.BuildServer.QueryBuilds(_buildSpec).Builds.OrderByDescending(b => b.StartTime);

                bool foundStatusBuild = false;

                foreach (IBuildDetail build in existingBuilds)
                {
                    try
                    {
                        if (!foundStatusBuild)
                        {
                            IDictionary <string, object> processParams = WorkflowHelpers.DeserializeProcessParameters(build.ProcessParameters);

                            if (EnvironmentName == "Commit" || processParams.ContainsKey("PriorBuild"))
                            {
                                if (!isQueued)
                                {
                                    LastStatus = new PipelineEnvironmentBuildStatus(build.Status);
                                }

                                LastBuildFinishTime = build.FinishTime;

                                LastBuildUri = build.Uri;

                                if (EnvironmentName == "Commit")
                                {
                                    LastBuildNumber = new Build(build).Number.ToString();
                                }
                                else if (EnvironmentName == "Production")
                                {
                                    string buildUriString = build.Uri.ToString();

                                    string buildUri = buildUriString.Contains("?") ? buildUriString.Substring(0, buildUriString.IndexOf("?")) : buildUriString;

                                    string buildUriPrefix = buildUri.Substring(0, buildUri.LastIndexOf("/") + 1);

                                    Uri commitBuildUri = new Uri(string.Format("{0}{1}", buildUriPrefix, processParams["PriorBuild"] as string));

                                    IBuildDetail buildDetail = BuildDefinition.BuildServer.GetMinimalBuildDetails(commitBuildUri);

                                    processParams = WorkflowHelpers.DeserializeProcessParameters(buildDetail.ProcessParameters);

                                    LastBuildNumber = processParams["PriorBuild"] as string;
                                }
                                else
                                {
                                    LastBuildNumber = processParams["PriorBuild"] as string;
                                }

                                foundStatusBuild = true;
                                break;
                            }
                        }
                    }
                    catch (Exception) { }
                }

                if (foundStatusBuild)
                {
                    return;
                }
                else
                {
                    LastBuildNumber     = "0";
                    LastBuildUri        = null;
                    LastStatus          = new PipelineEnvironmentBuildStatus(BuildStatus.None);
                    LastBuildFinishTime = DateTime.MinValue;
                }
            }
        }
 protected override IBuildDetail GetSpecificBuildFromQueuedBuild(IQueuedBuild queuedBuild, string shelvesetName)
 {
     var build = queuedBuild.Builds.FirstOrDefault(b => b.ShelvesetName == shelvesetName);
     return build != null ? build : queuedBuild.Build;
 }
Beispiel #13
0
        private bool CheckBuildId()
        {
            IQueuedBuild queuedBuild = this.bs.GetQueuedBuild(this.BuildId.Get(this.ActivityContext), QueryOptions.All);

            return(this.IsQueuedBuildRunning(queuedBuild));
        }
 private void UpdateStatus(IQueuedBuild queuedBuild)
 {
     if (queuedBuild.Build != null)
     {
         UpdateStatus(queuedBuild.Build);
     }
 }
Beispiel #15
0
 internal BuildInfo(IQueuedBuild queuedBuild)
 {
     this.queuedBuild = queuedBuild;
 }
Beispiel #16
0
        private void SortListData()
        {
            List <BuildInfo> listToSort = this.cachedBuilds[this.IsQueuedSelected];

            listToSort.Sort((x, y) =>
            {
                int compared;

                if (this.IsQueuedSelected)
                {
                    IQueuedBuild xx = x.queuedBuild;
                    IQueuedBuild yy = y.queuedBuild;

                    if (this.sortInfo.Index == COLUNN2_DEFINITION) // Build Definition
                    {
                        compared = string.CompareOrdinal(xx.BuildDefinition.Name, yy.BuildDefinition.Name);
                    }
                    else if (this.sortInfo.Index == COLUNN2_PRIORITY) // Priority
                    {
                        compared = string.CompareOrdinal(xx.Priority.ToString(), yy.Priority.ToString());
                    }
                    else if (this.sortInfo.Index == COLUNN2_DATEQUEUED) // Date queued
                    {
                        compared = DateTime.Compare(xx.QueueTime, yy.QueueTime);
                    }
                    else if (this.sortInfo.Index == COLUNN2_REQUESTEDBY) // Requested by
                    {
                        compared = string.CompareOrdinal(xx.RequestedBy, yy.RequestedBy);
                    }
                    else // Agent
                    {
                        compared = 0; // string.CompareOrdinal(xx.BuildAgent.Name, yy.BuildAgent.Name);
                    }
                }
                else
                {
                    IBuildDetail xx = x.buildDetail;
                    IBuildDetail yy = y.buildDetail;

                    if (this.sortInfo.Index == COLUNN_STATUS) // Status
                    {
                        compared = string.CompareOrdinal(xx.Status.ToString(), yy.Status.ToString());
                    }
                    else if (this.sortInfo.Index == COLUNN_STARTED) // Started
                    {
                        compared = DateTime.Compare(xx.StartTime, yy.StartTime);
                    }
                    else if (this.sortInfo.Index == COLUNN_BUILDNUMBER) // Build number
                    {
                        compared = string.CompareOrdinal(xx.BuildNumber, yy.BuildNumber);
                    }
                    else if (this.sortInfo.Index == COLUNN_DEFINITION) // Definition
                    {
                        compared = string.CompareOrdinal(xx.BuildDefinition.Name, yy.BuildDefinition.Name);
                    }
                    else if (this.sortInfo.Index == COLUNN_AGENT)       // Agent
                    {
                        compared = 0;                                   // string.CompareOrdinal(xx.BuildAgent.Name, yy.BuildAgent.Name);
                    }
                    else if (this.sortInfo.Index == COLUNN_REQUESTEDBY) // Requested by
                    {
                        compared = string.CompareOrdinal(xx.RequestedBy, yy.RequestedBy);
                    }
                    else if (this.sortInfo.Index == COLUNN_QUALITY) // Quality
                    {
                        compared = string.CompareOrdinal(xx.Quality, yy.Quality);
                    }
                    else if (this.sortInfo.Index == COLUNN_FINISHTIME) // Finish Time
                    {
                        compared = DateTime.Compare(xx.FinishTime, yy.FinishTime);
                    }
                    else
                    {
                        int xHasLog = Convert.ToInt32(!string.IsNullOrEmpty(xx.LogLocation) && File.Exists(xx.LogLocation));
                        int yHasLog = Convert.ToInt32(!string.IsNullOrEmpty(yy.LogLocation) && File.Exists(yy.LogLocation));

                        compared = xHasLog - yHasLog;
                    }
                }

                if (this.sortInfo.Order == SortOrder.Descending)
                {
                    compared = compared * -1;
                }

                return(compared);
            });
        }
Beispiel #17
0
        public void QueueCommitBuild()
        {
            IBuildRequest request = BuildDefinition.CreateBuildRequest();

            IQueuedBuild queuedBuild = BuildDefinition.BuildServer.QueueBuild(request);
        }
Beispiel #18
0
 public void FocusAndSelectTeamBuild(IQueuedBuild queuedBuild)
 {
     ChangeFilterBuilds(true);
     SelectBuildByCompare(new BuildInfo(queuedBuild));
 }
Beispiel #19
0
        protected override IBuildDetail GetSpecificBuildFromQueuedBuild(IQueuedBuild queuedBuild, string shelvesetName)
        {
            var build = queuedBuild.Builds.FirstOrDefault(b => b.ShelvesetName == shelvesetName);

            return(build != null ? build : queuedBuild.Build);
        }
Beispiel #20
0
        private void QueueBuildTemplate(BuildTemplate buildTemplate, bool queueingMultiple)
        {
            IBuildDefinition buildDefinition = Context.BuildServer.GetBuildDefinition(buildTemplate.TeamProject,
                                                                                      buildTemplate.DefinitionName);

            bool         started     = buildDefinition != null;
            string       exc_msg     = "-";
            IQueuedBuild queuedBuild = null;

            if (started)
            {
                try
                {
                    IBuildRequest request = buildDefinition.CreateBuildRequest();
                    //IBuildAgent buildAgent = Context.BuildServer.GetBuildAgent(new Uri(buildTemplate.BuildControllerUri));
                    IBuildController buildController = Context.BuildServer.GetBuildController(buildTemplate.BuildControllerName);

                    /*request.BuildAgent = buildAgent;
                     * request.CommandLineArguments = buildTemplate.CommandLineArguments;*/
                    request.BuildController = buildController;

                    BuildProcessParameters buildProcessParameters = buildDefinition.GetBuildProcessParameters();
                    buildProcessParameters.MSBuildArguments = buildTemplate.CommandLineArguments;

                    request.ProcessParameters = buildProcessParameters.SaveToXml();
                    request.DropLocation      = buildTemplate.DefaultDropLocation;
                    request.Postponed         = buildTemplate.Postponed;
                    request.Priority          = buildTemplate.RunPriority;
                    request.RequestedFor      = Context.LoggedUser;

                    queuedBuild = Context.BuildServer.QueueBuild(request);

                    if (!queueingMultiple)
                    {
                        started = queuedBuild.WaitForBuildStart(10000, 10000);
                    }
                }
                catch (Exception e)
                {
                    exc_msg = e.Message;
                }
            }

            if (!queueingMultiple)
            {
                string message = started
                    ? string.Format("Team build template '{0}' started successfully", buildTemplate.TemplateName)
                    : string.Format("Team build template '{0}' failed to start, message: {1}", buildTemplate.TemplateName, exc_msg);

                ToolTipIcon icon    = started ? ToolTipIcon.Info : ToolTipIcon.Warning;
                string      caption = string.Format("Queue team build template '{0}'", buildTemplate.TemplateName);

                UIContext.Instance.ShowTrayTooltip(caption, message, icon, new NavigateToTeamBuildDefinitionHandler(buildTemplate));

                //MessageBox.Show(message, string.Format("Queue team build template '{0}'", buildTemplate.TemplateName), MessageBoxButtons.OK, icon););

                if (started && queuedBuild != null)
                {
                    //this.parentControl.FocusAndSelectTeamBuild(queuedBuild);
                    UIContext.Instance.ControlTeamBuilds.FocusAndSelectTeamBuild(queuedBuild);
                }
            }
        }