---

environment:

- CONVEY_VERSION=0.14.0-dev

tasks:

# tasks for the default plan

import:

image: ${GO_IMAGE}

workdir: ${CONVEY_WORKSPACE}

command: go test ./...

type: docker/run

image: ${GO_IMAGE}

workdir: ${CONVEY_WORKSPACE}

environment:

- CGO_ENABLED=0

- GOOS=linux

environment:

- GOOS=windows

environment:

- GOOS=darwin

environment:

- GOOS=freebsd

plans:

default:

stages:

tasks:

- import

- name: testing

- name: build

concurrent: true

tasks:

- name: export

tasks:

- export

"keep.imfreedom.org/grim/convey/normalize"

)

repo, err := govcs.Detect(wd)

if err != nil {

return nil

name := strings.ToUpper(repo.Name())

// check for vcs specific values. If this grows past 1, make it a switch

// type.

if hg, ok := repo.(*hg.Mercurial); ok {

}

return nil

}

// LoadDefaults will load the default environment variables for a convey run.

oldHome := os.Getenv("HOME")

err := e.loadVCS(wd)

if err != nil {

package environment

import (

"strings"

)

// splitEqual takes a string like "foo=bar" and returns it as ("foo", "bar")

func splitEqual(value string) (string, string) {

return parts[0], parts[1]

}

}

}

}

}

return e

}

return e

}

}

log "github.com/sirupsen/logrus"

"keep.imfreedom.org/grim/convey/logging"

"keep.imfreedom.org/grim/convey/runtime"

"keep.imfreedom.org/grim/convey/stages"

}

// Execute runs the plan.

if err := p.Valid(); err != nil {

return err

}

p.logger = logging.NewAdapter(path)

commandv []string

}

// Create a new environment based on the stage's environment. Then merge

// the task's environment overriding anything from the stage. Finally merge

// the runtime enviroment which holds the environment from the command line.

if workspace == "" {

workspace = "/workspace"

}

return err

}

generator := exec.NewGenerator(

"podman",

"run",

// If the user specified a workdir, use it.

if r.Workdir != "" {

}

// Append the image name.

if len(r.commandv) > 0 {

}

return exec.Run(name, generator.Command(), rt.Timeout)

var (

Tasks = map[string]tasks.Task{

"podman/run": &Run{},

"docker/run": &Run{},

}

)

"time"

"keep.imfreedom.org/grim/convey/config"

"keep.imfreedom.org/grim/convey/globals"

"keep.imfreedom.org/grim/convey/logging"

"keep.imfreedom.org/grim/convey/runtime"

rt := runtime.New(configPath, c.ForceSequential, c.KeepWorkspace, c.Timeout)

defer rt.Shutdown()

for _, name := range c.Plans {

plan := cfg.Plans[name]

if err != nil {

return err

}

)

type Runtime struct {

ConfigPath string

ForceSequential bool

)

}

rt := &Runtime{

Environment: env,

ConfigPath: configPath,

Timeout: timeout,

}

return rt

}

}

// Execute runs the stage.

if s.Concurrent && !rt.ForceSequential {

taskRes := make(chan error)

return nil

}

absTaskName := fmt.Sprintf("%s/%s", path, name)

taskLogger := logging.NewAdapter(fmt.Sprintf("%s/%s", path, name))

## convey/clean Task

### Attributes

| Name | Required | Default | Description |

| --------- | -------- | ------- | ----------- |

### Example

----

## convey/fail Task

### Attributes

----

## convey/noop Task

A noop task does nothing. It is a "No Operation" task. It's used primarily in

clean:

type: convey/noop

Files yaml.StringOrSlice `yaml:"files"`

}

}

pathname, err := filepath.Abs(filename)

return pathname, nil

}

list := []string{}

for _, file := range files {

sanitized, err := sanitizeFile(base, file, env)

}

// Execute runs the clean task.

fullEnv := environment.New()

fullEnv.Merge(env)

fullEnv.Merge(rt.Environment)

}

for _, pattern := range c.Files {

}

matches, err := zglob.Glob(expandedPattern)

}

for _, path := range matches {

if err != nil {

return err

}

}

// Execute runs the count task.

c.Count += 1

return nil

package tasks

import (

log "github.com/sirupsen/logrus"

type Export struct {

Files yaml.StringOrSlice `yaml:"files"`

}

// New creates a new Export task.

}

// Executes the task

fullEnv := env.Copy().Merge(rt.Environment)

for _, pattern := range e.Files {

spec := fs.ParsePathSpec(pattern)

}

return nil

type Fail struct{}

// Execute runs the fail task.

return fmt.Errorf("convey/fail task always fails")

}

}

// Executes the task

for _, pattern := range i.Files {

spec := fs.ParsePathSpec(pattern)

matches, err := filepath.Glob(filepath.Join(rt.ConfigPath, spec.Source()))

type Noop struct{}

// Execute runs the noop task.

return nil

}

var (

// Tasks is the list of tasks defined in this package.

Tasks = map[string]Task{

}

)

// Task is an interface for defining a task that can be run.

type Task interface {

New() Task

Valid() error

}