func (a *App) actionTest(rctx router.Context) error {
ctx := rctx.(*app.Context)
// Rebuild
if err := a.actionRebuild(rctx); err != nil {
return err
}
// Verify we have the files
dir := filepath.Join(filepath.Dir(ctx.Appfile.Path), "_scriptpack_staging")
if _, err := os.Stat(dir); err != nil {
return fmt.Errorf(
"The directory with the built ScriptPack files doesn't exist!\n" +
"Please build this with `otto dev scriptpack-rebuild` prior to\n" +
"running tests.")
}
// Get the env vars
f, err := os.Open(filepath.Join(dir, "env"))
if err != nil {
return err
}
var env map[string]string
err = json.NewDecoder(f).Decode(&env)
f.Close()
if err != nil {
return err
}
// Build the command we execute to run the tests
cmd := []string{
"docker",
"run",
"-v /vagrant:/devroot",
}
for k, v := range env {
cmd = append(cmd, fmt.Sprintf("-e %s=%s", k, v))
}
cmd = append(cmd, "hashicorp/otto-scriptpack-test-ubuntu:14.04")
cmd = append(cmd, "bats")
// Determine the test to execute
testPath := "test"
if args := rctx.RouteArgs(); len(args) > 0 {
testPath = args[0]
}
if !filepath.IsAbs(testPath) {
testPath = fmt.Sprintf("/devroot/" + testPath)
}
cmd = append(cmd, testPath)
// Run the command
ctx.Ui.Header(fmt.Sprintf("Executing: %s", strings.Join(cmd, " ")))
v := &vagrant.DevOptions{}
v.Vagrant(ctx).Execute("ssh", "-c", strings.Join(cmd, " "))
return nil
}
func (opts *DevOptions) actionLayers(rctx router.Context) error {
if opts.Layer == nil {
return fmt.Errorf(
"This development environment does not use layers.\n" +
"This command can only be used to manage development\n" +
"environments with layers.")
}
ctx := rctx.(*app.Context)
fs := flag.NewFlagSet("otto", flag.ContinueOnError)
graph := fs.Bool("graph", false, "show graph")
prune := fs.Bool("prune", false, "prune unused layers")
if err := fs.Parse(rctx.RouteArgs()); err != nil {
return err
}
// Graph?
if *graph {
graph, err := opts.Layer.Graph()
if err != nil {
return err
}
ctx.Ui.Raw(graph.String() + "\n")
return nil
}
// Prune?
if *prune {
ctx.Ui.Header("Pruning any outdated or unused layers...")
count, err := opts.Layer.Prune(&ctx.Shared)
if err != nil {
return err
}
if count == 0 {
ctx.Ui.Message("No outdated or unused layers were found!")
} else {
ctx.Ui.Message(fmt.Sprintf(
"[green]Pruned %d outdated or unused layers!", count))
}
return nil
}
// We're just listing the layers. Eventually we probably should
// output status or something more useful here.
for _, l := range opts.Layer.Layers {
ctx.Ui.Raw(l.ID + "\n")
}
return nil
}
func (i *Infrastructure) actionApply(rctx router.Context) error {
rctx.UI().Header("Building main infrastructure...")
ctx := rctx.(*infrastructure.Context)
return i.execute(ctx, "apply")
}
func (i *Infrastructure) actionDestroy(rctx router.Context) error {
rctx.UI().Header("Destroying main infrastructure...")
ctx := rctx.(*infrastructure.Context)
return i.execute(ctx, "destroy", "-force")
}