b2a199100e
Adds a 'fade' param for dismissable alerts that if true will cause alerts to fade out and disappear after 5s. Setting it to false will keep alerts onscreen until they're manually dismissed by the user. Change-Id: If16b634c564e7ab906ecea33fd33128374570010
103 lines
2.6 KiB
Go
103 lines
2.6 KiB
Go
// +build !windows
|
|
|
|
/*
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
https://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package commands
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"sync"
|
|
"syscall"
|
|
|
|
"opendev.org/airship/airshipui/internal/webservice"
|
|
)
|
|
|
|
// ProcessGrpCmd wraps an exec.Cmd and a signal chan
|
|
type ProcessGrpCmd struct {
|
|
sigChan chan os.Signal
|
|
ctx context.Context
|
|
waitgrp *sync.WaitGroup
|
|
*exec.Cmd
|
|
}
|
|
|
|
// NewProcessGrpCmd creates a new ProcessGrpCmd to monitor a os.Signal chan
|
|
func NewProcessGrpCmd(c context.Context, wg *sync.WaitGroup, s chan os.Signal, cmd *exec.Cmd) *ProcessGrpCmd {
|
|
return &ProcessGrpCmd{
|
|
ctx: c,
|
|
waitgrp: wg,
|
|
sigChan: s,
|
|
Cmd: cmd,
|
|
}
|
|
}
|
|
|
|
// Run sets the process group id attribute to ensure all child
|
|
// processes started by the cmd will inherit it and will get killed
|
|
// with the parent
|
|
func (grp *ProcessGrpCmd) Run() error {
|
|
grp.Cmd.SysProcAttr = &syscall.SysProcAttr{Setpgid: true}
|
|
if err := grp.Cmd.Start(); err != nil {
|
|
grp.waitgrp.Done()
|
|
return err
|
|
}
|
|
|
|
go func() {
|
|
select {
|
|
case <-grp.sigChan:
|
|
grp.Terminate()
|
|
return
|
|
case <-grp.ctx.Done():
|
|
grp.Terminate()
|
|
return
|
|
}
|
|
}()
|
|
|
|
return grp.Cmd.Wait()
|
|
}
|
|
|
|
// RunBinaryWithOptions runs the binary
|
|
func RunBinaryWithOptions(ctx context.Context, cmd string, args []string, wg *sync.WaitGroup, s chan os.Signal) {
|
|
command := exec.CommandContext(ctx, cmd, args...)
|
|
|
|
// push executable's stdout / stderr
|
|
command.Stdout = os.Stdout
|
|
command.Stderr = os.Stderr
|
|
|
|
monitoredCmd := NewProcessGrpCmd(ctx, wg, s, command)
|
|
|
|
if err := monitoredCmd.Run(); err != nil {
|
|
log.Printf("'%s' exited with error: %v", cmd, err)
|
|
|
|
// send error to UI
|
|
webservice.SendAlert(
|
|
webservice.Error,
|
|
fmt.Sprintf("Plugin '%s' failed to start: %v", cmd, err),
|
|
true,
|
|
)
|
|
}
|
|
}
|
|
|
|
// Terminate kills the running process, logs a message, and sends Done() to the WaitGroup
|
|
func (grp *ProcessGrpCmd) Terminate() {
|
|
log.Printf("Terminating process '%s' with PID: %d", grp.Cmd.Path, grp.Cmd.Process.Pid)
|
|
if err := syscall.Kill(-grp.Cmd.Process.Pid, syscall.SIGKILL); err != nil {
|
|
log.Printf("Error terminating PID %d: %s", grp.Cmd.Process.Pid, err)
|
|
}
|
|
grp.waitgrp.Done()
|
|
}
|