agola/internal/services/gateway/command/project.go

192 lines
6.0 KiB
Go
Raw Normal View History

2019-02-21 16:58:25 +00:00
// Copyright 2019 Sorint.lab
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied
// See the License for the specific language governing permissions and
// limitations under the License.
package command
import (
"context"
"fmt"
"path"
"strings"
"github.com/sorintlab/agola/internal/services/gateway/common"
"github.com/sorintlab/agola/internal/services/types"
"github.com/sorintlab/agola/internal/util"
"github.com/pkg/errors"
)
type CreateProjectRequest struct {
Name string
ParentID string
2019-02-21 16:58:25 +00:00
RemoteSourceName string
RepoPath string
CurrentUserID string
2019-02-21 16:58:25 +00:00
SkipSSHHostKeyCheck bool
}
func (c *CommandHandler) CreateProject(ctx context.Context, req *CreateProjectRequest) (*types.Project, error) {
if !util.ValidateName(req.Name) {
return nil, errors.Errorf("invalid project name %q", req.Name)
}
user, _, err := c.configstoreClient.GetUser(ctx, req.CurrentUserID)
2019-02-21 16:58:25 +00:00
if err != nil {
return nil, errors.Wrapf(err, "failed to get user %q", req.CurrentUserID)
2019-02-21 16:58:25 +00:00
}
rs, _, err := c.configstoreClient.GetRemoteSourceByName(ctx, req.RemoteSourceName)
if err != nil {
return nil, errors.Wrapf(err, "failed to get remote source %q", req.RemoteSourceName)
}
c.log.Infof("rs: %s", util.Dump(rs))
var la *types.LinkedAccount
for _, v := range user.LinkedAccounts {
if v.RemoteSourceID == rs.ID {
la = v
break
}
}
c.log.Infof("la: %s", util.Dump(la))
if la == nil {
return nil, errors.Errorf("user doesn't have a linked account for remote source %q", rs.Name)
}
gitsource, err := common.GetGitSource(rs, la)
if err != nil {
return nil, errors.Wrapf(err, "failed to create gitsource client")
}
repoOwner := strings.TrimPrefix(path.Dir(req.RepoPath), "/")
repoName := path.Base(req.RepoPath)
c.log.Infof("repoOwner: %s, repoName: %s", repoOwner, repoName)
repo, err := gitsource.GetRepoInfo(repoOwner, repoName)
if err != nil {
return nil, errors.Wrapf(err, "failed to get repository info from gitsource")
}
//cloneURL := fmt.Sprintf("git@%s:%s/%s.git", host, repoOwner, repoName)
sshCloneURL := repo.SSHCloneURL
c.log.Infof("sshCloneURL: %s", sshCloneURL)
c.log.Infof("generating ssh key pairs")
privateKey, _, err := util.GenSSHKeyPair(4096)
if err != nil {
return nil, errors.Wrapf(err, "failed to generate ssh key pair")
}
parentID := req.ParentID
if parentID == "" {
// create project in current user namespace
parentID = path.Join("user", user.UserName)
}
2019-02-21 16:58:25 +00:00
p := &types.Project{
Name: req.Name,
Parent: types.Parent{
Type: types.ConfigTypeProjectGroup,
ID: parentID,
},
2019-02-21 16:58:25 +00:00
LinkedAccountID: la.ID,
RepoPath: req.RepoPath,
CloneURL: sshCloneURL,
2019-02-21 16:58:25 +00:00
SkipSSHHostKeyCheck: req.SkipSSHHostKeyCheck,
SSHPrivateKey: string(privateKey),
}
c.log.Infof("creating project")
p, _, err = c.configstoreClient.CreateProject(ctx, p)
if err != nil {
return nil, errors.Wrapf(err, "failed to create project")
}
c.log.Infof("project %s created, ID: %s", p.Name, p.ID)
return p, c.SetupProject(ctx, rs, la, &SetupProjectRequest{
Project: p,
RepoOwner: repoOwner,
RepoName: repoName,
})
}
type SetupProjectRequest struct {
Project *types.Project
RepoOwner string
RepoName string
}
func (c *CommandHandler) SetupProject(ctx context.Context, rs *types.RemoteSource, la *types.LinkedAccount, conf *SetupProjectRequest) error {
gitsource, err := common.GetGitSource(rs, la)
if err != nil {
return errors.Wrapf(err, "failed to create gitsource client")
}
2019-02-21 16:58:25 +00:00
pubKey, err := util.ExtractPublicKey([]byte(conf.Project.SSHPrivateKey))
if err != nil {
return errors.Wrapf(err, "failed to extract public key")
2019-02-21 16:58:25 +00:00
}
webhookURL := fmt.Sprintf("%s/webhooks?projectid=%s", c.apiExposedURL, conf.Project.ID)
// generate deploy keys and webhooks containing the agola project id so we
// can have multiple projects referencing the same remote repository and this
// will trigger multiple different runs
deployKeyName := fmt.Sprintf("agola deploy key - %s", conf.Project.ID)
2019-02-21 16:58:25 +00:00
c.log.Infof("creating/updating deploy key: %s", string(pubKey))
if err := gitsource.UpdateDeployKey(conf.RepoOwner, conf.RepoName, deployKeyName, string(pubKey), true); err != nil {
2019-02-21 16:58:25 +00:00
return errors.Wrapf(err, "failed to create deploy key")
}
c.log.Infof("deleting existing webhooks")
if err := gitsource.DeleteRepoWebhook(conf.RepoOwner, conf.RepoName, webhookURL); err != nil {
return errors.Wrapf(err, "failed to delete repository webhook")
}
c.log.Infof("creating webhook to url: %s", webhookURL)
if err := gitsource.CreateRepoWebhook(conf.RepoOwner, conf.RepoName, webhookURL, ""); err != nil {
return errors.Wrapf(err, "failed to create repository webhook")
}
return nil
}
func (c *CommandHandler) ReconfigProject(ctx context.Context, projectID string) error {
p, _, err := c.configstoreClient.GetProject(ctx, projectID)
2019-02-21 16:58:25 +00:00
if err != nil {
return err
}
user, _, err := c.configstoreClient.GetUserByLinkedAccount(ctx, p.LinkedAccountID)
if err != nil {
return errors.Wrapf(err, "failed to get user with linked account id %q", p.LinkedAccountID)
}
la := user.LinkedAccounts[p.LinkedAccountID]
c.log.Infof("la: %s", util.Dump(la))
if la == nil {
return errors.Errorf("linked account %q in user %q doesn't exist", p.LinkedAccountID, user.UserName)
}
rs, _, err := c.configstoreClient.GetRemoteSource(ctx, la.RemoteSourceID)
if err != nil {
return errors.Wrapf(err, "failed to get remote source %q", la.RemoteSourceID)
}
repoOwner := strings.TrimPrefix(path.Dir(p.RepoPath), "/")
repoName := path.Base(p.RepoPath)
2019-02-21 16:58:25 +00:00
return c.SetupProject(ctx, rs, la, &SetupProjectRequest{
Project: p,
RepoOwner: repoOwner,
RepoName: repoName,
})
}