func (runner *Runner) runTasks(configs *[]backuper.TaskConfig) (results []backuper.PathResult) { results = make([]backuper.PathResult, 0, len(*configs)) for _, config := range *configs { beginTime := time.Now() task, err := GetTask(&config) if err == nil { taskTmpFileName := task.TmpFileName() tmpFilePath := runner.tmpFilePath(taskTmpFileName) out, err := task.GenerateTmpFile(tmpFilePath) results = append(results, backuper.NewPathResult( err, taskTmpFileName, string(out), beginTime, time.Now(), )) } else { log.Printf("task type: %s, no registered handler found", config.Type) } } return }
func (runner *Runner) Run() (err error, backupResult *backuper.BackupResult) { configs := &runner.agentConfig.Tasks backupResult = &backuper.BackupResult{ BeginTime: time.Now(), Size: -1, Status: backuper.BackupErrorCrytical, } beginTime := time.Now() err = runner.prepareTmpDir() tmpDirPath := runner.tmpDirPath() backupResult.Prepare = backuper.NewPathResult( err, tmpDirPath, "", beginTime, time.Now(), ) if err != nil { log.Println("ERR: prepare:", err.Error()) return } defer func() { beginTime = time.Now() err = runner.CleanupTmpDir() backupResult.Cleanup = backuper.NewPathResult( err, tmpDirPath, "", beginTime, time.Now(), ) cryticalErrors := []*backuper.PathResult{ &backupResult.Prepare, &backupResult.Lock, &backupResult.Encrypt, // &backupResult.Upload, } backupResult.Status = backuper.BackupErrorNo hasCryticalError := false for _, br := range cryticalErrors { if !ResultSuccess(br) { hasCryticalError = true backupResult.Status = backuper.BackupErrorCrytical break } } if !hasCryticalError { numTaskErrors := 0 for _, br := range backupResult.Backup { if !ResultSuccess(&br) { numTaskErrors++ backupResult.Status = backuper.BackupErrorTask } } if numTaskErrors == len(backupResult.Backup) { backupResult.Status = backuper.BackupErrorTaskAll } else { if !ResultSuccess(&backupResult.Unlock) || !ResultSuccess(&backupResult.Cleanup) { backupResult.Status = backuper.BackupErrorCleanup } } } backupResult.EndTime = time.Now() }() beginTime = time.Now() pidFilePath := runner.pidFilePath() err = runner.lockPidFile(pidFilePath) backupResult.Lock = backuper.NewPathResult( err, pidFilePath, "", beginTime, time.Now(), ) if err != nil { log.Println("ERR: lock:", err.Error()) return } backupResult.Backup = runner.runTasks(configs) tmpFiles := make([]string, 0, len(*configs)) for _, result := range backupResult.Backup { if ResultSuccess(&result) { tmpFiles = append(tmpFiles, result.Path) } } beginTime = time.Now() backupFilePath := runner.backupFilePath() output, err := runner.encryptTmpFiles(backupFilePath, tmpFiles) backupResult.Encrypt = backuper.NewPathResult( err, backupFilePath, string(output), beginTime, time.Now(), ) if err != nil { log.Println("ERR: encrypt:", err.Error()) return } fi, err := os.Stat(backupFilePath) if err == nil { backupResult.Size = fi.Size() } // dstPath := runner.formatDstPath("backup/%hostname%/%timestamp%") dstPath := hmutil.FormatDstPath(filepath.Join("backup", "%hostname%", "%timestamp%"), runner.timestamp) uploadResults, err := runner.uploadBackupFile( backupFilePath, runner.agentConfig.UploadMethod, dstPath, ) // backupResult.Upload = backuper.NewPathResult( // err, // backupFilePath, // string(output), // beginTime, // time.Now(), // ) backupResult.Upload = uploadResults // backuper.UploadResult{ // Err: err.Error(), // next line fixes this // // Err: "", // Path: backupFilePath + ".tar.gz.encrypted", // Type: "S3", // Destination: "headmade", // BeginTime: beginTime, // EndTime: time.Now(), // } if err != nil { log.Println("ERR: upload:", err.Error()) return } beginTime = time.Now() // TODO: remember to uncomment the unlock()! //err = runner.unlockPidFile() backupResult.Unlock = backuper.NewPathResult( err, pidFilePath, "", beginTime, time.Now(), ) return }