149 lines
3.4 KiB
Go
149 lines
3.4 KiB
Go
package sync
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"syscall"
|
|
"time"
|
|
|
|
"git.csclub.uwaterloo.ca/public/merlin/config"
|
|
)
|
|
|
|
// SpawnProcess spawns a child process for the given repo. The process will
|
|
// be stopped early if the repo receives a stop signal, or if the process
|
|
// runs for longer than the repo's MaxTime.
|
|
// It returns a channel through which a Cmd will be sent once it has finished,
|
|
// or nil if it was unable to start a process.
|
|
func spawnProcess(repo *config.Repo, args []string) (ch <-chan *exec.Cmd) {
|
|
repo.Logger.Debug(fmt.Sprintf("Running the command: %v", args))
|
|
if repo.DryRun {
|
|
repo.Logger.Debug("Dry running for 50 seconds")
|
|
args = []string{"sleep", "50"}
|
|
}
|
|
cmd := exec.Command(args[0], args[1:]...)
|
|
repo.Logger.Debug("Starting process")
|
|
|
|
if err := cmd.Start(); err != nil {
|
|
repo.Logger.Error(fmt.Errorf("could not start process for %s: %w", repo.Name, err).Error())
|
|
return
|
|
}
|
|
|
|
cmdChan := make(chan *exec.Cmd)
|
|
ch = cmdChan
|
|
cmdDoneChan := make(chan struct{})
|
|
killProcess := func() {
|
|
err := cmd.Process.Signal(syscall.SIGTERM)
|
|
if err != nil {
|
|
repo.Logger.Error("Could not send signal to process:", err)
|
|
return
|
|
}
|
|
|
|
select {
|
|
case <-time.After(30 * time.Second):
|
|
repo.Logger.Warning("Process still hasn't stopped after 30 seconds; sending SIGKILL")
|
|
cmd.Process.Signal(syscall.SIGKILL)
|
|
|
|
case <-cmdDoneChan:
|
|
repo.Logger.Debug("Process has been stopped.")
|
|
}
|
|
}
|
|
|
|
go func() {
|
|
cmd.Wait()
|
|
close(cmdDoneChan)
|
|
}()
|
|
|
|
go func() {
|
|
defer func() {
|
|
cmdChan <- cmd
|
|
}()
|
|
select {
|
|
case <-cmdDoneChan:
|
|
if !cmd.ProcessState.Success() {
|
|
repo.Logger.Warning("Process ended with status code", cmd.ProcessState.ExitCode())
|
|
out, _ := cmd.CombinedOutput()
|
|
repo.Logger.Debug(string(out))
|
|
}
|
|
|
|
case <-repo.StopChan:
|
|
repo.Logger.Debug("Received signal to stop, killing process...")
|
|
killProcess()
|
|
|
|
case <-time.After(time.Duration(repo.MaxTime) * time.Second):
|
|
repo.Logger.Warning("Process has exceeded its max time; killing now")
|
|
killProcess()
|
|
}
|
|
}()
|
|
return
|
|
}
|
|
|
|
func startRepoSync(repo *config.Repo) {
|
|
status := config.FAILURE
|
|
defer func() {
|
|
repo.DoneChan <- config.SyncResult{
|
|
Name: repo.Name,
|
|
Exit: status,
|
|
}
|
|
}()
|
|
|
|
if repo.TraceUrl != "" {
|
|
repo.Logger.Debug("Checking for changes")
|
|
|
|
continueSync := true
|
|
status, continueSync = checkIfSyncNeeded(repo)
|
|
if !continueSync {
|
|
return
|
|
}
|
|
|
|
repo.Logger.Debug("Changes found; will attempt to sync")
|
|
}
|
|
|
|
args := getSyncCommand(repo)
|
|
if len(args) == 0 {
|
|
repo.Logger.Error("zero length command given for sync")
|
|
return
|
|
}
|
|
|
|
// clear the rsync log file before starting the sync
|
|
if repo.RsyncLogFile != "" {
|
|
err := os.Truncate(repo.RsyncLogFile, 0)
|
|
if err != nil {
|
|
repo.Logger.Error(err.Error())
|
|
}
|
|
}
|
|
|
|
ch := spawnProcess(repo, args)
|
|
if ch == nil {
|
|
// spawnSyncProcess will have already logged error
|
|
return
|
|
}
|
|
cmd := <-ch
|
|
|
|
switch cmd.ProcessState.ExitCode() {
|
|
case 0:
|
|
status = config.SUCCESS
|
|
case -1:
|
|
status = config.TERMINATED
|
|
// default is already FAILURE
|
|
}
|
|
}
|
|
|
|
func zfsSync(repo *config.Repo) {
|
|
// we are not using zfs snapshots at the moment
|
|
repo.Logger.Debug("Would run a zfssync if not disabled")
|
|
return
|
|
|
|
out, err := exec.Command("/bin/sh", "/home/mirror/bin/zfssync", repo.Name).CombinedOutput()
|
|
if err != nil {
|
|
repo.Logger.Error(err)
|
|
} else {
|
|
f, err := os.OpenFile(repo.ZfssyncLogFile, os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
|
|
if err != nil {
|
|
repo.Logger.Error(err.Error())
|
|
} else {
|
|
f.Write(out)
|
|
}
|
|
}
|
|
}
|