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: "******",
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: "******",
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: "******",
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
}
