Jared Allard
09d39ad36d
Adds a new `checkout` step intended to replace `git checkout` by actually checking out the correct revision when running commands. Adds a new `upload_artifact` step that uploads an artifact to a package specific prefix. Primarily intended for supporting Go dependency archives, but could also be used for anything. Added `net-vpn/tailscale` using this new functionality.
110 lines
3 KiB
Go
110 lines
3 KiB
Go
// Copyright (C) 2024 Jared Allard
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
// Pack steps contains a generic step runner in the context of being
|
|
// able to encapsulate custom logic for updating ebuilds.
|
|
package steps
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"gopkg.in/yaml.v3"
|
|
)
|
|
|
|
// StepRunner is a generic interface that all step runners must implement.
|
|
type StepRunner interface {
|
|
// Run runs the step. The first argument should be the input provided
|
|
// through the configuration file.
|
|
Run(context.Context, Environment) (*StepOutput, error)
|
|
}
|
|
|
|
// StepOutput is the output of a step, if applicable.
|
|
type StepOutput struct {
|
|
// Ebuild is the contents of the ebuild that was generated.
|
|
Ebuild []byte
|
|
|
|
// Manifest is the contents of the manifest that was generated.
|
|
Manifest []byte
|
|
}
|
|
|
|
// Steps contains a collection of steps.
|
|
type Steps []Step
|
|
|
|
// Step encapsulates a step that should be ran.
|
|
type Step struct {
|
|
// Args are the arguments that were provided to the step.
|
|
Args any
|
|
|
|
// Runner is the runner that runs this step.
|
|
Runner StepRunner
|
|
}
|
|
|
|
// UnmarshalYAML unmarshals the steps from the YAML configuration file
|
|
// turning them into their type safe representations.
|
|
func (s *Steps) UnmarshalYAML(node *yaml.Node) error {
|
|
var raw []any
|
|
if err := node.Decode(&raw); err != nil {
|
|
return err
|
|
}
|
|
|
|
// knownSteps map of key values to their respective steps.
|
|
knownSteps := map[string]func(any) (StepRunner, error){
|
|
"command": NewCommandStep,
|
|
"checkout": NewCheckoutStep,
|
|
"ebuild": NewEbuildStep,
|
|
"original_ebuild": NewOriginalEbuildStep,
|
|
"upload_artifact": NewUploadArtifactStep,
|
|
}
|
|
|
|
for _, rawStep := range raw {
|
|
var stepName string
|
|
var stepData any
|
|
|
|
switch rawStep := rawStep.(type) {
|
|
case map[string]any:
|
|
// If there's more than one key, fail.
|
|
if len(rawStep) != 1 {
|
|
return fmt.Errorf("expected one key on step, got %d", len(rawStep))
|
|
}
|
|
|
|
// If it's a map, use the first key.
|
|
for key, value := range rawStep {
|
|
stepName = key
|
|
stepData = value
|
|
break
|
|
}
|
|
case string:
|
|
// If it's just a string, then we use it as-is.
|
|
stepName = rawStep
|
|
}
|
|
|
|
if _, ok := knownSteps[stepName]; !ok {
|
|
return fmt.Errorf("unknown step: %s", stepName)
|
|
}
|
|
|
|
step, err := knownSteps[stepName](stepData)
|
|
if err != nil {
|
|
return fmt.Errorf("failed to create step: %w", err)
|
|
}
|
|
|
|
*s = append(*s, Step{
|
|
Args: stepData,
|
|
Runner: step,
|
|
})
|
|
}
|
|
|
|
return nil
|
|
}
|