func (f *Foundation) Infra(ctx *foundation.Context) error {
if ctx.Action == "" {
appInfra := ctx.Appfile.ActiveInfrastructure()
lookup := directory.Lookup{Infra: appInfra.Type}
infra, err := ctx.Directory.GetInfra(&directory.Infra{Lookup: lookup})
os.Setenv("DEISCTL_TUNNEL", infra.Outputs["ip"])
fmt.Println("DEISCTL_TUNNEL is " + os.Getenv("DEISCTL_TUNNEL"))
cmd := exec.Command("deisctl", "config", "platform", "set", "version=v1.11.1")
cmd.Env = os.Environ()
err = ottoExec.Run(ctx.Ui, cmd)
cmd = exec.Command("deisctl", "config", "platform", "set", "sshPrivateKey=~/.ssh/deis-test")
cmd.Env = os.Environ()
err = ottoExec.Run(ctx.Ui, cmd)
cmd = exec.Command("deisctl", "config", "platform", "set", "domain=goings.space")
cmd.Env = os.Environ()
err = ottoExec.Run(ctx.Ui, cmd)
cmd = exec.Command("deisctl", "install", "platform")
cmd.Env = os.Environ()
err = ottoExec.Run(ctx.Ui, cmd)
cmd = exec.Command("deisctl", "start", "platform")
cmd.Env = os.Environ()
err = ottoExec.Run(ctx.Ui, cmd)
return err
}
return nil
}
func (a *App) actionRebuild(rctx router.Context) error {
ctx := rctx.(*app.Context)
cwd := filepath.Dir(ctx.Appfile.Path)
// Get the path to the rebuild binary
path := filepath.Join(ctx.Dir, "rebuild", "rebuild.go")
// Run it to regenerate the contents
ctx.Ui.Header("Rebuilding ScriptPack data...")
cmd := exec.Command("go", "generate")
cmd.Dir = cwd
if err := execHelper.Run(ctx.Ui, cmd); err != nil {
return err
}
cmd = exec.Command("go", "run", path)
cmd.Dir = cwd
if err := execHelper.Run(ctx.Ui, cmd); err != nil {
return err
}
// Success
ctx.Ui.Message("ScriptPack data rebuilt!")
return nil
}
// Execute executes a raw Vagrant command.
func (v *Vagrant) Execute(commandRaw ...string) error {
vagrantMutex.Lock()
defer vagrantMutex.Unlock()
if v.Env == nil {
v.Env = make(map[string]string)
}
// Where to store data
v.Env[vagrantDataDirEnvVar] = v.DataDir
// Make sure we use our cwd properly
v.Env[vagrantCwdEnvVar] = v.Dir
// Build up the environment
env := os.Environ()
for k, v := range v.Env {
env = append(env, fmt.Sprintf("%s=%s", k, v))
}
// Build the args
command := make([]string, len(commandRaw)+1)
command[0] = "--machine-readable"
copy(command[1:], commandRaw)
// Build the command to execute
cmd := exec.Command("vagrant", command...)
cmd.Dir = v.Dir
cmd.Env = env
// Build our custom UI that we'll use that'll call the registered
// callbacks as well as streaming data to the UI.
callbacks := make(map[string]OutputCallback)
callbacks["invalid"] = v.uiCallback
callbacks["ui"] = v.uiCallback
for n, cb := range v.Callbacks {
callbacks[n] = cb
}
ui := &vagrantUi{Callbacks: callbacks}
// Run it with the execHelper
err := execHelper.Run(ui, cmd)
ui.Finish()
if err != nil {
return fmt.Errorf(
"Error executing Vagrant: %s\n\n"+
"The error messages from Vagrant are usually very informative.\n"+
"Please read it carefully and fix any issues it mentions. If\n"+
"the message isn't clear, please report this to the Otto project.",
err)
}
return nil
}
// Execute executes a raw Packer command.
func (p *Packer) Execute(commandRaw ...string) error {
varfile, err := p.varfile()
if err != nil {
return err
}
if execHelper.ShouldCleanup() {
defer os.Remove(varfile)
}
// The command must always be machine-readable. We use this
// exclusively to mirror the UI output.
command := make([]string, len(commandRaw)+3)
command[0] = commandRaw[0]
command[1] = "-machine-readable"
command[2] = "-var-file"
command[3] = varfile
copy(command[4:], commandRaw[1:])
// Build the command to execute
path := "packer"
if p.Path != "" {
path = p.Path
}
cmd := exec.Command(path, command...)
cmd.Dir = p.Dir
// Build our custom UI that we'll use that'll call the registered
// callbacks as well as streaming data to the UI.
callbacks := make(map[string]OutputCallback)
callbacks["ui"] = p.uiCallback
for n, cb := range p.Callbacks {
callbacks[n] = cb
}
ui := &packerUi{Callbacks: callbacks}
// Execute!
err = execHelper.Run(ui, cmd)
ui.Finish()
if err != nil {
return fmt.Errorf(
"Error executing Packer: %s\n\n"+
"The error messages from Packer are usually very informative.\n"+
"Please read it carefully and fix any issues it mentions. If\n"+
"the message isn't clear, please report this to the Otto project.",
err)
}
return nil
}
// Execute executes a raw Vagrant command.
func (v *Vagrant) Execute(command ...string) error {
vagrantMutex.Lock()
defer vagrantMutex.Unlock()
if v.Env == nil {
v.Env = make(map[string]string)
}
// Where to store data
v.Env[vagrantDataDirEnvVar] = v.DataDir
// Make sure we use our cwd properly
v.Env[vagrantCwdEnvVar] = v.Dir
// Build up the environment
env := os.Environ()
for k, v := range v.Env {
env = append(env, fmt.Sprintf("%s=%s", k, v))
}
// Build the command to execute
cmd := exec.Command("vagrant", command...)
cmd.Dir = v.Dir
cmd.Env = env
// Run it with the execHelper
if err := execHelper.Run(v.Ui, cmd); err != nil {
return fmt.Errorf(
"Error executing Vagrant: %s\n\n"+
"The error messages from Vagrant are usually very informative.\n"+
"Please read it carefully and fix any issues it mentions. If\n"+
"the message isn't clear, please report this to the Otto project.",
err)
}
return nil
}
// Add takes the path of a private key and runs ssh-add locally to add it to
// the agent. It needs a Ui to be able to interact with the user for the
// password prompt.
func Add(ui ui.Ui, privateKeyPath string) error {
cmd := exec.Command("ssh-add", privateKeyPath)
return execHelper.Run(ui, cmd)
}
// Execute executes a raw Terraform command
func (t *Terraform) Execute(commandRaw ...string) error {
command := make([]string, 1, len(commandRaw)*2)
command[0] = commandRaw[0]
commandArgs := commandRaw[1:]
// Determine if we need to skip var flags or not.
varSkip := false
varSkip = command[0] == "get"
// If we have variables, create the var file
if !varSkip && len(t.Variables) > 0 {
varfile, err := t.varfile()
if err != nil {
return err
}
if execHelper.ShouldCleanup() {
defer os.Remove(varfile)
}
// Append the varfile onto our command.
command = append(command, "-var-file", varfile)
// Log some of the vars we're using
for k, _ := range t.Variables {
log.Printf("[DEBUG] setting TF var: %s", k)
}
}
// Determine if we need to skip state flags or not. This is just
// hardcoded for now.
stateSkip := false
stateSkip = command[0] == "get"
// Output needs state but not state-out; more hard-coding
stateOutSkip := false
stateOutSkip = command[0] == "output"
// If we care about state, then setup the state directory and
// load it up.
var stateDir, statePath string
if !stateSkip && t.StateId != "" && t.Directory != nil {
var err error
stateDir, err = ioutil.TempDir("", "otto-tf")
if err != nil {
return err
}
if execHelper.ShouldCleanup() {
defer os.RemoveAll(stateDir)
}
// State path
stateOldPath := filepath.Join(stateDir, "state.old")
statePath = filepath.Join(stateDir, "state")
// Load the state from the directory
data, err := t.Directory.GetBlob(t.StateId)
if err != nil {
return fmt.Errorf("Error loading Terraform state: %s", err)
}
if data == nil && command[0] == "destroy" {
// Destroy we can just execute, we don't need state
return nil
}
if data != nil {
err = data.WriteToFile(stateOldPath)
data.Close()
}
if err != nil {
return fmt.Errorf("Error writing Terraform state: %s", err)
}
// Append the state to the args
command = append(command, "-state", stateOldPath)
if !stateOutSkip {
command = append(command, "-state-out", statePath)
}
}
// Append all the final args
command = append(command, commandArgs...)
// Build the command to execute
log.Printf("[DEBUG] executing terraform: %v", command)
path := "terraform"
if t.Path != "" {
path = t.Path
}
cmd := exec.Command(path, command...)
cmd.Dir = t.Dir
// Start the Terraform command. If there is an error we just store
// the error but can't exit yet because we have to store partial
// state if there is any.
err := execHelper.Run(t.Ui, cmd)
if err != nil {
err = fmt.Errorf("Error running Terraform: %s", err)
}
// Save the state file if we have it.
if t.StateId != "" && t.Directory != nil && statePath != "" && !stateOutSkip {
f, ferr := os.Open(statePath)
if ferr != nil {
return fmt.Errorf(
"Error reading Terraform state for saving: %s", ferr)
}
// Store the state
derr := t.Directory.PutBlob(t.StateId, &directory.BlobData{
Data: f,
})
// Always close the file
f.Close()
// If we couldn't save the data, then note the error. This is a
// _really_ bad error to get since there isn't a good way to
// recover. For now, we just copy the state to the pwd and note
// the user.
if derr != nil {
// TODO: copy state
err = fmt.Errorf(
"Failed to save Terraform state: %s\n\n"+
"This means that Otto was unable to store the state of your infrastructure.\n"+
"At this time, Otto doesn't support gracefully recovering from this\n"+
"scenario. The state should be in the path below. Please ask the\n"+
"community for assistance.",
derr)
}
}
return err
}
