@@ -1,17 +1,12 @@
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 (
@@ -20,503 +15,14 @@ var (
// 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, 0, 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, 0, 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, 0, 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) {
- issue, _, err := gc.Issues.CreateIssue(repositoryID, &gitlab.CreateIssueOptions{
- Title: &title,
- Description: &body,
- })
-
- if err != nil {
- return "", "", err
- }
-
- return strconv.Itoa(issue.IID), issue.WebURL, 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 int, status bug.Status) error {
- var state string
-
- switch status {
- case bug.OpenStatus:
- state = "reopen"
- case bug.ClosedStatus:
- state = "close"
- default:
- panic("unknown bug state")
- }
-
- _, _, err := gc.Issues.UpdateIssue("", id, &gitlab.UpdateIssueOptions{
- StateEvent: &state,
- })
-
- return err
-}
-
-func updateGitlabIssueBody(gc *gitlab.Client, id int, body string) error {
- _, _, err := gc.Issues.UpdateIssue("", id, &gitlab.UpdateIssueOptions{
- Description: &body,
- })
-
- return err
-}
-
-func updateGitlabIssueTitle(gc *gitlab.Client, id int, title string) error {
- _, _, err := gc.Issues.UpdateIssue("", id, &gitlab.UpdateIssueOptions{
- Title: &title,
- })
-
- return err
-}
-
-// update gitlab. issue labels
-func (ge *gitlabExporter) updateGitlabIssueLabels(gc *gitlab.Client, labelableID string, added, removed []bug.Label) error {
- return nil
+ return nil, nil
}