github.com/pf-qiu/concourse/v6@v6.7.3-0.20201207032516-1f455d73275f/atc/api/ccserver/get.go (about)

     1  package ccserver
     2  
     3  import (
     4  	"encoding/xml"
     5  	"fmt"
     6  	"net/http"
     7  	"net/url"
     8  	"time"
     9  
    10  	"code.cloudfoundry.org/lager"
    11  
    12  	"github.com/pf-qiu/concourse/v6/atc"
    13  	"github.com/pf-qiu/concourse/v6/atc/db"
    14  	"github.com/tedsuo/rata"
    15  )
    16  
    17  type Project struct {
    18  	Activity        string `xml:"activity,attr"`
    19  	LastBuildLabel  string `xml:"lastBuildLabel,attr"`
    20  	LastBuildStatus string `xml:"lastBuildStatus,attr"`
    21  	LastBuildTime   string `xml:"lastBuildTime,attr"`
    22  	Name            string `xml:"name,attr"`
    23  	WebUrl          string `xml:"webUrl,attr"`
    24  }
    25  
    26  type ProjectsContainer struct {
    27  	XMLName  xml.Name  `xml:"Projects"`
    28  	Projects []Project `xml:"Project"`
    29  }
    30  
    31  func (s *Server) GetCC(w http.ResponseWriter, r *http.Request) {
    32  	logger := s.logger.Session("get-cc")
    33  	teamName := rata.Param(r, "team_name")
    34  
    35  	team, found, err := s.teamFactory.FindTeam(teamName)
    36  
    37  	if err != nil {
    38  		logger.Error("failed-to-find-team", err)
    39  		w.WriteHeader(http.StatusInternalServerError)
    40  		return
    41  	}
    42  
    43  	if !found {
    44  		logger.Debug("team-not-found", lager.Data{"team": teamName})
    45  		w.WriteHeader(http.StatusNotFound)
    46  		return
    47  	}
    48  
    49  	pipelines, err := team.Pipelines()
    50  
    51  	if err != nil {
    52  		logger.Error("failed-to-get-all-active-pipelines", err)
    53  		w.WriteHeader(http.StatusInternalServerError)
    54  		return
    55  	}
    56  
    57  	var projects []Project
    58  
    59  	for _, pipeline := range pipelines {
    60  		dashboards, err := pipeline.Dashboard()
    61  
    62  		if err != nil {
    63  			logger.Error("failed-to-get-dashboards", err)
    64  			w.WriteHeader(http.StatusInternalServerError)
    65  			return
    66  		}
    67  
    68  		for _, dashboardJob := range dashboards {
    69  			if dashboardJob.FinishedBuild != nil {
    70  				projects = append(projects, s.buildProject(dashboardJob))
    71  			}
    72  		}
    73  	}
    74  
    75  	w.Header().Set("Content-Type", "application/xml")
    76  	err = xml.NewEncoder(w).Encode(ProjectsContainer{Projects: projects})
    77  
    78  	if err != nil {
    79  		logger.Error("failed-to-serialize-projects", err)
    80  		w.WriteHeader(http.StatusInternalServerError)
    81  		return
    82  	}
    83  }
    84  
    85  func (s *Server) buildProject(j atc.JobSummary) Project {
    86  	var lastBuildStatus string
    87  	switch {
    88  	case db.BuildStatus(j.FinishedBuild.Status) == db.BuildStatusSucceeded:
    89  		lastBuildStatus = "Success"
    90  	case db.BuildStatus(j.FinishedBuild.Status) == db.BuildStatusFailed:
    91  		lastBuildStatus = "Failure"
    92  	default:
    93  		lastBuildStatus = "Exception"
    94  	}
    95  
    96  	var activity string
    97  	if j.NextBuild != nil {
    98  		activity = "Building"
    99  	} else {
   100  		activity = "Sleeping"
   101  	}
   102  
   103  	pipelineRef := atc.PipelineRef{
   104  		Name:         j.PipelineName,
   105  		InstanceVars: j.PipelineInstanceVars,
   106  	}
   107  	return Project{
   108  		Activity:        activity,
   109  		LastBuildLabel:  fmt.Sprint(j.FinishedBuild.Name),
   110  		LastBuildStatus: lastBuildStatus,
   111  		LastBuildTime:   time.Unix(j.FinishedBuild.EndTime, 0).UTC().Format(time.RFC3339),
   112  		Name:            fmt.Sprintf("%s/%s", pipelineRef.String(), j.Name),
   113  		WebUrl:          s.createWebUrl(j.TeamName, j.Name, pipelineRef),
   114  	}
   115  }
   116  
   117  func (s *Server) createWebUrl(teamName, jobName string, pipelineRef atc.PipelineRef) string {
   118  	externalURL, err := url.Parse(s.externalURL)
   119  	if err != nil {
   120  		fmt.Println("Could not parse externalURL")
   121  	}
   122  
   123  	queryParams := pipelineRef.QueryParams().Encode()
   124  	if queryParams != "" {
   125  		queryParams = "?" + queryParams
   126  	}
   127  	pipelineURL, err := url.Parse("/teams/" + teamName + "/pipelines/" + pipelineRef.Name + "/jobs/" + jobName + queryParams)
   128  	if err != nil {
   129  		fmt.Println("Could not parse pipelineURL")
   130  	}
   131  
   132  	return externalURL.ResolveReference(pipelineURL).String()
   133  }