For a simple live coding environment I'm writing a git add, commit and push function, which is working fine, except of the case of conflicts, when two users code in the same part of a file. It performs the conflict analysis correctly and loads the result:
// Live-Editor, Processing / Javascript
fill(130, 52, 130);
<<<<<<< HEAD
textSize(130);
=======
textSize(120);
>>>>>>> master
text( "𝄠",160, 100);
showing the differences in git style. But when I then make the changes in the editor and add/commit/push again, then it results in the same conflict. It is like it doesn't "remember" that the conflict was already there and presents it again. (unlike git command line behaviour.)
Here is my code (I took the error handling out to make it shorter ...)
// Add
repo, err := git.OpenRepository(dir)
index, err := repo.Index()
err = index.AddAll([]string{}, git.IndexAddDefault, nil)
err = index.Write()
treeId, err := index.WriteTreeTo(repo)
tree, err := repo.LookupTree(treeId)
// Commit
sig := &git.Signature{
Name: userName,
Email: userName + "@" + beego.AppConfig.String("userdata::emailserver"),
When: time.Now(),
}
var currentCommit *git.Oid
if firstCommit == true {
_, err = repo.CreateCommit("HEAD", sig, sig, message, tree)
} else {
currentBranch, err := repo.Head()
currentTip, err := repo.LookupCommit(currentBranch.Target())
currentCommit, err = repo.CreateCommit("HEAD", sig, sig, message, tree, currentTip)
}
remote, err := repo.LookupRemote("origin")
// Pull
if firstCommit == false {
// Pull possible changes from remote repo
err = remote.Fetch([]string{}, nil, "")
remoteBranch, err := repo.LookupReference("refs/remotes/origin/master")
annotatedCommit, err := repo.AnnotatedCommitFromRef(remoteBranch)
// Do the merge analysis
mergeHeads := make([]*git.AnnotatedCommit, 1)
mergeHeads[0] = annotatedCommit
analysis, _, err := repo.MergeAnalysis(mergeHeads)
if analysis&git.MergeAnalysisUpToDate == 0 && analysis&git.MergeAnalysisNormal != 0 {
err := repo.Merge([]*git.AnnotatedCommit{annotatedCommit}, nil, nil)
// Check for conflicts
index, err := repo.Index()
if index.HasConflicts() {
err = index.Write()
return errors.New("Conflicts")
}
// No unsolvable conflicts, commit it
treeId, err := index.WriteTree()
tree, err := repo.LookupTree(treeId)
localCommit, err := repo.LookupCommit(currentCommit)
remoteCommit, err := repo.LookupCommit(remoteBranch.Target())
repo.CreateCommit("HEAD", sig, sig, "Merge commit", tree, localCommit, remoteCommit)
repo.StateCleanup()
}
}
// Push
err = remote.Push([]string{"refs/heads/master"}, nil, sig, message)
I guess the critical section is after // Check for conflicts Somehow that leaves the git directory in a state that let's it perform just the same analysis. I thought about not doing the analysis after the user made the changes and commits the project again, but it is possible that in the meantime another user has already changed something in the remote repo.
How is a good way to handle such conflicts with git2go?
I solved the problem. Collision detection worked fine. In case of a not automatically resolvable conflict, the control was given back to the user. He made changes, and those changes weren'T committed before the conflict analysis happened again.
Here is the complete code (the section after "Merge commit (in case of -- now hopefully resolved -- conflicts) is crucial."):
//////////////////////////////////////////////////////////
// GitAddCommitPush
func GitAddCommitPush(userName string, dir string, message string, firstCommit bool) error {
///////////////////////////////////////////////////////////////////////
// Add
//
// 1 Open repository
repo, err := git.OpenRepository(dir)
if err != nil {
beego.Error("OpenRepository - ", err)
}
// 2 Retrieve index
index, err := repo.Index()
if err != nil {
beego.Error("Index - ", err)
}
// 3 Remember if we had conflicts before we added everything to the index
indexHadConflicts := index.HasConflicts()
// 4 Add everything to the index
err = index.AddAll([]string{}, git.IndexAddDefault, nil)
if err != nil {
beego.Error("AddAll - ", err)
}
// 5 Write the index (so git knows about it)
err = index.Write()
if err != nil {
beego.Error("Write - ", err)
}
// 6 Write the current index tree to the repo
treeId, err := index.WriteTreeTo(repo)
if err != nil {
beego.Error("WriteTreeTo - ", err)
}
/////////////////////////////////////////////////////////////////////////////////////////////
// Commit
//
// 1 Retrieve the tree we just wrote (git's reference of it that it made in the last step)
tree, err := repo.LookupTree(treeId)
if err != nil {
beego.Error("LookupTree - ", err)
}
// 2 Create a signature
sig := &git.Signature{
Name: userName,
Email: userName + "@" + beego.AppConfig.String("userdata::emailserver"),
When: time.Now(),
}
// 3 Get remote now (as we need it for both, fetch and later push )
remote, err := repo.LookupRemote("origin")
if err != nil {
remote, err = repo.CreateRemote("origin", repo.Path())
if err != nil {
beego.Error("CreateRemote - ", err)
}
}
// 4 Read the remote branch
remoteBranch, err := repo.LookupReference("refs/remotes/origin/master")
if err != nil {
beego.Error("Fetch 2 - ", err)
}
// 5 Determine if this is a first commit ...
if firstCommit == true {
// 5a ... then create a new one
_, err = repo.CreateCommit("HEAD", sig, sig, message, tree)
} else {
// 5b ... or retrieve current head
currentBranch, err := repo.Head()
if err != nil {
beego.Error("Head - ", err)
}
// 6 Retrieve current commit
currentTip, err := repo.LookupCommit(currentBranch.Target())
if err != nil {
beego.Error("LookupCommit - ", err)
}
// 7 Create a new one on top
currentCommit, err := repo.CreateCommit("HEAD", sig, sig, message, tree, currentTip)
if err != nil {
beego.Error("CreateCommit - ", err)
}
////////////////////////////////////////////////////////////////////////////////////
// Merge commit (in case of -- now hopefully resolved -- conflicts)
//
// 1 If there were conflicts, do the merge commit
if indexHadConflicts == true {
// 2 Retrieve the local commit
localCommit, err := repo.LookupCommit(currentCommit)
if err != nil {
beego.Error("Fetch 11 - ", err)
}
// 3 Retrieve the remote commit
remoteCommit, err := repo.LookupCommit(remoteBranch.Target())
if err != nil {
beego.Error("Fetch 12 - ", err)
}
// 4 Create a new one
repo.CreateCommit("HEAD", sig, sig, "Merge commit", tree, localCommit, remoteCommit)
// 5 Clean up
repo.StateCleanup()
}
///////////////////////////////////////////////////////////////////////////////////
// Pull (Fetch and Commit)
//
// 1 Fetch it (pull without commit)
err = remote.Fetch([]string{}, nil, "")
if err != nil {
beego.Error("Fetch 1 - ", err)
}
// 2 Perform an annotated commit
annotatedCommit, err := repo.AnnotatedCommitFromRef(remoteBranch)
if err != nil {
beego.Error("Fetch 3 - ", err)
}
// 3 Do the merge analysis
mergeHeads := make([]*git.AnnotatedCommit, 1)
mergeHeads[0] = annotatedCommit
analysis, _, err := repo.MergeAnalysis(mergeHeads)
if err != nil {
beego.Error("Fetch 4 - ", err)
}
// 4 Check if something happend
if analysis&git.MergeAnalysisUpToDate == 0 && analysis&git.MergeAnalysisNormal != 0 {
// 5 Yes! First just merge changes
if err := repo.Merge([]*git.AnnotatedCommit{annotatedCommit}, nil, nil); err != nil {
beego.Error("Fetch 5 - ", err)
}
// 6 Retrieve the index after that treatment
index, err := repo.Index()
if err != nil {
beego.Error("Fetch 6 - ", err)
}
// 7 Check for conflicts
if index.HasConflicts() {
// 7a There are not automaticly solvable conflicts ... give them back to the user
beego.Trace("Conflicts! Write new index and return.", index)
err = index.Write()
if err != nil {
beego.Error("Write - ", err)
}
return errors.New("Conflicts")
}
// 8 Write the new tree
treeId, err := index.WriteTree()
if err != nil {
beego.Error("Fetch 9 - ", err)
}
// 9 Retrieve the new tree
tree, err := repo.LookupTree(treeId)
if err != nil {
beego.Error("Fetch 10 - ", err)
}
// 10 Retrieve the local commit
localCommit, err := repo.LookupCommit(currentCommit)
if err != nil {
beego.Error("Fetch 11 - ", err)
}
// 11 Retrieve the remote commit
remoteCommit, err := repo.LookupCommit(remoteBranch.Target())
if err != nil {
beego.Error("Fetch 12 - ", err)
}
// 12 Create a new one
repo.CreateCommit("HEAD", sig, sig, "Merge commit", tree, localCommit, remoteCommit)
// 13 Clean up
repo.StateCleanup()
}
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
// Push
err = remote.Push([]string{"refs/heads/master"}, nil, sig, message)
if err != nil {
beego.Error("Push - ", err)
}
return err
}