woodpecker/pipeline/stepBuilder.go

419 lines
11 KiB
Go
Raw Normal View History

// Copyright 2022 Woodpecker Authors
2019-06-01 08:17:02 +00:00
// Copyright 2018 Drone.IO Inc.
//
// 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.
2022-11-06 11:44:04 +00:00
package pipeline
2019-06-01 08:17:02 +00:00
import (
"fmt"
"net/url"
"path/filepath"
2019-06-01 08:17:02 +00:00
"strings"
"github.com/drone/envsubst"
"github.com/oklog/ulid/v2"
"github.com/rs/zerolog/log"
backend "github.com/woodpecker-ci/woodpecker/pipeline/backend/types"
"github.com/woodpecker-ci/woodpecker/pipeline/frontend"
"github.com/woodpecker-ci/woodpecker/pipeline/frontend/yaml"
"github.com/woodpecker-ci/woodpecker/pipeline/frontend/yaml/compiler"
"github.com/woodpecker-ci/woodpecker/pipeline/frontend/yaml/linter"
"github.com/woodpecker-ci/woodpecker/pipeline/frontend/yaml/matrix"
"github.com/woodpecker-ci/woodpecker/server"
2022-11-06 11:44:04 +00:00
forge_types "github.com/woodpecker-ci/woodpecker/server/forge/types"
"github.com/woodpecker-ci/woodpecker/server/model"
2019-06-01 08:17:02 +00:00
)
// StepBuilder Takes the hook data and the yaml and returns in internal data model
type StepBuilder struct {
Repo *model.Repo
Curr *model.Pipeline
Last *model.Pipeline
Netrc *model.Netrc
Secs []*model.Secret
Regs []*model.Registry
Link string
2022-11-06 11:44:04 +00:00
Yamls []*forge_types.FileMeta
Envs map[string]string
2019-06-01 08:17:02 +00:00
}
2022-11-06 11:44:04 +00:00
type Item struct {
Workflow *model.Step
2019-06-13 15:38:19 +00:00
Platform string
Labels map[string]string
DependsOn []string
RunsOn []string
2019-06-13 15:38:19 +00:00
Config *backend.Config
2019-06-01 08:17:02 +00:00
}
2022-11-06 11:44:04 +00:00
func (b *StepBuilder) Build() ([]*Item, error) {
var items []*Item
2019-06-01 08:17:02 +00:00
2022-11-06 11:44:04 +00:00
b.Yamls = forge_types.SortByName(b.Yamls)
2019-07-19 07:17:47 +00:00
pidSequence := 1
for _, y := range b.Yamls {
2019-06-05 13:58:27 +00:00
// matrix axes
2019-06-13 15:38:19 +00:00
axes, err := matrix.ParseString(string(y.Data))
if err != nil {
return nil, err
2019-06-01 08:17:02 +00:00
}
if len(axes) == 0 {
axes = append(axes, matrix.Axis{})
2019-06-01 08:17:02 +00:00
}
2019-07-19 07:17:47 +00:00
for _, axis := range axes {
workflow := &model.Step{
PipelineID: b.Curr.ID,
PID: pidSequence,
PGID: pidSequence,
State: model.StatusPending,
Environ: axis,
Name: SanitizePath(y.Name),
2019-06-01 08:17:02 +00:00
}
metadata := metadataFromStruct(b.Repo, b.Curr, b.Last, workflow, b.Link)
2019-06-05 13:58:27 +00:00
environ := b.environmentVariables(metadata, axis)
2019-06-01 08:17:02 +00:00
// add global environment variables for substituting
for k, v := range b.Envs {
if _, exists := environ[k]; exists {
// don't override existing values
continue
}
environ[k] = v
}
2019-06-05 13:58:27 +00:00
// substitute vars
substituted, err := b.envsubst(string(y.Data), environ)
if err != nil {
return nil, err
}
2019-06-05 13:58:27 +00:00
// parse yaml pipeline
2019-06-13 15:38:19 +00:00
parsed, err := yaml.ParseString(substituted)
if err != nil {
return nil, &yaml.PipelineParseError{Err: err}
}
2019-06-05 13:58:27 +00:00
// lint pipeline
if err := linter.New(
linter.WithTrusted(b.Repo.IsTrusted),
).Lint(parsed); err != nil {
return nil, &yaml.PipelineParseError{Err: err}
}
// checking if filtered.
if match, err := parsed.When.Match(metadata, true); !match && err == nil {
log.Debug().Str("pipeline", workflow.Name).Msg(
"Marked as skipped, dose not match metadata",
)
workflow.State = model.StatusSkipped
} else if err != nil {
log.Debug().Str("pipeline", workflow.Name).Msg(
"Pipeline config could not be parsed",
)
return nil, err
}
// TODO: deprecated branches filter => remove after some time
if !parsed.Branches.Match(b.Curr.Branch) && (b.Curr.Event != model.EventDeploy && b.Curr.Event != model.EventTag) {
log.Debug().Str("pipeline", workflow.Name).Msg(
"Marked as skipped, dose not match branch",
)
workflow.State = model.StatusSkipped
2019-06-19 07:36:54 +00:00
}
ir, err := b.toInternalRepresentation(parsed, environ, metadata, workflow.ID)
if err != nil {
return nil, err
}
if len(ir.Stages) == 0 {
continue
}
2022-11-06 11:44:04 +00:00
item := &Item{
Workflow: workflow,
2019-06-13 15:38:19 +00:00
Config: ir,
Labels: parsed.Labels,
DependsOn: parsed.DependsOn,
RunsOn: parsed.RunsOn,
Platform: parsed.Platform,
}
if item.Labels == nil {
item.Labels = map[string]string{}
}
items = append(items, item)
2019-07-19 07:17:47 +00:00
pidSequence++
2019-06-01 08:17:02 +00:00
}
}
items = filterItemsWithMissingDependencies(items)
// check if at least one step can start, if list is not empty
if len(items) > 0 && !stepListContainsItemsToRun(items) {
return nil, fmt.Errorf("pipeline has no startpoint")
}
2019-06-01 08:17:02 +00:00
return items, nil
}
2022-11-06 11:44:04 +00:00
func stepListContainsItemsToRun(items []*Item) bool {
for i := range items {
if items[i].Workflow.State == model.StatusPending {
return true
}
}
return false
}
2022-11-06 11:44:04 +00:00
func filterItemsWithMissingDependencies(items []*Item) []*Item {
itemsToRemove := make([]*Item, 0)
for _, item := range items {
for _, dep := range item.DependsOn {
if !containsItemWithName(dep, items) {
itemsToRemove = append(itemsToRemove, item)
}
}
}
if len(itemsToRemove) > 0 {
2022-11-06 11:44:04 +00:00
filtered := make([]*Item, 0)
for _, item := range items {
if !containsItemWithName(item.Workflow.Name, itemsToRemove) {
filtered = append(filtered, item)
}
}
// Recursive to handle transitive deps
return filterItemsWithMissingDependencies(filtered)
}
return items
}
2022-11-06 11:44:04 +00:00
func containsItemWithName(name string, items []*Item) bool {
for _, item := range items {
if name == item.Workflow.Name {
return true
}
}
return false
}
func (b *StepBuilder) envsubst(y string, environ map[string]string) (string, error) {
2019-06-05 13:58:27 +00:00
return envsubst.Eval(y, func(name string) string {
env := environ[name]
if strings.Contains(env, "\n") {
env = fmt.Sprintf("%q", env)
}
return env
})
}
func (b *StepBuilder) environmentVariables(metadata frontend.Metadata, axis matrix.Axis) map[string]string {
2019-06-05 13:58:27 +00:00
environ := metadata.Environ()
for k, v := range axis {
environ[k] = v
}
return environ
}
func (b *StepBuilder) toInternalRepresentation(parsed *yaml.Config, environ map[string]string, metadata frontend.Metadata, stepID int64) (*backend.Config, error) {
2019-06-05 13:58:27 +00:00
var secrets []compiler.Secret
for _, sec := range b.Secs {
if !sec.Match(b.Curr.Event) {
continue
}
secrets = append(secrets, compiler.Secret{
Name: sec.Name,
Value: sec.Value,
Match: sec.Images,
PluginOnly: sec.PluginsOnly,
2019-06-05 13:58:27 +00:00
})
}
var registries []compiler.Registry
for _, reg := range b.Regs {
registries = append(registries, compiler.Registry{
Hostname: reg.Address,
Username: reg.Username,
Password: reg.Password,
Email: reg.Email,
})
}
return compiler.New(
compiler.WithEnviron(environ),
compiler.WithEnviron(b.Envs),
compiler.WithEscalated(server.Config.Pipeline.Privileged...),
compiler.WithResourceLimit(server.Config.Pipeline.Limits.MemSwapLimit, server.Config.Pipeline.Limits.MemLimit, server.Config.Pipeline.Limits.ShmSize, server.Config.Pipeline.Limits.CPUQuota, server.Config.Pipeline.Limits.CPUShares, server.Config.Pipeline.Limits.CPUSet),
compiler.WithVolumes(server.Config.Pipeline.Volumes...),
compiler.WithNetworks(server.Config.Pipeline.Networks...),
2019-06-05 13:58:27 +00:00
compiler.WithLocal(false),
compiler.WithOption(
compiler.WithNetrc(
b.Netrc.Login,
b.Netrc.Password,
b.Netrc.Machine,
),
b.Repo.IsSCMPrivate || server.Config.Pipeline.AuthenticatePublicRepos,
2019-06-05 13:58:27 +00:00
),
compiler.WithDefaultCloneImage(server.Config.Pipeline.DefaultCloneImage),
2019-06-05 13:58:27 +00:00
compiler.WithRegistry(registries...),
compiler.WithSecret(secrets...),
compiler.WithPrefix(
fmt.Sprintf(
"wp_%s_%d",
strings.ToLower(ulid.Make().String()),
stepID,
2019-06-05 13:58:27 +00:00
),
),
compiler.WithProxy(),
compiler.WithWorkspaceFromURL("/woodpecker", b.Repo.Link),
2019-06-05 13:58:27 +00:00
compiler.WithMetadata(metadata),
compiler.WithTrusted(b.Repo.IsTrusted),
compiler.WithNetrcOnlyTrusted(b.Repo.NetrcOnlyTrusted),
2019-06-05 13:58:27 +00:00
).Compile(parsed)
}
2022-11-06 11:44:04 +00:00
func SetPipelineStepsOnPipeline(pipeline *model.Pipeline, pipelineItems []*Item) *model.Pipeline {
var pidSequence int
for _, item := range pipelineItems {
pipeline.Steps = append(pipeline.Steps, item.Workflow)
if pidSequence < item.Workflow.PID {
pidSequence = item.Workflow.PID
}
2019-07-22 11:43:18 +00:00
}
for _, item := range pipelineItems {
for _, stage := range item.Config.Stages {
var gid int
for _, step := range stage.Steps {
pidSequence++
if gid == 0 {
gid = pidSequence
}
step := &model.Step{
PipelineID: pipeline.ID,
Name: step.Alias,
PID: pidSequence,
PPID: item.Workflow.PID,
PGID: gid,
State: model.StatusPending,
}
if item.Workflow.State == model.StatusSkipped {
step.State = model.StatusSkipped
2019-06-19 07:36:54 +00:00
}
pipeline.Steps = append(pipeline.Steps, step)
}
}
}
2019-07-22 11:43:18 +00:00
return pipeline
}
2019-06-01 08:17:02 +00:00
// return the metadata from the cli context.
func metadataFromStruct(repo *model.Repo, pipeline, last *model.Pipeline, workflow *model.Step, link string) frontend.Metadata {
2019-06-01 08:17:02 +00:00
host := link
uri, err := url.Parse(link)
if err == nil {
host = uri.Host
}
2023-05-31 16:30:41 +00:00
forge := frontend.Forge{}
if server.Config.Services.Forge != nil {
forge = frontend.Forge{
Type: server.Config.Services.Forge.Name(),
URL: server.Config.Services.Forge.URL(),
}
}
2019-06-01 08:17:02 +00:00
return frontend.Metadata{
Repo: frontend.Repo{
Name: repo.FullName,
Link: repo.Link,
CloneURL: repo.Clone,
Private: repo.IsSCMPrivate,
Branch: repo.Branch,
2019-06-01 08:17:02 +00:00
},
Curr: metadataPipelineFromModelPipeline(pipeline, true),
Prev: metadataPipelineFromModelPipeline(last, false),
Workflow: frontend.Workflow{
Name: workflow.Name,
Number: workflow.PID,
Matrix: workflow.Environ,
2019-06-01 08:17:02 +00:00
},
Step: frontend.Step{},
2019-06-01 08:17:02 +00:00
Sys: frontend.System{
Name: "woodpecker",
Link: link,
Host: host,
Platform: "", // will be set by pipeline platform option or by agent
2019-06-01 08:17:02 +00:00
},
2023-05-31 16:30:41 +00:00
Forge: forge,
2019-06-01 08:17:02 +00:00
}
}
2019-06-13 15:38:19 +00:00
func metadataPipelineFromModelPipeline(pipeline *model.Pipeline, includeParent bool) frontend.Pipeline {
cron := ""
if pipeline.Event == model.EventCron {
cron = pipeline.Sender
}
parent := int64(0)
if includeParent {
parent = pipeline.Parent
}
return frontend.Pipeline{
Number: pipeline.Number,
Parent: parent,
Created: pipeline.Created,
Started: pipeline.Started,
Finished: pipeline.Finished,
Status: string(pipeline.Status),
Event: string(pipeline.Event),
Link: pipeline.Link,
Target: pipeline.Deploy,
Commit: frontend.Commit{
Sha: pipeline.Commit,
Ref: pipeline.Ref,
Refspec: pipeline.Refspec,
Branch: pipeline.Branch,
Message: pipeline.Message,
Author: frontend.Author{
Name: pipeline.Author,
Email: pipeline.Email,
Avatar: pipeline.Avatar,
},
ChangedFiles: pipeline.ChangedFiles,
PullRequestLabels: pipeline.PullRequestLabels,
},
Cron: cron,
}
}
func SanitizePath(path string) string {
path = filepath.Base(path)
2019-06-13 15:38:19 +00:00
path = strings.TrimSuffix(path, ".yml")
path = strings.TrimSuffix(path, ".yaml")
2019-06-13 15:38:19 +00:00
path = strings.TrimPrefix(path, ".")
return path
}