go/goreleaser
go/goreleaser
1
0
Fork 0
mirror of https://github.com/goreleaser/goreleaser.git synced 2025-03-17 20:47:50 +02:00
Code Issues Releases Activity

Merge pull request #495 from goreleaser/timeout

Browse Source 
feat: make goreleaser timeoutable
This commit is contained in:
Carlos Alexandro Becker 2018-01-02 17:37:33 -02:00 committed by GitHub
commit 62fd78efc5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
18 changed files with 266 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
Gopkg.lock generated
View File

@ -2,9 +2,18 @@
[[projects]]
branch = "master"
name = "github.com/apex/log"
packages = [".","handlers/cli"]
revision = "0296d6eb16bb28f8a0c55668affcf4876dc269be"
packages = [
".",
"handlers/cli"
]
revision = "bf81de4b2280680c3ccdf5520047f055cdafc7e0"
[[projects]]
name = "github.com/caarlos0/ctrlc"
packages = ["."]
revision = "70dc48d5d792f20f684a8f1d29bbac298f4b2ef4"
version = "v1.0.0"
[[projects]]
@ -33,14 +42,21 @@
[[projects]]
name = "github.com/goreleaser/archive"
packages = [".","tar","zip"]
packages = [
".",
"tar",
"zip"
]
revision = "caa5f3f5742eb0535631e94fa5e171c74c0144b7"
version = "v1.0.0"
[[projects]]
branch = "master"
name = "github.com/mattn/go-zglob"
packages = [".","fastwalk"]
packages = [
".",
"fastwalk"
]
revision = "4ecb59231939b2e499b1f2fd8f075565977d2452"
[[projects]]
@ -70,13 +86,19 @@
[[projects]]
branch = "master"
name = "golang.org/x/net"
packages = ["context","context/ctxhttp"]
packages = [
"context",
"context/ctxhttp"
]
revision = "cd69bc3fc700721b709c3a59e16e24c67b58f6ff"
[[projects]]
branch = "master"
name = "golang.org/x/oauth2"
packages = [".","internal"]
packages = [
".",
"internal"
]
revision = "bb50c06baba3d0c76f9d125c0719093e315b5b44"
[[projects]]
@ -87,7 +109,15 @@
[[projects]]
name = "google.golang.org/appengine"
packages = ["internal","internal/base","internal/datastore","internal/log","internal/remote_api","internal/urlfetch","urlfetch"]
packages = [
"internal",
"internal/base",
"internal/datastore",
"internal/log",
"internal/remote_api",
"internal/urlfetch",
"urlfetch"
]
revision = "150dc57a1b433e64154302bdc40b6bb8aefa313a"
version = "v1.0.0"
@ -100,6 +130,6 @@
[solve-meta]
analyzer-name = "dep"
analyzer-version = 1
inputs-digest = "963ab95030179004b910d862fc0048503002cb1029912dbe437ee08e87b31446"
inputs-digest = "7c274a0e93e3a9ae90db19694e64c254f25763565b80c965de42dda3eacf77e8"
solver-name = "gps-cdcl"
solver-version = 1

5
Gopkg.toml
View File

@ -38,3 +38,8 @@
branch = "master"
name = "github.com/apex/log"
[[constraint]]
name = "github.com/caarlos0/ctrlc"
version = "1.0.0"

13
context/context.go
View File

@ -10,6 +10,7 @@ import (
ctx "context"
"os"
"strings"
"time"
"github.com/goreleaser/goreleaser/config"
"github.com/goreleaser/goreleaser/internal/artifact"
@ -41,8 +42,18 @@ type Context struct {
// New context
func New(config config.Project) *Context {
return wrap(ctx.Background(), config)
}
// NewWithTimeout new context with the given timeout
func NewWithTimeout(config config.Project, timeout time.Duration) (*Context, ctx.CancelFunc) {
ctx, cancel := ctx.WithTimeout(ctx.Background(), timeout)
return wrap(ctx, config), cancel
}
func wrap(ctx ctx.Context, config config.Project) *Context {
return &Context{
Context: ctx.Background(),
Context: ctx,
Config: config,
Env: splitEnv(os.Environ()),
Parallelism: 4,

10
context/context_test.go
View File

@ -2,6 +2,7 @@ package context
import (
"testing"
"time"
"github.com/goreleaser/goreleaser/config"
"github.com/stretchr/testify/assert"
@ -12,3 +13,12 @@ func TestNew(t *testing.T) {
assert.NotEmpty(t, ctx.Env)
assert.Equal(t, 4, ctx.Parallelism)
}
func TestNewWithTimeout(t *testing.T) {
ctx, cancel := NewWithTimeout(config.Project{}, time.Second)
assert.NotEmpty(t, ctx.Env)
assert.Equal(t, 4, ctx.Parallelism)
cancel()
<-ctx.Done()
assert.EqualError(t, ctx.Err(), `context canceled`)
}

32
goreleaserlib/goreleaser.go
View File

@ -5,9 +5,11 @@ import (
"io/ioutil"
"os"
"strings"
"time"
"github.com/apex/log"
"github.com/apex/log/handlers/cli"
"github.com/caarlos0/ctrlc"
yaml "gopkg.in/yaml.v2"
"github.com/goreleaser/goreleaser/config"
@ -65,6 +67,7 @@ type Flags interface {
String(s string) string
Int(s string) int
Bool(s string) bool
Duration(s string) time.Duration
}
// Release runs the release process with the given flags
@ -84,7 +87,8 @@ func Release(flags Flags) error {
}
log.WithField("file", file).Warn("could not load config, using defaults")
}
var ctx = context.New(cfg)
ctx, cancel := context.NewWithTimeout(cfg, flags.Duration("timeout"))
defer cancel()
ctx.Parallelism = flags.Int("parallelism")
ctx.Debug = flags.Bool("debug")
log.Debugf("parallelism: %v", ctx.Parallelism)
@ -105,16 +109,26 @@ func Release(flags Flags) error {
ctx.Publish = false
}
ctx.RmDist = flags.Bool("rm-dist")
for _, pipe := range pipes {
cli.Default.Padding = normalPadding
log.Infof("\033[1m%s\033[0m", strings.ToUpper(pipe.String()))
cli.Default.Padding = increasedPadding
if err := handle(pipe.Run(ctx)); err != nil {
return err
return doRelease(ctx)
}
func doRelease(ctx *context.Context) error {
defer restoreOutputPadding()
return ctrlc.Default.Run(ctx, func() error {
for _, pipe := range pipes {
restoreOutputPadding()
log.Infof("\033[1m%s\033[0m", strings.ToUpper(pipe.String()))
cli.Default.Padding = increasedPadding
if err := handle(pipe.Run(ctx)); err != nil {
return err
}
}
}
return nil
})
}
func restoreOutputPadding() {
cli.Default.Padding = normalPadding
return nil
}
func handle(err error) error {

89
goreleaserlib/goreleaser_test.go
View File

@ -6,6 +6,7 @@ import (
"path/filepath"
"strconv"
"testing"
"time"
"github.com/goreleaser/goreleaser/config"
"github.com/goreleaser/goreleaser/internal/testlib"
@ -20,36 +21,21 @@ func init() {
func TestRelease(t *testing.T) {
_, back := setup(t)
defer back()
var flags = fakeFlags{
flags: map[string]string{
"skip-publish": "true",
"skip-validate": "true",
"debug": "true",
"parallelism": "4",
},
}
assert.NoError(t, Release(flags))
assert.NoError(t, Release(newFlags(t, testParams())))
}
func TestSnapshotRelease(t *testing.T) {
_, back := setup(t)
defer back()
var flags = fakeFlags{
flags: map[string]string{
"snapshot": "true",
"parallelism": "4",
},
}
assert.NoError(t, Release(flags))
params := testParams()
params["snapshot"] = "true"
assert.NoError(t, Release(newFlags(t, params)))
}
func TestConfigFileIsSetAndDontExist(t *testing.T) {
var flags = fakeFlags{
flags: map[string]string{
"config": "/this/wont/exist",
},
}
assert.Error(t, Release(flags))
params := testParams()
params["config"] = "/this/wont/exist"
assert.Error(t, Release(newFlags(t, params)))
}
func TestConfigFlagNotSetButExists(t *testing.T) {
@ -69,21 +55,15 @@ func TestConfigFlagNotSetButExists(t *testing.T) {
filepath.Join(folder, name),
),
)
var flags = fakeFlags{
flags: map[string]string{},
}
assert.Equal(t, name, getConfigFile(flags))
assert.Equal(t, name, getConfigFile(newFlags(t, testParams())))
})
}
}
func TestReleaseNotesFileDontExist(t *testing.T) {
var flags = fakeFlags{
flags: map[string]string{
"release-notes": "/this/also/wont/exist",
},
}
assert.Error(t, Release(flags))
params := testParams()
params["release-notes"] = "/this/also/wont/exist"
assert.Error(t, Release(newFlags(t, params)))
}
func TestCustomReleaseNotesFile(t *testing.T) {
@ -91,29 +71,16 @@ func TestCustomReleaseNotesFile(t *testing.T) {
defer back()
var releaseNotes = filepath.Join(folder, "notes.md")
createFile(t, releaseNotes, "nothing important at all")
var flags = fakeFlags{
flags: map[string]string{
"release-notes": releaseNotes,
"skip-publish": "true",
"skip-validate": "true",
"parallelism": "4",
},
}
assert.NoError(t, Release(flags))
var params = testParams()
params["release-notes"] = releaseNotes
assert.NoError(t, Release(newFlags(t, params)))
}
func TestBrokenPipe(t *testing.T) {
_, back := setup(t)
defer back()
createFile(t, "main.go", "not a valid go file")
var flags = fakeFlags{
flags: map[string]string{
"skip-publish": "true",
"skip-validate": "true",
"parallelism": "4",
},
}
assert.Error(t, Release(flags))
assert.Error(t, Release(newFlags(t, testParams())))
}
func TestInitProject(t *testing.T) {
@ -149,9 +116,17 @@ func TestInitProjectDefaultPipeFails(t *testing.T) {
// fakeFlags is a mock of the cli flags
type fakeFlags struct {
t *testing.T
flags map[string]string
}
func newFlags(t *testing.T, params map[string]string) Flags {
return fakeFlags{
t: t,
flags: params,
}
}
func (f fakeFlags) IsSet(s string) bool {
return f.flags[s] != ""
}
@ -169,6 +144,22 @@ func (f fakeFlags) Bool(s string) bool {
return f.flags[s] == "true"
}
func (f fakeFlags) Duration(s string) time.Duration {
result, err := time.ParseDuration(f.flags[s])
assert.NoError(f.t, err)
return result
}
func testParams() map[string]string {
return map[string]string{
"debug": "true",
"parallelism": "4",
"skip-publish": "true",
"skip-validate": "true",
"timeout": "1m",
}
}
func setup(t *testing.T) (current string, back func()) {
folder, err := ioutil.TempDir("", "goreleaser")
assert.NoError(t, err)

5
main.go
View File

@ -63,6 +63,11 @@ func main() {
Name: "debug",
Usage: "Enable debug mode",
},
cli.DurationFlag{
Name: "timeout",
Usage: "How much time the entire release process is allowed to take",
Value: 30 * time.Minute,
},
}
app.Action = func(c *cli.Context) error {
start := time.Now()

14
pipeline/build/build.go
View File

@ -74,7 +74,7 @@ func buildWithDefaults(ctx *context.Context, build config.Build) config.Build {
}
func runPipeOnBuild(ctx *context.Context, build config.Build) error {
if err := runHook(build.Env, build.Hooks.Pre); err != nil {
if err := runHook(ctx, build.Env, build.Hooks.Pre); err != nil {
return errors.Wrap(err, "pre hook failed")
}
sem := make(chan bool, ctx.Parallelism)
@ -93,16 +93,16 @@ func runPipeOnBuild(ctx *context.Context, build config.Build) error {
if err := g.Wait(); err != nil {
return err
}
return errors.Wrap(runHook(build.Env, build.Hooks.Post), "post hook failed")
return errors.Wrap(runHook(ctx, build.Env, build.Hooks.Post), "post hook failed")
}
func runHook(env []string, hook string) error {
func runHook(ctx *context.Context, env []string, hook string) error {
if hook == "" {
return nil
}
log.WithField("hook", hook).Info("running hook")
cmd := strings.Fields(hook)
return run(buildtarget.Runtime, cmd, env)
return run(ctx, buildtarget.Runtime, cmd, env)
}
func doBuild(ctx *context.Context, build config.Build, target buildtarget.Target) error {
@ -119,7 +119,7 @@ func doBuild(ctx *context.Context, build config.Build, target buildtarget.Target
return err
}
cmd = append(cmd, "-ldflags="+flags, "-o", binary, build.Main)
if err := run(target, cmd, build.Env); err != nil {
if err := run(ctx, target, cmd, build.Env); err != nil {
return errors.Wrapf(err, "failed to build for %s", target)
}
ctx.Artifacts.Add(artifact.Artifact{
@ -137,9 +137,9 @@ func doBuild(ctx *context.Context, build config.Build, target buildtarget.Target
return nil
}
func run(target buildtarget.Target, command, env []string) error {
func run(ctx *context.Context, target buildtarget.Target, command, env []string) error {
/* #nosec */
var cmd = exec.Command(command[0], command[1:]...)
var cmd = exec.CommandContext(ctx, command[0], command[1:]...)
env = append(env, target.Env()...)
var log = log.WithField("target", target.PrettyString()).
WithField("env", env).

14
pipeline/build/build_test.go
View File

@ -21,11 +21,21 @@ func TestPipeDescription(t *testing.T) {
}
func TestRun(t *testing.T) {
assert.NoError(t, run(buildtarget.Runtime, []string{"go", "list", "./..."}, emptyEnv))
assert.NoError(t, run(
context.New(config.Project{}),
buildtarget.Runtime,
[]string{"go", "list", "./..."},
emptyEnv,
))
}
func TestRunInvalidCommand(t *testing.T) {
assert.Error(t, run(buildtarget.Runtime, []string{"gggggo", "nope"}, emptyEnv))
assert.Error(t, run(
context.New(config.Project{}),
buildtarget.Runtime,
[]string{"gggggo", "nope"},
emptyEnv,
))
}
func TestBuild(t *testing.T) {

16
pipeline/docker/docker.go
View File

@ -141,11 +141,11 @@ func process(ctx *context.Context, docker config.Docker, artifact artifact.Artif
return errors.Wrapf(err, "failed to link extra file '%s'", file)
}
}
if err := dockerBuild(root, dockerfile, image); err != nil {
if err := dockerBuild(ctx, root, dockerfile, image); err != nil {
return err
}
if docker.Latest {
if err := dockerTag(image, latest); err != nil {
if err := dockerTag(ctx, image, latest); err != nil {
return err
}
}
@ -187,16 +187,16 @@ func publish(ctx *context.Context, docker config.Docker, image, latest string) e
if !docker.Latest {
return nil
}
if err := dockerTag(image, latest); err != nil {
if err := dockerTag(ctx, image, latest); err != nil {
return err
}
return dockerPush(ctx, docker, latest)
}
func dockerBuild(root, dockerfile, image string) error {
func dockerBuild(ctx *context.Context, root, dockerfile, image string) error {
log.WithField("image", image).Info("building docker image")
/* #nosec */
var cmd = exec.Command("docker", "build", "-f", dockerfile, "-t", image, root)
var cmd = exec.CommandContext(ctx, "docker", "build", "-f", dockerfile, "-t", image, root)
log.WithField("cmd", cmd).Debug("executing")
out, err := cmd.CombinedOutput()
if err != nil {
@ -206,10 +206,10 @@ func dockerBuild(root, dockerfile, image string) error {
return nil
}
func dockerTag(image, tag string) error {
func dockerTag(ctx *context.Context, image, tag string) error {
log.WithField("image", image).WithField("tag", tag).Info("tagging docker image")
/* #nosec */
var cmd = exec.Command("docker", "tag", image, tag)
var cmd = exec.CommandContext(ctx, "docker", "tag", image, tag)
log.WithField("cmd", cmd).Debug("executing")
out, err := cmd.CombinedOutput()
if err != nil {
@ -222,7 +222,7 @@ func dockerTag(image, tag string) error {
func dockerPush(ctx *context.Context, docker config.Docker, image string) error {
log.WithField("image", image).Info("pushing docker image")
/* #nosec */
var cmd = exec.Command("docker", "push", image)
var cmd = exec.CommandContext(ctx, "docker", "push", image)
log.WithField("cmd", cmd).Debug("executing")
out, err := cmd.CombinedOutput()
if err != nil {

45
pipeline/docker/docker_test.go
View File

@ -203,30 +203,28 @@ func TestRunPipe(t *testing.T) {
for name, docker := range table {
t.Run(name, func(tt *testing.T) {
folder, err := ioutil.TempDir("", "archivetest")
assert.NoError(t, err)
assert.NoError(tt, err)
var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755))
assert.NoError(tt, os.Mkdir(dist, 0755))
assert.NoError(tt, os.Mkdir(filepath.Join(dist, "mybin"), 0755))
var binPath = filepath.Join(dist, "mybin", "mybin")
_, err = os.Create(binPath)
assert.NoError(t, err)
assert.NoError(tt, err)
var ctx = &context.Context{
Version: "1.0.0",
Publish: docker.publish,
Parallelism: 4,
Artifacts: artifact.New(),
Git: context.GitInfo{
CurrentTag: "v1.0.0",
var ctx = context.New(config.Project{
ProjectName: "mybin",
Dist: dist,
Dockers: []config.Docker{
docker.docker,
},
Config: config.Project{
ProjectName: "mybin",
Dist: dist,
Dockers: []config.Docker{
docker.docker,
},
},
Env: map[string]string{"FOO": "123"},
})
ctx.Publish = true
ctx.Env = map[string]string{
"FOO": "123",
}
ctx.Version = "1.0.0"
ctx.Git = context.GitInfo{
CurrentTag: "v1.0.0",
}
for _, os := range []string{"linux", "darwin"} {
for _, arch := range []string{"amd64", "386"} {
@ -252,14 +250,17 @@ func TestRunPipe(t *testing.T) {
if docker.err == "" {
assert.NoError(tt, err)
} else {
assert.Contains(tt, err.Error(), docker.err)
assert.Error(tt, err)
if err != nil {
assert.Contains(tt, err.Error(), docker.err)
}
}
// this might should not fail as the image should have been created when
// the step ran
for _, img := range docker.expect {
t.Log("removing docker image", img)
assert.NoError(t, exec.Command("docker", "rmi", img).Run(), "could not delete image %s", img)
tt.Log("removing docker image", img)
assert.NoError(tt, exec.Command("docker", "rmi", img).Run(), "could not delete image %s", img)
}
})

6
pipeline/fpm/fpm.go
View File

@ -128,7 +128,7 @@ func create(ctx *context.Context, format, arch string, binaries []artifact.Artif
}
log.WithField("args", options).Debug("creating fpm package")
if out, err := cmd(options).CombinedOutput(); err != nil {
if out, err := cmd(ctx, options).CombinedOutput(); err != nil {
return errors.Wrap(err, string(out))
}
ctx.Artifacts.Add(artifact.Artifact{
@ -142,9 +142,9 @@ func create(ctx *context.Context, format, arch string, binaries []artifact.Artif
return nil
}
func cmd(options []string) *exec.Cmd {
func cmd(ctx *context.Context, options []string) *exec.Cmd {
/* #nosec */
var cmd = exec.Command("fpm", options...)
var cmd = exec.CommandContext(ctx, "fpm", options...)
cmd.Env = []string{fmt.Sprintf("PATH=%s:%s", gnuTarPath, os.Getenv("PATH"))}
for _, env := range os.Environ() {
if strings.HasPrefix(env, "PATH=") {

62
pipeline/fpm/fpm_test.go
View File

@ -36,27 +36,22 @@ func TestRunPipe(t *testing.T) {
var binPath = filepath.Join(dist, "mybin", "mybin")
_, err = os.Create(binPath)
assert.NoError(t, err)
var ctx = &context.Context{
Version: "1.0.0",
Parallelism: runtime.NumCPU(),
Debug: true,
Artifacts: artifact.New(),
Config: config.Project{
ProjectName: "mybin",
Dist: dist,
FPM: config.FPM{
NameTemplate: defaultNameTemplate,
Formats: []string{"deb", "rpm"},
Dependencies: []string{"make"},
Conflicts: []string{"git"},
Description: "Some description",
License: "MIT",
Maintainer: "me@me",
Vendor: "asdf",
Homepage: "https://goreleaser.github.io",
},
var ctx = context.New(config.Project{
ProjectName: "mybin",
Dist: dist,
FPM: config.FPM{
NameTemplate: defaultNameTemplate,
Formats: []string{"deb", "rpm"},
Dependencies: []string{"make"},
Conflicts: []string{"git"},
Description: "Some description",
License: "MIT",
Maintainer: "me@me",
Vendor: "asdf",
Homepage: "https://goreleaser.github.io",
},
}
})
ctx.Version = "1.0.0"
for _, goos := range []string{"linux", "darwin"} {
for _, goarch := range []string{"amd64", "386"} {
ctx.Artifacts.Add(artifact.Artifact{
@ -96,7 +91,7 @@ func TestInvalidNameTemplate(t *testing.T) {
Config: config.Project{
FPM: config.FPM{
NameTemplate: "{{.Foo}",
Formats: []string{"deb"},
Formats: []string{"deb"},
},
},
}
@ -109,27 +104,22 @@ func TestInvalidNameTemplate(t *testing.T) {
assert.Contains(t, Pipe{}.Run(ctx).Error(), `template: {{.Foo}:1: unexpected "}" in operand`)
}
func TestCreateFileDoesntExist(t *testing.T) {
folder, err := ioutil.TempDir("", "archivetest")
assert.NoError(t, err)
var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, os.Mkdir(filepath.Join(dist, "mybin"), 0755))
var ctx = &context.Context{
Version: "1.0.0",
Parallelism: runtime.NumCPU(),
Artifacts: artifact.New(),
Config: config.Project{
Dist: dist,
FPM: config.FPM{
Formats: []string{"deb", "rpm"},
Files: map[string]string{
"testdata/testfile.txt": "/var/lib/test/testfile.txt",
},
var ctx = context.New(config.Project{
Dist: dist,
FPM: config.FPM{
Formats: []string{"deb", "rpm"},
Files: map[string]string{
"testdata/testfile.txt": "/var/lib/test/testfile.txt",
},
},
}
})
ctx.Version = "1.0.0"
ctx.Artifacts.Add(artifact.Artifact{
Name: "mybin",
Path: filepath.Join(dist, "mybin", "mybin"),
@ -141,7 +131,7 @@ func TestCreateFileDoesntExist(t *testing.T) {
}
func TestCmd(t *testing.T) {
cmd := cmd([]string{"--help"})
cmd := cmd(context.New(config.Project{}), []string{"--help"})
assert.NotEmpty(t, cmd.Env)
assert.Contains(t, cmd.Env[0], gnuTarPath)
}
@ -161,7 +151,7 @@ func TestDefaultSet(t *testing.T) {
var ctx = &context.Context{
Config: config.Project{
FPM: config.FPM{
Bindir: "/bin",
Bindir: "/bin",
NameTemplate: "foo",
},
},

2
pipeline/release/body.go
View File

@ -25,7 +25,7 @@ Built with {{ .GoVersion }}`
func describeBody(ctx *context.Context) (bytes.Buffer, error) {
/* #nosec */
bts, err := exec.Command("go", "version").CombinedOutput()
bts, err := exec.CommandContext(ctx, "go", "version").CombinedOutput()
if err != nil {
return bytes.Buffer{}, err
}

6
pipeline/release/body_test.go
View File

@ -60,9 +60,9 @@ func TestDescribeBodyNoDockerImagesNoBrews(t *testing.T) {
func TestDontEscapeHTML(t *testing.T) {
var changelog = "<h1>test</h1>"
var ctx = &context.Context{
ReleaseNotes: changelog,
}
var ctx = context.New(config.Project{})
ctx.ReleaseNotes = changelog
out, err := describeBody(ctx)
assert.NoError(t, err)
assert.Contains(t, out.String(), changelog)

2
pipeline/sign/sign.go
View File

@ -92,7 +92,7 @@ func signone(ctx *context.Context, artifact artifact.Artifact) (string, error) {
// However, this works as intended. The nosec annotation
// tells the scanner to ignore this.
// #nosec
cmd := exec.Command(cfg.Cmd, args...)
cmd := exec.CommandContext(ctx, cfg.Cmd, args...)
output, err := cmd.CombinedOutput()
if err != nil {
return "", fmt.Errorf("sign: %s failed with %q", cfg.Cmd, string(output))

2
pipeline/snapcraft/snapcraft.go
View File

@ -163,7 +163,7 @@ func create(ctx *context.Context, arch string, binaries []artifact.Artifact) err
var snap = filepath.Join(ctx.Config.Dist, folder+".snap")
/* #nosec */
var cmd = exec.Command("snapcraft", "snap", primeDir, "--output", snap)
var cmd = exec.CommandContext(ctx, "snapcraft", "snap", primeDir, "--output", snap)
if out, err = cmd.CombinedOutput(); err != nil {
return fmt.Errorf("failed to generate snap package: %s", string(out))
}

110
pipeline/snapcraft/snapcraft_test.go
View File

@ -46,19 +46,16 @@ func TestRunPipe(t *testing.T) {
var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, err)
var ctx = &context.Context{
Version: "testversion",
Artifacts: artifact.New(),
Config: config.Project{
ProjectName: "mybin",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}}",
Summary: "test summary",
Description: "test description",
},
var ctx = context.New(config.Project{
ProjectName: "mybin",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}}",
Summary: "test summary",
Description: "test description",
},
}
})
ctx.Version = "testversion"
addBinaries(t, ctx, "mybin", dist)
assert.NoError(t, Pipe{}.Run(ctx))
}
@ -69,19 +66,16 @@ func TestRunPipeInvalidNameTemplate(t *testing.T) {
var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, err)
var ctx = &context.Context{
Version: "testversion",
Artifacts: artifact.New(),
Config: config.Project{
ProjectName: "mybin",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}",
Summary: "test summary",
Description: "test description",
},
var ctx = context.New(config.Project{
ProjectName: "mybin",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}",
Summary: "test summary",
Description: "test description",
},
}
})
ctx.Version = "testversion"
addBinaries(t, ctx, "mybin", dist)
assert.EqualError(t, Pipe{}.Run(ctx), `template: foo_{{.Arch}:1: unexpected "}" in operand`)
}
@ -92,20 +86,17 @@ func TestRunPipeWithName(t *testing.T) {
var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, err)
var ctx = &context.Context{
Version: "testversion",
Artifacts: artifact.New(),
Config: config.Project{
ProjectName: "testprojectname",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}}",
Name: "testsnapname",
Summary: "test summary",
Description: "test description",
},
var ctx = context.New(config.Project{
ProjectName: "testprojectname",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}}",
Name: "testsnapname",
Summary: "test summary",
Description: "test description",
},
}
})
ctx.Version = "testversion"
addBinaries(t, ctx, "testprojectname", dist)
assert.NoError(t, Pipe{}.Run(ctx))
yamlFile, err := ioutil.ReadFile(filepath.Join(dist, "foo_amd64", "prime", "meta", "snap.yaml"))
@ -122,25 +113,22 @@ func TestRunPipeWithPlugsAndDaemon(t *testing.T) {
var dist = filepath.Join(folder, "dist")
assert.NoError(t, os.Mkdir(dist, 0755))
assert.NoError(t, err)
var ctx = &context.Context{
Version: "testversion",
Artifacts: artifact.New(),
Config: config.Project{
ProjectName: "mybin",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}}",
Summary: "test summary",
Description: "test description",
Apps: map[string]config.SnapcraftAppMetadata{
"mybin": {
Plugs: []string{"home", "network"},
Daemon: "simple",
},
var ctx = context.New(config.Project{
ProjectName: "mybin",
Dist: dist,
Snapcraft: config.Snapcraft{
NameTemplate: "foo_{{.Arch}}",
Summary: "test summary",
Description: "test description",
Apps: map[string]config.SnapcraftAppMetadata{
"mybin": {
Plugs: []string{"home", "network"},
Daemon: "simple",
},
},
},
}
})
ctx.Version = "testversion"
addBinaries(t, ctx, "mybin", dist)
assert.NoError(t, Pipe{}.Run(ctx))
yamlFile, err := ioutil.ReadFile(filepath.Join(dist, "foo_amd64", "prime", "meta", "snap.yaml"))
@ -158,20 +146,18 @@ func TestNoSnapcraftInPath(t *testing.T) {
assert.NoError(t, os.Setenv("PATH", path))
}()
assert.NoError(t, os.Setenv("PATH", ""))
var ctx = &context.Context{
Config: config.Project{
Snapcraft: config.Snapcraft{
Summary: "dummy",
Description: "dummy",
},
var ctx = context.New(config.Project{
Snapcraft: config.Snapcraft{
Summary: "dummy",
Description: "dummy",
},
}
})
assert.EqualError(t, Pipe{}.Run(ctx), ErrNoSnapcraft.Error())
}
func TestDefault(t *testing.T) {
var ctx = context.New(config.Project{})
assert.NoError(t,Pipe{}.Default(ctx))
assert.NoError(t, Pipe{}.Default(ctx))
assert.Equal(t, defaultNameTemplate, ctx.Config.Snapcraft.NameTemplate)
}
@ -181,7 +167,7 @@ func TestDefaultSet(t *testing.T) {
NameTemplate: "foo",
},
})
assert.NoError(t,Pipe{}.Default(ctx))
assert.NoError(t, Pipe{}.Default(ctx))
assert.Equal(t, "foo", ctx.Config.Snapcraft.NameTemplate)
}