func (a *App) Dev(ctx *app.Context) error {
	var layered *vagrant.Layered

	// We only setup a layered environment if we've recompiled since
	// version 0. If we're still at version 0 then we have to use the
	// non-layered dev environment.
	if ctx.CompileResult.Version > 0 {
		// Read the go version, since we use that for our layer
		version, err := oneline.Read(filepath.Join(ctx.Dir, "dev", "node_version"))
		if err != nil {
			return err
		}

		// Setup layers
		layered, err = vagrant.DevLayered(ctx, []*vagrant.Layer{
			&vagrant.Layer{
				ID:          fmt.Sprintf("node%s", version),
				Vagrantfile: filepath.Join(ctx.Dir, "dev", "layer-base", "Vagrantfile"),
			},
		})
		if err != nil {
			return err
		}
	}

	// Build the actual development environment
	return vagrant.Dev(&vagrant.DevOptions{
		Instructions: strings.TrimSpace(devInstructions),
		Layer:        layered,
	}).Route(ctx)
}

// LoadCompiled loads and verifies a compiled Appfile (*Compiled) from
// disk.
func LoadCompiled(dir string) (*Compiled, error) {
	// Check the version
	vsnStr, err := oneline.Read(filepath.Join(dir, CompileVersionFilename))
	if err != nil {
		return nil, err
	}
	vsn, err := strconv.ParseInt(vsnStr, 0, 0)
	if err != nil {
		return nil, err
	}

	// If the version is too new, then we can't handle it
	if vsn > CompileVersion {
		return nil, fmt.Errorf(
			"The Appfile for this enviroment was compiled with a newer version\n" +
				"of Otto. Otto can't load this environment. You can recompile this\n" +
				"environment to this version of Otto with `otto compile`.")
	}

	f, err := os.Open(filepath.Join(dir, CompileFilename))
	if err != nil {
		return nil, err
	}
	defer f.Close()

	var c Compiled
	dec := json.NewDecoder(f)
	if err := dec.Decode(&c); err != nil {
		return nil, err
	}

	return &c, nil
}

func (a *App) Build(ctx *app.Context) error {
	// Determine if we set a Packer path.
	path := filepath.Join(ctx.Dir, "build", "packer_path")
	if _, err := os.Stat(path); err != nil {
		if os.IsNotExist(err) {
			return errors.New(strings.TrimSpace(errPackerNotSet))
		}

		return err
	}

	// Read the actual Packer dir
	packerPath, err := oneline.Read(path)
	if err != nil {
		return fmt.Errorf(
			"Error reading the Packer template path: %s\n\n"+
				"An Otto recompile with `otto compile` usually fixes this.",
			err)
	}

	return packer.Build(ctx, &packer.BuildOptions{
		Dir:          filepath.Dir(packerPath),
		TemplatePath: packerPath,
	})
}

func (a *App) Deploy(ctx *app.Context) error {
	// Determine if we set a Terraform path. If we didn't, then
	// tell the user we can't deploy.
	path := filepath.Join(ctx.Dir, "deploy", "terraform_path")
	if _, err := os.Stat(path); err != nil {
		if os.IsNotExist(err) {
			return errors.New(strings.TrimSpace(errTerraformNotSet))
		}

		return err
	}

	// Read the actual TF dir
	tfdir, err := oneline.Read(path)
	if err != nil {
		return fmt.Errorf(
			"Error reading the Terraform module directory: %s\n\n"+
				"An Otto recompile with `otto compile` usually fixes this.",
			err)
	}

	// Determine if we set a Packer path. If we didn't, we disable
	// the build loading for deploys.
	disableBuild := true
	path = filepath.Join(ctx.Dir, "build", "packer_path")
	if _, err := os.Stat(path); err == nil {
		disableBuild = false
	}

	// But if we did, then deploy using Terraform
	return terraform.Deploy(&terraform.DeployOptions{
		Dir:          tfdir,
		DisableBuild: disableBuild,
	}).Route(ctx)
}

// appFoundations compiles the app-specific foundation files.
func appFoundations(opts *AppOptions) error {
	// Setup the bindata for rendering
	dataCopy := Data
	data := &dataCopy
	data.Context = make(map[string]interface{})
	for k, v := range opts.Bindata.Context {
		data.Context[k] = v
	}

	// Go through each foundation and setup the layers
	log.Printf("[INFO] compile: looking for foundation layers for dev")
	for i, dir := range opts.Ctx.FoundationDirs {
		devDir := filepath.Join(dir, "app-dev")
		log.Printf("[DEBUG] compile: checking foundation dir: %s", devDir)

		_, err := os.Stat(filepath.Join(devDir, "layer.sh"))
		if err != nil {
			// If the file doesn't exist then this foundation just
			// doesn't have a layer. Not a big deal.
			if os.IsNotExist(err) {
				log.Printf("[DEBUG] compile: dir %s has no layers", devDir)
				continue
			}

			// The error is something else, return it...
			return err
		}

		log.Printf("[DEBUG] compile: dir %s has a layer!", devDir)

		// We have a layer! Read the ID.
		id, err := oneline.Read(filepath.Join(devDir, "layer.id"))
		if err != nil {
			return err
		}

		// Setup the data for this render
		data.Context["foundation_id"] = id
		data.Context["foundation_dir"] = devDir

		// Create the directory where this will be stored
		renderDir := filepath.Join(
			opts.Ctx.Dir, "foundation-layers", fmt.Sprintf("%d-%s", i, id))
		if err := os.MkdirAll(renderDir, 0755); err != nil {
			return err
		}

		// Render our standard template for a foundation layer
		err = data.RenderAsset(
			filepath.Join(renderDir, "Vagrantfile"),
			"data/internal/foundation-layer.Vagrantfile.tpl")
		if err != nil {
			return err
		}
	}

	return nil
}

// loadID loads the ID for this File.
func (appF *File) loadID() error {
	hasID, err := appF.hasID()
	if err != nil {
		return err
	}
	if !hasID {
		appF.ID = ""
		return nil
	}

	path := filepath.Join(filepath.Dir(appF.Path), IDFile)
	uuid, err := oneline.Read(path)
	if err != nil {
		return err
	}

	appF.ID = uuid
	return nil
}

func detectRubyVersionFile(dir string) (result string, err error) {
	path := filepath.Join(dir, ".ruby-version")

	// Verify the .ruby-version exists
	if _, err = os.Stat(path); err != nil {
		if os.IsNotExist(err) {
			log.Printf("[DEBUG] ruby: .ruby-version not found, will not detect Ruby version this way")
			err = nil
		}

		return
	}

	log.Printf("[DEBUG] ruby: .ruby-version found! Attempting to detect Ruby version")

	// Read the first line of the file
	result, err = oneline.Read(path)
	log.Printf("[DEBUG] ruby: .ruby-version detected Ruby: %q", result)
	return
}

func (a *App) Dev(ctx *app.Context) error {
	// Determine if we have a Vagrant path set...
	instructions := devInstructionsCustom
	path := filepath.Join(ctx.Dir, "dev", "vagrant_path")
	if _, err := os.Stat(path); err != nil {
		if !os.IsNotExist(err) {
			return err
		}

		path = ""
	}
	if path != "" {
		var err error
		path, err = oneline.Read(path)
		if err != nil {
			return fmt.Errorf(
				"Error reading the Vagrant directory: %s\n\n"+
					"An Otto recompile with `otto compile` usually fixes this.",
				err)
		}
	}

	if path == "" {
		// Determine if we have our own Vagrantfile
		path = filepath.Join(ctx.Dir, "dev", "Vagrantfile")
		if _, err := os.Stat(path); err != nil {
			if os.IsNotExist(err) {
				return errors.New(strings.TrimSpace(errVagrantNotSet))
			}

			return err
		}

		instructions = devInstructionsDevDep
	}

	return vagrant.Dev(&vagrant.DevOptions{
		Dir:          filepath.Dir(path),
		Instructions: strings.TrimSpace(instructions),
	}).Route(ctx)
}

// IP retrieves the IP address.
//
// If it is cached, it will renew and use that address. If it isn't cached,
// then it will grab a new IP, cache that, and use that.
func (db *CachedDB) IP() (net.IP, error) {
	log.Printf("[DEBUG] reading IP, cache path: %s", db.CachePath)

	// Try to read the cached version
	_, err := os.Stat(db.CachePath)
	if err == nil {
		raw, err := oneline.Read(db.CachePath)
		if err != nil {
			return nil, err
		}

		ip := net.ParseIP(raw)
		if ip != nil {
			log.Printf("[DEBUG] read ip from cache: %s", ip)
			db.DB.Renew(ip)
			return ip, nil
		}
	}

	// Make sure the directory to our cache path exists
	if err := os.MkdirAll(filepath.Dir(db.CachePath), 0755); err != nil {
		return nil, err
	}

	// No cached version.
	log.Printf("[DEBUG] no ip cache found, getting new IP")
	ip, err := db.DB.Next()
	if err != nil {
		return nil, err
	}

	contents := fmt.Sprintf(strings.TrimSpace(cacheContents)+"\n", ip.String())
	err = ioutil.WriteFile(db.CachePath, []byte(contents), 0644)
	if err != nil {
		db.DB.Release(ip)
		return nil, err
	}

	log.Printf("[DEBUG] new IP cached: %s", ip)
	return ip, nil
}