gateway: add default_branch in projectresponse and /projects/{project…

…ref}/refreshremoterepo api to refresh repo info

internal/gitsources/gitea/gitea.go

@@ -420,11 +420,12 @@ func (c *Client) ListUserRepos() ([]*gitsource.RepoInfo, error) {
 
 func fromGiteaRepo(rr *gitea.Repository) *gitsource.RepoInfo {
 	return &gitsource.RepoInfo{
-		ID:           strconv.FormatInt(rr.ID, 10),
-		Path:         path.Join(rr.Owner.UserName, rr.Name),
-		HTMLURL:      rr.HTMLURL,
-		SSHCloneURL:  rr.SSHURL,
-		HTTPCloneURL: rr.CloneURL,
+		ID:            strconv.FormatInt(rr.ID, 10),
+		Path:          path.Join(rr.Owner.UserName, rr.Name),
+		HTMLURL:       rr.HTMLURL,
+		SSHCloneURL:   rr.SSHURL,
+		HTTPCloneURL:  rr.CloneURL,
+		DefaultBranch: rr.DefaultBranch,
 	}
 }
 

internal/gitsources/github/github.go

@@ -423,11 +423,12 @@ func (c *Client) ListUserRepos() ([]*gitsource.RepoInfo, error) {
 
 func fromGithubRepo(rr *github.Repository) *gitsource.RepoInfo {
 	return &gitsource.RepoInfo{
-		ID:           strconv.FormatInt(*rr.ID, 10),
-		Path:         path.Join(*rr.Owner.Login, *rr.Name),
-		HTMLURL:      *rr.HTMLURL,
-		SSHCloneURL:  *rr.SSHURL,
-		HTTPCloneURL: *rr.CloneURL,
+		ID:            strconv.FormatInt(*rr.ID, 10),
+		Path:          path.Join(*rr.Owner.Login, *rr.Name),
+		HTMLURL:       *rr.HTMLURL,
+		SSHCloneURL:   *rr.SSHURL,
+		HTTPCloneURL:  *rr.CloneURL,
+		DefaultBranch: *rr.DefaultBranch,
 	}
 }
 

internal/gitsources/gitlab/gitlab.go

@@ -297,11 +297,12 @@ func (c *Client) ListUserRepos() ([]*gitsource.RepoInfo, error) {
 
 func fromGitlabRepo(rr *gitlab.Project) *gitsource.RepoInfo {
 	return &gitsource.RepoInfo{
-		ID:           strconv.Itoa(rr.ID),
-		Path:         rr.PathWithNamespace,
-		HTMLURL:      rr.WebURL,
-		SSHCloneURL:  rr.SSHURLToRepo,
-		HTTPCloneURL: rr.HTTPURLToRepo,
+		ID:            strconv.Itoa(rr.ID),
+		Path:          rr.PathWithNamespace,
+		HTMLURL:       rr.WebURL,
+		SSHCloneURL:   rr.SSHURLToRepo,
+		HTTPCloneURL:  rr.HTTPURLToRepo,
+		DefaultBranch: rr.DefaultBranch,
 	}
 }
 

internal/gitsources/gitsource.go

@@ -82,11 +82,12 @@ type Oauth2Source interface {
 }
 
 type RepoInfo struct {
-	ID           string
-	Path         string
-	HTMLURL      string
-	SSHCloneURL  string
-	HTTPCloneURL string
+	ID            string
+	Path          string
+	HTMLURL       string
+	SSHCloneURL   string
+	HTTPCloneURL  string
+	DefaultBranch string
 }
 
 type UserInfo struct {

internal/services/configstore/action/project.go

@@ -93,6 +93,7 @@ type CreateUpdateProjectRequest struct {
 	SSHPrivateKey              string
 	SkipSSHHostKeyCheck        bool
 	PassVarsToForkedPR         bool
+	DefaultBranch              string
 }
 
 func (h *ActionHandler) CreateProject(ctx context.Context, req *CreateUpdateProjectRequest) (*types.Project, error) {
@@ -162,6 +163,7 @@ func (h *ActionHandler) CreateProject(ctx context.Context, req *CreateUpdateProj
 		project.SSHPrivateKey = req.SSHPrivateKey
 		project.SkipSSHHostKeyCheck = req.SkipSSHHostKeyCheck
 		project.PassVarsToForkedPR = req.PassVarsToForkedPR
+		project.DefaultBranch = req.DefaultBranch
 
 		// generate the Secret and the WebhookSecret
 		// TODO(sgotti) move this to the gateway?
@@ -271,6 +273,7 @@ func (h *ActionHandler) UpdateProject(ctx context.Context, curProjectRef string,
 		project.SSHPrivateKey = req.SSHPrivateKey
 		project.SkipSSHHostKeyCheck = req.SkipSSHHostKeyCheck
 		project.PassVarsToForkedPR = req.PassVarsToForkedPR
+		project.DefaultBranch = req.DefaultBranch
 
 		if err := h.d.UpdateProject(tx, project); err != nil {
 			return errors.WithStack(err)

internal/services/configstore/api/project.go

@@ -182,6 +182,7 @@ func (h *CreateProjectHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
 		SSHPrivateKey:              req.SSHPrivateKey,
 		SkipSSHHostKeyCheck:        req.SkipSSHHostKeyCheck,
 		PassVarsToForkedPR:         req.PassVarsToForkedPR,
+		DefaultBranch:              req.DefaultBranch,
 	}
 
 	project, err := h.ah.CreateProject(ctx, areq)
@@ -240,6 +241,7 @@ func (h *UpdateProjectHandler) ServeHTTP(w http.ResponseWriter, r *http.Request)
 		SSHPrivateKey:              req.SSHPrivateKey,
 		SkipSSHHostKeyCheck:        req.SkipSSHHostKeyCheck,
 		PassVarsToForkedPR:         req.PassVarsToForkedPR,
+		DefaultBranch:              req.DefaultBranch,
 	}
 
 	project, err := h.ah.UpdateProject(ctx, projectRef, areq)

internal/services/gateway/action/project.go

@@ -135,6 +135,7 @@ func (h *ActionHandler) CreateProject(ctx context.Context, req *CreateProjectReq
 		SSHPrivateKey:              string(privateKey),
 		SkipSSHHostKeyCheck:        req.SkipSSHHostKeyCheck,
 		PassVarsToForkedPR:         req.PassVarsToForkedPR,
+		DefaultBranch:              repo.DefaultBranch,
 	}
 
 	h.log.Info().Msgf("creating project")
@@ -169,6 +170,8 @@ type UpdateProjectRequest struct {
 
 	Visibility         *cstypes.Visibility
 	PassVarsToForkedPR *bool
+
+	DefaultBranch *string
 }
 
 func (h *ActionHandler) UpdateProject(ctx context.Context, projectRef string, req *UpdateProjectRequest) (*csapitypes.Project, error) {
@@ -197,6 +200,9 @@ func (h *ActionHandler) UpdateProject(ctx context.Context, projectRef string, re
 	if req.PassVarsToForkedPR != nil {
 		p.PassVarsToForkedPR = *req.PassVarsToForkedPR
 	}
+	if req.DefaultBranch != nil {
+		p.DefaultBranch = *req.DefaultBranch
+	}
 
 	creq := &csapitypes.CreateUpdateProjectRequest{
 		Name:                       p.Name,
@@ -210,6 +216,7 @@ func (h *ActionHandler) UpdateProject(ctx context.Context, projectRef string, re
 		SSHPrivateKey:              p.SSHPrivateKey,
 		SkipSSHHostKeyCheck:        p.SkipSSHHostKeyCheck,
 		PassVarsToForkedPR:         p.PassVarsToForkedPR,
+		DefaultBranch:              p.DefaultBranch,
 	}
 
 	h.log.Info().Msgf("updating project")
@@ -584,3 +591,40 @@ func (h *ActionHandler) getRemoteRepoAccessData(ctx context.Context, linkedAccou
 
 	return user, rs, la, nil
 }
+
+func (h *ActionHandler) GetRepoInfo(ctx context.Context, repoPath string, remoteSourceRef string) (*gitsource.RepoInfo, error) {
+	curUserID := common.CurrentUserID(ctx)
+	gitSource, _, _, err := h.GetGitSourceByRemoteSourceRef(ctx, remoteSourceRef, curUserID)
+	if err != nil {
+		return nil, util.NewAPIError(util.KindFromRemoteError(err), errors.Wrapf(err, "failed to get remote source %q", remoteSourceRef))
+	}
+
+	repo, err := gitSource.GetRepoInfo(repoPath)
+	if err != nil {
+		return nil, util.NewAPIError(util.KindFromRemoteError(err), errors.Wrapf(err, "failed to get repository info from gitsource %q", repoPath))
+	}
+
+	return repo, nil
+}
+
+func (h *ActionHandler) RefreshRemoteRepositoryInfo(ctx context.Context, projectRef string) (*csapitypes.Project, error) {
+	project, err := h.GetProject(ctx, projectRef)
+	if err != nil {
+		return nil, util.NewAPIError(util.KindFromRemoteError(err), errors.Wrapf(err, "failed to get project %q", projectRef))
+	}
+
+	repoInfo, err := h.GetRepoInfo(ctx, project.RepositoryPath, project.RemoteSourceID)
+	if err != nil {
+		return nil, util.NewAPIError(util.KindFromRemoteError(err), errors.Wrapf(err, "failed to get repo info %q", project.RepositoryPath))
+	}
+
+	areq := &UpdateProjectRequest{
+		DefaultBranch: &repoInfo.DefaultBranch,
+	}
+	project, err = h.UpdateProject(ctx, projectRef, areq)
+	if err != nil {
+		return nil, util.NewAPIError(util.KindFromRemoteError(err), errors.Wrapf(err, "failed to update project %q", projectRef))
+	}
+
+	return project, nil
+}

internal/services/gateway/action/user.go

@@ -1027,3 +1027,33 @@ func (h *ActionHandler) GetUserGitSource(ctx context.Context, remoteSourceRef, u
 
 	return gitSource, rs, la, nil
 }
+
+func (h *ActionHandler) GetGitSourceByRemoteSourceRef(ctx context.Context, remoteSourceRef, userID string) (gitsource.GitSource, *cstypes.RemoteSource, *cstypes.LinkedAccount, error) {
+	rs, _, err := h.configstoreClient.GetRemoteSource(ctx, remoteSourceRef)
+	if err != nil {
+		return nil, nil, nil, util.NewAPIError(util.KindFromRemoteError(err), errors.Wrapf(err, "failed to get remote source %q", remoteSourceRef))
+	}
+
+	linkedAccounts, _, err := h.configstoreClient.GetUserLinkedAccounts(ctx, userID)
+	if err != nil {
+		return nil, nil, nil, util.NewAPIError(util.KindFromRemoteError(err), errors.Wrapf(err, "failed to get linked accounts for user %q", userID))
+	}
+
+	var la *cstypes.LinkedAccount
+	for _, v := range linkedAccounts {
+		if v.RemoteSourceID == rs.ID {
+			la = v
+			break
+		}
+	}
+	if la == nil {
+		return nil, nil, nil, errors.Errorf("user doesn't have a linked account for remote source %q", rs.Name)
+	}
+
+	gitSource, err := h.GetGitSource(ctx, rs, la.RemoteUserName, la)
+	if err != nil {
+		return nil, nil, nil, util.NewAPIError(util.ErrInternal, errors.Wrapf(err, "failed to create gitea client"))
+	}
+
+	return gitSource, rs, la, nil
+}

internal/services/gateway/api/project.go

@@ -244,6 +244,7 @@ func createProjectResponse(r *csapitypes.Project) *gwapitypes.ProjectResponse {
 		Visibility:         gwapitypes.Visibility(r.Visibility),
 		GlobalVisibility:   string(r.GlobalVisibility),
 		PassVarsToForkedPR: r.PassVarsToForkedPR,
+		DefaultBranch:      r.DefaultBranch,
 	}
 
 	return res
@@ -284,3 +285,33 @@ func (h *ProjectCreateRunHandler) ServeHTTP(w http.ResponseWriter, r *http.Reque
 		h.log.Err(err).Send()
 	}
 }
+
+type RefreshRemoteRepositoryInfoHandler struct {
+	log zerolog.Logger
+	ah  *action.ActionHandler
+}
+
+func NewRefreshRemoteRepositoryInfoHandler(log zerolog.Logger, ah *action.ActionHandler) *RefreshRemoteRepositoryInfoHandler {
+	return &RefreshRemoteRepositoryInfoHandler{log: log, ah: ah}
+}
+
+func (h *RefreshRemoteRepositoryInfoHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+	vars := mux.Vars(r)
+	projectRef, err := url.PathUnescape(vars["projectref"])
+	if err != nil {
+		util.HTTPError(w, util.NewAPIError(util.ErrBadRequest, err))
+		return
+	}
+
+	project, err := h.ah.RefreshRemoteRepositoryInfo(ctx, projectRef)
+	if util.HTTPError(w, err) {
+		h.log.Err(err).Send()
+		return
+	}
+
+	res := createProjectResponse(project)
+	if err := util.HTTPResponse(w, http.StatusCreated, res); err != nil {
+		h.log.Err(err).Send()
+	}
+}

internal/services/gateway/gateway.go

@@ -163,6 +163,7 @@ func (g *Gateway) Run(ctx context.Context) error {
 	projectReconfigHandler := api.NewProjectReconfigHandler(g.log, g.ah)
 	projectUpdateRepoLinkedAccountHandler := api.NewProjectUpdateRepoLinkedAccountHandler(g.log, g.ah)
 	projectCreateRunHandler := api.NewProjectCreateRunHandler(g.log, g.ah)
+	refreshRemoteRepositoryInfoHandler := api.NewRefreshRemoteRepositoryInfoHandler(g.log, g.ah)
 
 	secretHandler := api.NewSecretHandler(g.log, g.ah)
 	createSecretHandler := api.NewCreateSecretHandler(g.log, g.ah)
@@ -263,6 +264,7 @@ func (g *Gateway) Run(ctx context.Context) error {
 	apirouter.Handle("/projects/{projectref}/runs/{runnumber}/tasks/{taskid}/actions", authForcedHandler(projectRunTaskActionsHandler)).Methods("PUT")
 	apirouter.Handle("/projects/{projectref}/runs/{runnumber}/tasks/{taskid}/logs", authOptionalHandler(projectRunLogsHandler)).Methods("GET")
 	apirouter.Handle("/projects/{projectref}/runs/{runnumber}/tasks/{taskid}/logs", authForcedHandler(projectRunLogsDeleteHandler)).Methods("DELETE")
+	apirouter.Handle("/projects/{projectref}/refreshremoterepo", authForcedHandler(refreshRemoteRepositoryInfoHandler)).Methods("PUT")
 
 	apirouter.Handle("/projectgroups/{projectgroupref}/secrets", authForcedHandler(secretHandler)).Methods("GET")
 	apirouter.Handle("/projects/{projectref}/secrets", authForcedHandler(secretHandler)).Methods("GET")

services/configstore/api/types/project.go

@@ -30,6 +30,7 @@ type CreateUpdateProjectRequest struct {
 	SSHPrivateKey              string
 	SkipSSHHostKeyCheck        bool
 	PassVarsToForkedPR         bool
+	DefaultBranch              string
 }
 
 // Project augments cstypes.Project with dynamic data

services/configstore/types/project.go

@@ -86,6 +86,8 @@ type Project struct {
 	WebhookSecret string `json:"webhook_secret,omitempty"`
 
 	PassVarsToForkedPR bool `json:"pass_vars_to_forked_pr,omitempty"`
+
+	DefaultBranch string `json:"default_branch,omitempty"`
 }
 
 func NewProject() *Project {

services/gateway/api/types/project.go

@@ -39,6 +39,7 @@ type ProjectResponse struct {
 	Visibility         Visibility `json:"visibility,omitempty"`
 	GlobalVisibility   string     `json:"global_visibility,omitempty"`
 	PassVarsToForkedPR bool       `json:"pass_vars_to_forked_pr,omitempty"`
+	DefaultBranch      string     `json:"default_branch,omitempty"`
 }
 
 type ProjectCreateRunRequest struct {

services/gateway/client/client.go

@@ -637,3 +637,9 @@ func (c *Client) GetUserOrgs(ctx context.Context) ([]*gwapitypes.UserOrgsRespons
 	resp, err := c.getParsedResponse(ctx, "GET", "/user/orgs", nil, jsonContent, nil, &userOrgs)
 	return userOrgs, resp, errors.WithStack(err)
 }
+
+func (c *Client) RefreshRemoteRepo(ctx context.Context, projectRef string) (*gwapitypes.ProjectResponse, *http.Response, error) {
+	project := new(gwapitypes.ProjectResponse)
+	resp, err := c.getParsedResponse(ctx, "PUT", path.Join("/projects", url.PathEscape(projectRef), "/refreshremoterepo"), nil, jsonContent, nil, project)
+	return project, resp, err
+}

tests/setup_test.go

@@ -2204,3 +2204,51 @@ func TestTaskTimeout(t *testing.T) {
 		})
 	}
 }
+
+func TestRefreshRemoteRepositoryInfo(t *testing.T) {
+	dir, err := ioutil.TempDir("", "agola")
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	defer os.RemoveAll(dir)
+
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	tgitea, c := setup(ctx, t, dir, true)
+	defer shutdownGitea(tgitea)
+
+	giteaAPIURL := fmt.Sprintf("http://%s:%s", tgitea.HTTPListenAddress, tgitea.HTTPPort)
+
+	giteaToken, token := createLinkedAccount(ctx, t, tgitea, c)
+
+	giteaClient := gitea.NewClient(giteaAPIURL, giteaToken)
+	gwClient := gwclient.NewClient(c.Gateway.APIExposedURL, token)
+
+	giteaRepo, project := createProject(ctx, t, giteaClient, gwClient)
+
+	if project.DefaultBranch != "master" {
+		t.Fatalf("expected DefaultBranch master got: %s", project.DefaultBranch)
+	}
+
+	_, err = giteaClient.EditRepo(giteaRepo.Owner.UserName, giteaRepo.Name, gitea.EditRepoOption{DefaultBranch: util.StringP("testbranch")})
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+
+	project, _, err = gwClient.RefreshRemoteRepo(ctx, project.ID)
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if project.DefaultBranch != "testbranch" {
+		t.Fatalf("expected DefaultBranch testbranch got: %s", project.DefaultBranch)
+	}
+
+	p, _, err := gwClient.GetProject(ctx, project.ID)
+	if err != nil {
+		t.Fatalf("unexpected err: %v", err)
+	}
+	if diff := cmp.Diff(project, p); diff != "" {
+		t.Fatalf("projects mismatch (-expected +got):\n%s", diff)
+	}
+}