package gitlab
import (
"fmt"
"strconv"
"time"
"github.com/pkg/errors"
"github.com/xanzy/go-gitlab"
"github.com/MichaelMure/git-bug/bridge/core"
"github.com/MichaelMure/git-bug/bug"
"github.com/MichaelMure/git-bug/cache"
"github.com/MichaelMure/git-bug/util/git"
)
var (
ErrMissingIdentityToken = errors.New("missing identity token")
)
const (
keyGitlabId = "gitlab-id"
keyGitlabUrl = "gitlab-url"
keyOrigin = "origin"
)
// gitlabExporter implement the Exporter interface
type gitlabExporter struct {
conf core.Configuration
// cache identities clients
identityClient map[string]*gitlab.Client
// map identities with their tokens
identityToken map[string]string
// gitlab repository ID
repositoryID string
// cache identifiers used to speed up exporting operations
// cleared for each bug
cachedOperationIDs map[string]string
// cache labels used to speed up exporting labels events
cachedLabels map[string]string
}
// Init .
func (ge *gitlabExporter) Init(conf core.Configuration) error {
ge.conf = conf
//TODO: initialize with multiple tokens
ge.identityToken = make(map[string]string)
ge.identityClient = make(map[string]*gitlab.Client)
ge.cachedOperationIDs = make(map[string]string)
ge.cachedLabels = make(map[string]string)
return nil
}
// getIdentityClient return a gitlab v4 API client configured with the access token of the given identity.
// if no client were found it will initialize it from the known tokens map and cache it for next use
func (ge *gitlabExporter) getIdentityClient(id string) (*gitlab.Client, error) {
client, ok := ge.identityClient[id]
if ok {
return client, nil
}
// get token
token, ok := ge.identityToken[id]
if !ok {
return nil, ErrMissingIdentityToken
}
// create client
client = buildClient(token)
// cache client
ge.identityClient[id] = client
return client, nil
}
// ExportAll export all event made by the current user to Gitlab
func (ge *gitlabExporter) ExportAll(repo *cache.RepoCache, since time.Time) (<-chan core.ExportResult, error) {
out := make(chan core.ExportResult)
user, err := repo.GetUserIdentity()
if err != nil {
return nil, err
}
ge.identityToken[user.Id()] = ge.conf[keyToken]
// get repository node id
ge.repositoryID = ge.conf[keyProjectID]
if err != nil {
return nil, err
}
go func() {
defer close(out)
var allIdentitiesIds []string
for id := range ge.identityToken {
allIdentitiesIds = append(allIdentitiesIds, id)
}
allBugsIds := repo.AllBugsIds()
for _, id := range allBugsIds {
b, err := repo.ResolveBug(id)
if err != nil {
out <- core.NewExportError(err, id)
return
}
snapshot := b.Snapshot()
// ignore issues created before since date
// TODO: compare the Lamport time instead of using the unix time
if snapshot.CreatedAt.Before(since) {
out <- core.NewExportNothing(b.Id(), "bug created before the since date")
continue
}
if snapshot.HasAnyActor(allIdentitiesIds...) {
// try to export the bug and it associated events
ge.exportBug(b, since, out)
} else {
out <- core.NewExportNothing(id, "not an actor")
}
}
}()
return out, nil
}
// exportBug publish bugs and related events
func (ge *gitlabExporter) exportBug(b *cache.BugCache, since time.Time, out chan<- core.ExportResult) {
snapshot := b.Snapshot()
var bugGitlabID string
var bugGitlabURL string
var bugCreationHash string
// Special case:
// if a user try to export a bug that is not already exported to Gitlab (or imported
// from Gitlab) and we do not have the token of the bug author, there is nothing we can do.
// first operation is always createOp
createOp := snapshot.Operations[0].(*bug.CreateOperation)
author := snapshot.Author
// skip bug if origin is not allowed
origin, ok := snapshot.GetCreateMetadata(keyOrigin)
if ok && origin != target {
out <- core.NewExportNothing(b.Id(), fmt.Sprintf("issue tagged with origin: %s", origin))
return
}
// get gitlab bug ID
gitlabID, ok := snapshot.GetCreateMetadata(keyGitlabId)
if ok {
gitlabURL, ok := snapshot.GetCreateMetadata(keyGitlabUrl)
if !ok {
// if we find gitlab ID, gitlab URL must be found too
err := fmt.Errorf("expected to find gitlab issue URL")
out <- core.NewExportError(err, b.Id())
}
//FIXME:
// ignore issue comming from other repositories
out <- core.NewExportNothing(b.Id(), "bug already exported")
// will be used to mark operation related to a bug as exported
bugGitlabID = gitlabID
bugGitlabURL = gitlabURL
} else {
// check that we have a token for operation author
client, err := ge.getIdentityClient(author.Id())
if err != nil {
// if bug is still not exported and we do not have the author stop the execution
out <- core.NewExportNothing(b.Id(), fmt.Sprintf("missing author token"))
return
}
// create bug
id, url, err := createGitlabIssue(client, ge.repositoryID, createOp.Title, createOp.Message)
if err != nil {
err := errors.Wrap(err, "exporting gitlab issue")
out <- core.NewExportError(err, b.Id())
return
}
out <- core.NewExportBug(b.Id())
hash, err := createOp.Hash()
if err != nil {
err := errors.Wrap(err, "comment hash")
out <- core.NewExportError(err, b.Id())
return
}
// mark bug creation operation as exported
if err := markOperationAsExported(b, hash, id, url); err != nil {
err := errors.Wrap(err, "marking operation as exported")
out <- core.NewExportError(err, b.Id())
return
}
// commit operation to avoid creating multiple issues with multiple pushes
if err := b.CommitAsNeeded(); err != nil {
err := errors.Wrap(err, "bug commit")
out <- core.NewExportError(err, b.Id())
return
}
// cache bug gitlab ID and URL
bugGitlabID = id
bugGitlabURL = url
}
// get createOp hash
hash, err := createOp.Hash()
if err != nil {
out <- core.NewExportError(err, b.Id())
return
}
bugCreationHash = hash.String()
// cache operation gitlab id
ge.cachedOperationIDs[bugCreationHash] = bugGitlabID
for _, op := range snapshot.Operations[1:] {
// ignore SetMetadata operations
if _, ok := op.(*bug.SetMetadataOperation); ok {
continue
}
// get operation hash
hash, err := op.Hash()
if err != nil {
err := errors.Wrap(err, "operation hash")
out <- core.NewExportError(err, b.Id())
return
}
// ignore operations already existing in gitlab (due to import or export)
// cache the ID of already exported or imported issues and events from Gitlab
if id, ok := op.GetMetadata(keyGitlabId); ok {
ge.cachedOperationIDs[hash.String()] = id
out <- core.NewExportNothing(hash.String(), "already exported operation")
continue
}
opAuthor := op.GetAuthor()
client, err := ge.getIdentityClient(opAuthor.Id())
if err != nil {
out <- core.NewExportNothing(hash.String(), "missing operation author token")
continue
}
var id, url string
switch op.(type) {
case *bug.AddCommentOperation:
opr := op.(*bug.AddCommentOperation)
// send operation to gitlab
id, url, err = addCommentGitlabIssue(client, bugGitlabID, opr.Message)
if err != nil {
err := errors.Wrap(err, "adding comment")
out <- core.NewExportError(err, b.Id())
return
}
out <- core.NewExportComment(hash.String())
// cache comment id
ge.cachedOperationIDs[hash.String()] = id
case *bug.EditCommentOperation:
opr := op.(*bug.EditCommentOperation)
targetHash := opr.Target.String()
// Since gitlab doesn't consider the issue body as a comment
if targetHash == bugCreationHash {
// case bug creation operation: we need to edit the Gitlab issue
if err := updateGitlabIssueBody(client, bugGitlabID, opr.Message); err != nil {
err := errors.Wrap(err, "editing issue")
out <- core.NewExportError(err, b.Id())
return
}
out <- core.NewExportCommentEdition(hash.String())
id = bugGitlabID
url = bugGitlabURL
} else {
// case comment edition operation: we need to edit the Gitlab comment
commentID, ok := ge.cachedOperationIDs[targetHash]
if !ok {
panic("unexpected error: comment id not found")
}
eid, eurl, err := editCommentGitlabIssue(client, commentID, opr.Message)
if err != nil {
err := errors.Wrap(err, "editing comment")
out <- core.NewExportError(err, b.Id())
return
}
out <- core.NewExportCommentEdition(hash.String())
// use comment id/url instead of issue id/url
id = eid
url = eurl
}
case *bug.SetStatusOperation:
opr := op.(*bug.SetStatusOperation)
if err := updateGitlabIssueStatus(client, bugGitlabID, opr.Status); err != nil {
err := errors.Wrap(err, "editing status")
out <- core.NewExportError(err, b.Id())
return
}
out <- core.NewExportStatusChange(hash.String())
id = bugGitlabID
url = bugGitlabURL
case *bug.SetTitleOperation:
opr := op.(*bug.SetTitleOperation)
if err := updateGitlabIssueTitle(client, bugGitlabID, opr.Title); err != nil {
err := errors.Wrap(err, "editing title")
out <- core.NewExportError(err, b.Id())
return
}
out <- core.NewExportTitleEdition(hash.String())
id = bugGitlabID
url = bugGitlabURL
case *bug.LabelChangeOperation:
opr := op.(*bug.LabelChangeOperation)
if err := ge.updateGitlabIssueLabels(client, bugGitlabID, opr.Added, opr.Removed); err != nil {
err := errors.Wrap(err, "updating labels")
out <- core.NewExportError(err, b.Id())
return
}
out <- core.NewExportLabelChange(hash.String())
id = bugGitlabID
url = bugGitlabURL
default:
panic("unhandled operation type case")
}
// mark operation as exported
if err := markOperationAsExported(b, hash, id, url); err != nil {
err := errors.Wrap(err, "marking operation as exported")
out <- core.NewExportError(err, b.Id())
return
}
// commit at each operation export to avoid exporting same events multiple times
if err := b.CommitAsNeeded(); err != nil {
err := errors.Wrap(err, "bug commit")
out <- core.NewExportError(err, b.Id())
return
}
}
}
func markOperationAsExported(b *cache.BugCache, target git.Hash, gitlabID, gitlabURL string) error {
_, err := b.SetMetadata(
target,
map[string]string{
keyGitlabId: gitlabID,
keyGitlabUrl: gitlabURL,
},
)
return err
}
func (ge *gitlabExporter) getGitlabLabelID(label string) (string, error) {
id, ok := ge.cachedLabels[label]
if !ok {
return "", fmt.Errorf("non cached label")
}
return id, nil
}
// get label from gitlab
func (ge *gitlabExporter) loadLabelsFromGitlab(client *gitlab.Client) error {
labels, _, err := client.Labels.ListLabels(
ge.repositoryID,
&gitlab.ListLabelsOptions{
Page: 0,
},
)
if err != nil {
return err
}
for _, label := range labels {
ge.cachedLabels[label.Name] = strconv.Itoa(label.ID)
}
for page := 2; len(labels) != 0; page++ {
labels, _, err = client.Labels.ListLabels(
ge.repositoryID,
&gitlab.ListLabelsOptions{
Page: page,
},
)
if err != nil {
return err
}
for _, label := range labels {
ge.cachedLabels[label.Name] = strconv.Itoa(label.ID)
}
}
return nil
}
func (ge *gitlabExporter) createGitlabLabel(gc *gitlab.Client, label bug.Label) (string, error) {
client := buildClient(ge.conf[keyToken])
// RGBA to hex color
rgba := label.RGBA()
hexColor := fmt.Sprintf("%.2x%.2x%.2x", rgba.R, rgba.G, rgba.B)
name := label.String()
_, _, err := client.Labels.CreateLabel(ge.repositoryID, &gitlab.CreateLabelOptions{
Name: &name,
Color: &hexColor,
})
if err != nil {
return "", err
}
return "", nil
}
func (ge *gitlabExporter) getLabelsIDs(gc *gitlab.Client, repositoryID string, labels []bug.Label) ([]string, error) {
return []string{}, nil
}
// create a gitlab. issue and return it ID
func createGitlabIssue(gc *gitlab.Client, repositoryID, title, body string) (string, string, error) {
return "", "", nil
}
// add a comment to an issue and return it ID
func addCommentGitlabIssue(gc *gitlab.Client, subjectID string, body string) (string, string, error) {
return "", "", nil
}
func editCommentGitlabIssue(gc *gitlab.Client, commentID, body string) (string, string, error) {
return "", "", nil
}
func updateGitlabIssueStatus(gc *gitlab.Client, id string, status bug.Status) error {
return nil
}
func updateGitlabIssueBody(gc *gitlab.Client, id string, body string) error {
return nil
}
func updateGitlabIssueTitle(gc *gitlab.Client, id, title string) error {
return nil
}
// update gitlab. issue labels
func (ge *gitlabExporter) updateGitlabIssueLabels(gc *gitlab.Client, labelableID string, added, removed []bug.Label) error {
return nil
}
