func (hl *Launchable) InvokeBinScript(script string) (string, error) {
	cmdPath := filepath.Join(hl.InstallDir(), "bin", script)
	_, err := os.Stat(cmdPath)
	if err != nil {
		return "", err
	}

	cgroupName := hl.CgroupName
	if hl.CgroupConfigName == "" {
		cgroupName = ""
	}
	p2ExecArgs := p2exec.P2ExecArgs{
		Command:          []string{cmdPath},
		User:             hl.RunAs,
		EnvDirs:          []string{hl.PodEnvDir, hl.EnvDir()},
		NoLimits:         hl.ExecNoLimit,
		CgroupConfigName: hl.CgroupConfigName,
		CgroupName:       cgroupName,
	}
	cmd := exec.Command(hl.P2Exec, p2ExecArgs.CommandLine()...)
	buffer := bytes.Buffer{}
	cmd.Stdout = &buffer
	cmd.Stderr = &buffer
	err = cmd.Run()
	if err != nil {
		return buffer.String(), err
	}

	return buffer.String(), nil
}

func (pod *Pod) SetLogBridgeExec(logExec []string) {
	p2ExecArgs := p2exec.P2ExecArgs{
		Command: logExec,
		User:    "nobody",
		EnvDirs: []string{pod.EnvDir()},
	}

	pod.LogExec = append([]string{pod.P2Exec}, p2ExecArgs.CommandLine()...)
}

func (pod *Pod) FinishExecForLaunchable(launchable launch.Launchable) runit.Exec {
	p2ExecArgs := p2exec.P2ExecArgs{
		Command: pod.FinishExec,
		User:    "nobody",
		EnvDirs: []string{pod.EnvDir(), launchable.EnvDir()},
	}

	return append([]string{pod.P2Exec}, p2ExecArgs.CommandLine()...)
}

func (pod *Pod) FinishExecForExecutable(launchable launch.Launchable, executable launch.Executable) runit.Exec {
	p2ExecArgs := p2exec.P2ExecArgs{
		Command:  pod.FinishExec,
		User:     "nobody",
		EnvDirs:  []string{pod.EnvDir(), launchable.EnvDir()},
		ExtraEnv: map[string]string{launch.EntryPointEnvVar: executable.ServiceName},
	}

	return append([]string{pod.P2Exec}, p2ExecArgs.CommandLine()...)
}

func (hl *Launchable) Executables(
	serviceBuilder *runit.ServiceBuilder,
) ([]launch.Executable, error) {
	if !hl.Installed() {
		return []launch.Executable{}, util.Errorf("%s is not installed", hl.Id)
	}

	binLaunchPath := filepath.Join(hl.InstallDir(), "bin", "launch")

	binLaunchInfo, err := os.Stat(binLaunchPath)
	if os.IsNotExist(err) {
		return []launch.Executable{}, nil
	} else if err != nil {
		return nil, util.Errorf("%s", err)
	}

	// we support bin/launch being a file, or a directory, so we check here.
	services := []os.FileInfo{binLaunchInfo}
	serviceDir := filepath.Dir(binLaunchPath)
	if binLaunchInfo.IsDir() {
		serviceDir = binLaunchPath
		services, err = ioutil.ReadDir(binLaunchPath)
		if err != nil {
			return nil, err
		}
	}

	var executables []launch.Executable
	for _, service := range services {
		serviceName := fmt.Sprintf("%s__%s", hl.Id, service.Name())
		p2ExecArgs := p2exec.P2ExecArgs{
			Command:          []string{filepath.Join(serviceDir, service.Name())},
			User:             hl.RunAs,
			EnvDir:           hl.PodEnvDir,
			NoLimits:         hl.ExecNoLimit,
			CgroupConfigName: hl.CgroupConfigName,
			CgroupName:       hl.Id,
		}
		execCmd := append([]string{hl.P2Exec}, p2ExecArgs.CommandLine()...)

		executables = append(executables, launch.Executable{
			Service: runit.Service{
				Path: filepath.Join(serviceBuilder.RunitRoot, serviceName),
				Name: serviceName,
			},
			Exec: execCmd,
		})
	}
	return executables, nil
}

func (hl *Launchable) Executables(
	serviceBuilder *runit.ServiceBuilder,
) ([]launch.Executable, error) {
	if !hl.Installed() {
		return []launch.Executable{}, util.Errorf("%s is not installed", hl.ServiceId)
	}

	// Maps service name to a launch.Executable to guarantee that no two services can share
	// a name.
	executableMap := make(map[string]launch.Executable)

	for _, relativeEntryPoint := range hl.EntryPoints {
		absEntryPointPath := filepath.Join(hl.InstallDir(), relativeEntryPoint)

		entryPointInfo, err := os.Stat(absEntryPointPath)
		if os.IsNotExist(err) {
			return []launch.Executable{}, nil
		} else if err != nil {
			return nil, util.Errorf("%s", err)
		}

		// an entry point can be a file or a directory. If it's a file, simply
		// add it to our services map. Otherwise, add each file under it.
		var serviceDir string
		var services []os.FileInfo
		if entryPointInfo.IsDir() {
			serviceDir = absEntryPointPath
			services, err = ioutil.ReadDir(absEntryPointPath)
			if err != nil {
				return nil, err
			}
		} else {
			serviceDir = filepath.Dir(absEntryPointPath)
			services = append(services, entryPointInfo)
		}

		for _, service := range services {
			serviceName := fmt.Sprintf("%s__%s", hl.ServiceId, service.Name())

			// Make sure we don't have two services with the same name
			// (which is possible because) multiple entry points may be
			// specified

			if _, ok := executableMap[serviceName]; ok {
				return nil, util.Errorf("Multiple services found with name %s", serviceName)
			}

			p2ExecArgs := p2exec.P2ExecArgs{
				Command:          []string{filepath.Join(serviceDir, service.Name())},
				User:             hl.RunAs,
				EnvDirs:          []string{hl.PodEnvDir, hl.EnvDir()},
				NoLimits:         hl.ExecNoLimit,
				CgroupConfigName: hl.CgroupConfigName,
				CgroupName:       hl.CgroupName,
			}
			execCmd := append([]string{hl.P2Exec}, p2ExecArgs.CommandLine()...)

			executableMap[serviceName] = launch.Executable{
				Service: runit.Service{
					Path: filepath.Join(serviceBuilder.RunitRoot, serviceName),
					Name: serviceName,
				},
				LogAgent: runit.Service{
					Path: filepath.Join(serviceBuilder.RunitRoot, serviceName, "log"),
					Name: serviceName + " logAgent",
				},
				Exec: execCmd,
			}
		}
	}

	var executables []launch.Executable
	for _, executable := range executableMap {
		executables = append(executables, executable)
	}

	return executables, nil
}