2022-01-19 09:32:27 +02:00
|
|
|
package git_commands
|
|
|
|
|
|
|
|
import (
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"strings"
|
|
|
|
)
|
|
|
|
|
|
|
|
type BisectCommands struct {
|
|
|
|
*GitCommon
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewBisectCommands(gitCommon *GitCommon) *BisectCommands {
|
|
|
|
return &BisectCommands{
|
|
|
|
GitCommon: gitCommon,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// This command is pretty cheap to run so we're not storing the result anywhere.
|
|
|
|
// But if it becomes problematic we can chang that.
|
|
|
|
func (self *BisectCommands) GetInfo() *BisectInfo {
|
2023-07-28 10:27:14 +02:00
|
|
|
return self.GetInfoForGitDir(self.repoPaths.WorktreeGitDirPath())
|
2023-07-24 08:36:11 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (self *BisectCommands) GetInfoForGitDir(gitDir string) *BisectInfo {
|
2022-01-19 09:32:27 +02:00
|
|
|
var err error
|
|
|
|
info := &BisectInfo{started: false, log: self.Log, newTerm: "bad", oldTerm: "good"}
|
|
|
|
// we return nil if we're not in a git bisect session.
|
|
|
|
// we know we're in a session by the presence of a .git/BISECT_START file
|
|
|
|
|
2023-07-24 08:36:11 +02:00
|
|
|
bisectStartPath := filepath.Join(gitDir, "BISECT_START")
|
2022-01-19 09:32:27 +02:00
|
|
|
exists, err := self.os.FileExists(bisectStartPath)
|
|
|
|
if err != nil {
|
|
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
|
|
return info
|
|
|
|
}
|
|
|
|
|
|
|
|
if !exists {
|
|
|
|
return info
|
|
|
|
}
|
|
|
|
|
|
|
|
startContent, err := os.ReadFile(bisectStartPath)
|
|
|
|
if err != nil {
|
|
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
|
|
return info
|
|
|
|
}
|
|
|
|
|
|
|
|
info.started = true
|
|
|
|
info.start = strings.TrimSpace(string(startContent))
|
|
|
|
|
2023-07-24 08:36:11 +02:00
|
|
|
termsContent, err := os.ReadFile(filepath.Join(gitDir, "BISECT_TERMS"))
|
2022-01-19 09:32:27 +02:00
|
|
|
if err != nil {
|
|
|
|
// old git versions won't have this file so we default to bad/good
|
|
|
|
} else {
|
|
|
|
splitContent := strings.Split(string(termsContent), "\n")
|
|
|
|
info.newTerm = splitContent[0]
|
|
|
|
info.oldTerm = splitContent[1]
|
|
|
|
}
|
|
|
|
|
2023-07-24 08:36:11 +02:00
|
|
|
bisectRefsDir := filepath.Join(gitDir, "refs", "bisect")
|
2022-01-19 09:32:27 +02:00
|
|
|
files, err := os.ReadDir(bisectRefsDir)
|
|
|
|
if err != nil {
|
|
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
|
|
return info
|
|
|
|
}
|
|
|
|
|
|
|
|
info.statusMap = make(map[string]BisectStatus)
|
|
|
|
for _, file := range files {
|
|
|
|
status := BisectStatusSkipped
|
|
|
|
name := file.Name()
|
|
|
|
path := filepath.Join(bisectRefsDir, name)
|
|
|
|
|
|
|
|
fileContent, err := os.ReadFile(path)
|
|
|
|
if err != nil {
|
|
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
|
|
return info
|
|
|
|
}
|
|
|
|
|
|
|
|
sha := strings.TrimSpace(string(fileContent))
|
|
|
|
|
|
|
|
if name == info.newTerm {
|
|
|
|
status = BisectStatusNew
|
|
|
|
} else if strings.HasPrefix(name, info.oldTerm+"-") {
|
|
|
|
status = BisectStatusOld
|
|
|
|
} else if strings.HasPrefix(name, "skipped-") {
|
|
|
|
status = BisectStatusSkipped
|
|
|
|
}
|
|
|
|
|
|
|
|
info.statusMap[sha] = status
|
|
|
|
}
|
|
|
|
|
2023-07-24 08:36:11 +02:00
|
|
|
currentContent, err := os.ReadFile(filepath.Join(gitDir, "BISECT_EXPECTED_REV"))
|
2022-01-19 09:32:27 +02:00
|
|
|
if err != nil {
|
|
|
|
self.Log.Infof("error getting git bisect info: %s", err.Error())
|
|
|
|
return info
|
|
|
|
}
|
|
|
|
currentSha := strings.TrimSpace(string(currentContent))
|
|
|
|
info.current = currentSha
|
|
|
|
|
|
|
|
return info
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *BisectCommands) Reset() error {
|
2023-05-21 09:00:29 +02:00
|
|
|
cmdArgs := NewGitCmd("bisect").Arg("reset").ToArgv()
|
2023-05-19 12:18:02 +02:00
|
|
|
|
2023-05-21 09:00:29 +02:00
|
|
|
return self.cmd.New(cmdArgs).StreamOutput().Run()
|
2022-01-19 09:32:27 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (self *BisectCommands) Mark(ref string, term string) error {
|
2023-05-21 09:00:29 +02:00
|
|
|
cmdArgs := NewGitCmd("bisect").Arg(term, ref).ToArgv()
|
2023-05-19 12:18:02 +02:00
|
|
|
|
2023-05-21 09:00:29 +02:00
|
|
|
return self.cmd.New(cmdArgs).
|
2022-01-19 09:32:27 +02:00
|
|
|
IgnoreEmptyError().
|
|
|
|
StreamOutput().
|
|
|
|
Run()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *BisectCommands) Skip(ref string) error {
|
|
|
|
return self.Mark(ref, "skip")
|
|
|
|
}
|
|
|
|
|
|
|
|
func (self *BisectCommands) Start() error {
|
2023-05-21 09:00:29 +02:00
|
|
|
cmdArgs := NewGitCmd("bisect").Arg("start").ToArgv()
|
2023-05-19 12:18:02 +02:00
|
|
|
|
2023-05-21 09:00:29 +02:00
|
|
|
return self.cmd.New(cmdArgs).StreamOutput().Run()
|
2022-01-19 09:32:27 +02:00
|
|
|
}
|
|
|
|
|
2023-07-27 14:15:56 +02:00
|
|
|
func (self *BisectCommands) StartWithTerms(oldTerm string, newTerm string) error {
|
|
|
|
cmdArgs := NewGitCmd("bisect").Arg("start").
|
|
|
|
Arg("--term-old=" + oldTerm).
|
|
|
|
Arg("--term-new=" + newTerm).
|
|
|
|
ToArgv()
|
|
|
|
|
|
|
|
return self.cmd.New(cmdArgs).StreamOutput().Run()
|
|
|
|
}
|
|
|
|
|
2022-01-19 09:32:27 +02:00
|
|
|
// tells us whether we've found our problem commit(s). We return a string slice of
|
|
|
|
// commit sha's if we're done, and that slice may have more that one item if
|
|
|
|
// skipped commits are involved.
|
|
|
|
func (self *BisectCommands) IsDone() (bool, []string, error) {
|
|
|
|
info := self.GetInfo()
|
|
|
|
if !info.Bisecting() {
|
|
|
|
return false, nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
newSha := info.GetNewSha()
|
|
|
|
if newSha == "" {
|
|
|
|
return false, nil, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// if we start from the new commit and reach the a good commit without
|
|
|
|
// coming across any unprocessed commits, then we're done
|
|
|
|
done := false
|
|
|
|
candidates := []string{}
|
|
|
|
|
2023-05-21 09:00:29 +02:00
|
|
|
cmdArgs := NewGitCmd("rev-list").Arg(newSha).ToArgv()
|
|
|
|
err := self.cmd.New(cmdArgs).RunAndProcessLines(func(line string) (bool, error) {
|
2022-01-19 09:32:27 +02:00
|
|
|
sha := strings.TrimSpace(line)
|
|
|
|
|
|
|
|
if status, ok := info.statusMap[sha]; ok {
|
|
|
|
switch status {
|
|
|
|
case BisectStatusSkipped, BisectStatusNew:
|
|
|
|
candidates = append(candidates, sha)
|
|
|
|
return false, nil
|
|
|
|
case BisectStatusOld:
|
|
|
|
done = true
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return true, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// should never land here
|
|
|
|
return true, nil
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return false, nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
return done, candidates, nil
|
|
|
|
}
|
2022-01-26 06:17:11 +02:00
|
|
|
|
2022-01-26 10:12:44 +02:00
|
|
|
// tells us whether the 'start' ref that we'll be sent back to after we're done
|
|
|
|
// bisecting is actually a descendant of our current bisect commit. If it's not, we need to
|
|
|
|
// render the commits from the bad commit.
|
|
|
|
func (self *BisectCommands) ReachableFromStart(bisectInfo *BisectInfo) bool {
|
2023-05-21 09:00:29 +02:00
|
|
|
cmdArgs := NewGitCmd("merge-base").
|
2023-05-19 12:18:02 +02:00
|
|
|
Arg("--is-ancestor", bisectInfo.GetNewSha(), bisectInfo.GetStartSha()).
|
2023-05-21 09:00:29 +02:00
|
|
|
ToArgv()
|
2023-05-19 12:18:02 +02:00
|
|
|
|
2023-05-21 09:00:29 +02:00
|
|
|
err := self.cmd.New(cmdArgs).DontLog().Run()
|
2022-01-26 06:17:11 +02:00
|
|
|
|
|
|
|
return err == nil
|
|
|
|
}
|