git-bug/bridge/gitlab/import.go

394 lines
8.3 KiB
Go
Raw Normal View History

2019-07-09 23:56:38 +03:00
package gitlab
import (
"context"
2019-07-17 01:06:42 +03:00
"fmt"
"strconv"
2019-07-09 23:56:38 +03:00
"time"
2019-07-17 01:06:42 +03:00
"github.com/xanzy/go-gitlab"
2019-07-09 23:56:38 +03:00
"github.com/MichaelMure/git-bug/bridge/core"
2019-07-17 01:06:42 +03:00
"github.com/MichaelMure/git-bug/bug"
2019-07-09 23:56:38 +03:00
"github.com/MichaelMure/git-bug/cache"
"github.com/MichaelMure/git-bug/entity"
2019-07-17 01:06:42 +03:00
"github.com/MichaelMure/git-bug/util/text"
2019-07-09 23:56:38 +03:00
)
// gitlabImporter implement the Importer interface
2019-07-09 23:56:38 +03:00
type gitlabImporter struct {
conf core.Configuration
2019-07-17 01:06:42 +03:00
// iterator
iterator *iterator
// send only channel
out chan<- core.ImportResult
2019-07-09 23:56:38 +03:00
}
2019-07-17 01:06:42 +03:00
func (gi *gitlabImporter) Init(conf core.Configuration) error {
gi.conf = conf
return nil
}
// ImportAll iterate over all the configured repository issues (notes) and ensure the creation
// of the missing issues / comments / label events / title changes ...
func (gi *gitlabImporter) ImportAll(ctx context.Context, repo *cache.RepoCache, since time.Time) (<-chan core.ImportResult, error) {
gi.iterator = NewIterator(ctx, 10, gi.conf[keyProjectID], gi.conf[keyToken], since)
out := make(chan core.ImportResult)
gi.out = out
go func() {
defer close(gi.out)
// Loop over all matching issues
for gi.iterator.NextIssue() {
issue := gi.iterator.IssueValue()
// create issue
b, err := gi.ensureIssue(repo, issue)
if err != nil {
err := fmt.Errorf("issue creation: %v", err)
out <- core.NewImportError(err, "")
return
}
2019-07-17 01:06:42 +03:00
// Loop over all notes
for gi.iterator.NextNote() {
note := gi.iterator.NoteValue()
if err := gi.ensureNote(repo, b, note); err != nil {
err := fmt.Errorf("note creation: %v", err)
out <- core.NewImportError(err, entity.Id(strconv.Itoa(note.ID)))
return
}
}
2019-07-17 01:06:42 +03:00
// Loop over all label events
for gi.iterator.NextLabelEvent() {
labelEvent := gi.iterator.LabelEventValue()
if err := gi.ensureLabelEvent(repo, b, labelEvent); err != nil {
err := fmt.Errorf("label event creation: %v", err)
out <- core.NewImportError(err, entity.Id(strconv.Itoa(labelEvent.ID)))
return
}
2019-07-17 01:06:42 +03:00
}
// commit bug state
if err := b.CommitAsNeeded(); err != nil {
err := fmt.Errorf("bug commit: %v", err)
out <- core.NewImportError(err, "")
return
2019-07-17 01:06:42 +03:00
}
}
if err := gi.iterator.Error(); err != nil {
out <- core.NewImportError(err, "")
}
}()
return out, nil
2019-07-09 23:56:38 +03:00
}
2019-07-17 01:06:42 +03:00
func (gi *gitlabImporter) ensureIssue(repo *cache.RepoCache, issue *gitlab.Issue) (*cache.BugCache, error) {
// ensure issue author
author, err := gi.ensurePerson(repo, issue.Author.ID)
if err != nil {
return nil, err
}
// resolve bug
b, err := repo.ResolveBugCreateMetadata(keyGitlabUrl, issue.WebURL)
if err == nil {
gi.out <- core.NewImportNothing("", "bug already imported")
return b, nil
}
if err != bug.ErrBugNotExist {
return nil, err
}
2019-07-17 01:06:42 +03:00
// if bug was never imported
cleanText, err := text.Cleanup(issue.Description)
if err != nil {
return nil, err
}
2019-07-17 01:06:42 +03:00
// create bug
b, _, err = repo.NewBugRaw(
author,
issue.CreatedAt.Unix(),
issue.Title,
cleanText,
nil,
map[string]string{
core.KeyOrigin: target,
keyGitlabId: parseID(issue.IID),
keyGitlabUrl: issue.WebURL,
keyGitlabProject: gi.conf[keyProjectID],
},
)
2019-07-17 01:06:42 +03:00
if err != nil {
return nil, err
2019-07-17 01:06:42 +03:00
}
// importing a new bug
gi.out <- core.NewImportBug(b.Id())
return b, nil
2019-07-17 01:06:42 +03:00
}
func (gi *gitlabImporter) ensureNote(repo *cache.RepoCache, b *cache.BugCache, note *gitlab.Note) error {
gitlabID := parseID(note.ID)
2019-07-17 01:06:42 +03:00
id, errResolve := b.ResolveOperationWithMetadata(keyGitlabId, gitlabID)
if errResolve != nil && errResolve != cache.ErrNoMatchingOp {
return errResolve
}
2019-07-17 01:06:42 +03:00
// ensure issue author
author, err := gi.ensurePerson(repo, note.Author.ID)
if err != nil {
return err
}
noteType, body := GetNoteType(note)
switch noteType {
case NOTE_CLOSED:
if errResolve == nil {
return nil
}
op, err := b.CloseRaw(
2019-07-17 01:06:42 +03:00
author,
note.CreatedAt.Unix(),
map[string]string{
keyGitlabId: gitlabID,
2019-07-17 01:06:42 +03:00
},
)
if err != nil {
return err
}
gi.out <- core.NewImportStatusChange(op.Id())
2019-07-17 01:06:42 +03:00
case NOTE_REOPENED:
if errResolve == nil {
return nil
}
op, err := b.OpenRaw(
2019-07-17 01:06:42 +03:00
author,
note.CreatedAt.Unix(),
map[string]string{
keyGitlabId: gitlabID,
2019-07-17 01:06:42 +03:00
},
)
if err != nil {
return err
}
gi.out <- core.NewImportStatusChange(op.Id())
2019-07-17 01:06:42 +03:00
case NOTE_DESCRIPTION_CHANGED:
issue := gi.iterator.IssueValue()
firstComment := b.Snapshot().Comments[0]
2019-07-17 01:06:42 +03:00
// since gitlab doesn't provide the issue history
// we should check for "changed the description" notes and compare issue texts
// TODO: Check only one time and ignore next 'description change' within one issue
if errResolve == cache.ErrNoMatchingOp && issue.Description != firstComment.Message {
2019-07-17 01:06:42 +03:00
// comment edition
op, err := b.EditCommentRaw(
2019-07-17 01:06:42 +03:00
author,
note.UpdatedAt.Unix(),
firstComment.Id(),
2019-07-17 01:06:42 +03:00
issue.Description,
map[string]string{
keyGitlabId: gitlabID,
2019-07-17 01:06:42 +03:00
},
)
if err != nil {
return err
}
2019-07-17 01:06:42 +03:00
gi.out <- core.NewImportTitleEdition(op.Id())
2019-07-17 01:06:42 +03:00
}
case NOTE_COMMENT:
cleanText, err := text.Cleanup(body)
if err != nil {
return err
}
// if we didn't import the comment
if errResolve == cache.ErrNoMatchingOp {
2019-07-17 01:06:42 +03:00
// add comment operation
op, err := b.AddCommentRaw(
2019-07-17 01:06:42 +03:00
author,
note.CreatedAt.Unix(),
cleanText,
nil,
map[string]string{
keyGitlabId: gitlabID,
2019-07-17 01:06:42 +03:00
},
)
if err != nil {
return err
}
gi.out <- core.NewImportComment(op.Id())
return nil
2019-07-17 01:06:42 +03:00
}
// if comment was already exported
// search for last comment update
comment, err := b.Snapshot().SearchComment(id)
2019-07-17 01:06:42 +03:00
if err != nil {
return err
}
// compare local bug comment with the new note body
if comment.Message != cleanText {
2019-07-17 01:06:42 +03:00
// comment edition
op, err := b.EditCommentRaw(
2019-07-17 01:06:42 +03:00
author,
note.UpdatedAt.Unix(),
comment.Id(),
2019-07-17 01:06:42 +03:00
cleanText,
nil,
2019-07-17 01:06:42 +03:00
)
if err != nil {
return err
}
gi.out <- core.NewImportCommentEdition(op.Id())
2019-07-17 01:06:42 +03:00
}
return nil
case NOTE_TITLE_CHANGED:
// title change events are given new notes
if errResolve == nil {
return nil
}
op, err := b.SetTitleRaw(
2019-07-17 01:06:42 +03:00
author,
note.CreatedAt.Unix(),
body,
map[string]string{
keyGitlabId: gitlabID,
2019-07-17 01:06:42 +03:00
},
)
if err != nil {
return err
}
2019-07-17 01:06:42 +03:00
gi.out <- core.NewImportTitleEdition(op.Id())
2019-07-17 01:06:42 +03:00
case NOTE_UNKNOWN,
NOTE_ASSIGNED,
NOTE_UNASSIGNED,
NOTE_CHANGED_MILESTONE,
NOTE_REMOVED_MILESTONE,
NOTE_CHANGED_DUEDATE,
NOTE_REMOVED_DUEDATE,
NOTE_LOCKED,
NOTE_UNLOCKED,
NOTE_MENTIONED_IN_ISSUE,
NOTE_MENTIONED_IN_MERGE_REQUEST:
reason := fmt.Sprintf("unsupported note type: %s", noteType.String())
gi.out <- core.NewImportNothing("", reason)
2019-07-17 01:06:42 +03:00
return nil
default:
panic("unhandled note type")
2019-07-17 01:06:42 +03:00
}
2019-07-09 23:56:38 +03:00
return nil
}
2019-07-17 01:06:42 +03:00
func (gi *gitlabImporter) ensureLabelEvent(repo *cache.RepoCache, b *cache.BugCache, labelEvent *gitlab.LabelEvent) error {
_, err := b.ResolveOperationWithMetadata(keyGitlabId, parseID(labelEvent.ID))
if err != cache.ErrNoMatchingOp {
return err
}
// ensure issue author
author, err := gi.ensurePerson(repo, labelEvent.User.ID)
if err != nil {
return err
}
switch labelEvent.Action {
case "add":
_, err = b.ForceChangeLabelsRaw(
author,
labelEvent.CreatedAt.Unix(),
[]string{labelEvent.Label.Name},
nil,
map[string]string{
keyGitlabId: parseID(labelEvent.ID),
},
)
case "remove":
_, err = b.ForceChangeLabelsRaw(
author,
labelEvent.CreatedAt.Unix(),
nil,
[]string{labelEvent.Label.Name},
map[string]string{
keyGitlabId: parseID(labelEvent.ID),
},
)
default:
err = fmt.Errorf("unexpected label event action")
2019-07-17 01:06:42 +03:00
}
return err
}
func (gi *gitlabImporter) ensurePerson(repo *cache.RepoCache, id int) (*cache.IdentityCache, error) {
// Look first in the cache
i, err := repo.ResolveIdentityImmutableMetadata(keyGitlabId, strconv.Itoa(id))
if err == nil {
return i, nil
}
if _, ok := err.(entity.ErrMultipleMatch); ok {
return nil, err
}
2019-07-17 01:06:42 +03:00
client := buildClient(gi.conf["token"])
user, _, err := client.Users.GetUser(id)
if err != nil {
return nil, err
}
i, err = repo.NewIdentityRaw(
2019-07-17 01:06:42 +03:00
user.Name,
user.PublicEmail,
user.Username,
user.AvatarURL,
map[string]string{
2019-07-23 20:16:52 +03:00
// because Gitlab
keyGitlabId: strconv.Itoa(id),
2019-07-17 01:06:42 +03:00
keyGitlabLogin: user.Username,
},
)
if err != nil {
return nil, err
}
gi.out <- core.NewImportIdentity(i.Id())
return i, nil
2019-07-17 01:06:42 +03:00
}
func parseID(id int) string {
return fmt.Sprintf("%d", id)
}