package github import ( "bytes" "context" "encoding/json" "fmt" "io/ioutil" "net/http" "os" "strings" "time" "github.com/pkg/errors" "github.com/shurcooL/githubv4" "golang.org/x/sync/errgroup" "github.com/MichaelMure/git-bug/bridge/core" "github.com/MichaelMure/git-bug/bridge/core/auth" "github.com/MichaelMure/git-bug/bug" "github.com/MichaelMure/git-bug/cache" "github.com/MichaelMure/git-bug/entity" "github.com/MichaelMure/git-bug/identity" ) var ( ErrMissingIdentityToken = errors.New("missing identity token") ) // githubExporter implement the Exporter interface type githubExporter struct { conf core.Configuration // cache identities clients identityClient map[entity.Id]*githubv4.Client // the client to use for non user-specific queries // it's the client associated to the "default-login" config // used for the github V4 API (graphql) defaultClient *githubv4.Client // the token of the default user // it's the token associated to the "default-login" config // used for the github V3 API (REST) defaultToken *auth.Token // github repository ID repositoryID string // cache identifiers used to speed up exporting operations // cleared for each bug cachedOperationIDs map[entity.Id]string // cache labels used to speed up exporting labels events cachedLabels map[string]string } // Init . func (ge *githubExporter) Init(_ context.Context, repo *cache.RepoCache, conf core.Configuration) error { ge.conf = conf ge.identityClient = make(map[entity.Id]*githubv4.Client) ge.cachedOperationIDs = make(map[entity.Id]string) ge.cachedLabels = make(map[string]string) // preload all clients err := ge.cacheAllClient(repo) if err != nil { return err } return nil } func (ge *githubExporter) cacheAllClient(repo *cache.RepoCache) error { creds, err := auth.List(repo, auth.WithTarget(target), auth.WithKind(auth.KindToken)) if err != nil { return err } for _, cred := range creds { login, ok := cred.GetMetadata(auth.MetaKeyLogin) if !ok { _, _ = fmt.Fprintf(os.Stderr, "credential %s is not tagged with a Github login\n", cred.ID().Human()) continue } user, err := repo.ResolveIdentityImmutableMetadata(metaKeyGithubLogin, login) if err == identity.ErrIdentityNotExist { continue } if err != nil { return nil } if _, ok := ge.identityClient[user.Id()]; ok { continue } client := buildClient(creds[0].(*auth.Token)) ge.identityClient[user.Id()] = client // assign the default client and token as well if ge.defaultClient == nil && login == ge.conf[confKeyDefaultLogin] { ge.defaultClient = client ge.defaultToken = creds[0].(*auth.Token) } } if ge.defaultClient == nil { return fmt.Errorf("no token found for the default login \"%s\"", ge.conf[confKeyDefaultLogin]) } return nil } // getClientForIdentity return a githubv4 API client configured with the access token of the given identity. func (ge *githubExporter) getClientForIdentity(userId entity.Id) (*githubv4.Client, error) { client, ok := ge.identityClient[userId] if ok { return client, nil } return nil, ErrMissingIdentityToken } // ExportAll export all event made by the current user to Github func (ge *githubExporter) ExportAll(ctx context.Context, repo *cache.RepoCache, since time.Time) (<-chan core.ExportResult, error) { out := make(chan core.ExportResult) var err error // get repository node id ge.repositoryID, err = getRepositoryNodeID( ctx, ge.defaultToken, ge.conf[confKeyOwner], ge.conf[confKeyProject], ) if err != nil { return nil, err } // query all labels err = ge.cacheGithubLabels(ctx, ge.defaultClient) if err != nil { return nil, err } go func() { defer close(out) allIdentitiesIds := make([]entity.Id, 0, len(ge.identityClient)) for id := range ge.identityClient { allIdentitiesIds = append(allIdentitiesIds, id) } allBugsIds := repo.AllBugsIds() for _, id := range allBugsIds { b, err := repo.ResolveBug(id) if err != nil { out <- core.NewExportError(errors.Wrap(err, "can't load bug"), id) return } select { case <-ctx.Done(): // stop iterating if context cancel function is called return default: snapshot := b.Snapshot() // ignore issues created before since date // TODO: compare the Lamport time instead of using the unix time if snapshot.CreateTime.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(ctx, b, out) } } } }() return out, nil } // exportBug publish bugs and related events func (ge *githubExporter) exportBug(ctx context.Context, b *cache.BugCache, out chan<- core.ExportResult) { snapshot := b.Snapshot() var bugUpdated bool var bugGithubID string var bugGithubURL string // Special case: // if a user try to export a bug that is not already exported to Github (or imported // from Github) 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(core.MetaKeyOrigin) if ok && origin != target { out <- core.NewExportNothing(b.Id(), fmt.Sprintf("issue tagged with origin: %s", origin)) return } // get github bug ID githubID, ok := snapshot.GetCreateMetadata(metaKeyGithubId) if ok { githubURL, ok := snapshot.GetCreateMetadata(metaKeyGithubUrl) if !ok { // if we find github ID, github URL must be found too err := fmt.Errorf("incomplete Github metadata: expected to find issue URL") out <- core.NewExportError(err, b.Id()) } // extract owner and project owner, project, err := splitURL(githubURL) if err != nil { err := fmt.Errorf("bad project url: %v", err) out <- core.NewExportError(err, b.Id()) return } // ignore issue coming from other repositories if owner != ge.conf[confKeyOwner] && project != ge.conf[confKeyProject] { out <- core.NewExportNothing(b.Id(), fmt.Sprintf("skipping issue from url:%s", githubURL)) return } // will be used to mark operation related to a bug as exported bugGithubID = githubID bugGithubURL = githubURL } else { // check that we have a token for operation author client, err := ge.getClientForIdentity(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 := createGithubIssue(ctx, client, ge.repositoryID, createOp.Title, createOp.Message) if err != nil { err := errors.Wrap(err, "exporting github issue") out <- core.NewExportError(err, b.Id()) return } out <- core.NewExportBug(b.Id()) // mark bug creation operation as exported if err := markOperationAsExported(b, createOp.Id(), 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 github ID and URL bugGithubID = id bugGithubURL = url } // cache operation github id ge.cachedOperationIDs[createOp.Id()] = bugGithubID for _, op := range snapshot.Operations[1:] { // ignore SetMetadata operations if _, ok := op.(*bug.SetMetadataOperation); ok { continue } // ignore operations already existing in github (due to import or export) // cache the ID of already exported or imported issues and events from Github if id, ok := op.GetMetadata(metaKeyGithubId); ok { ge.cachedOperationIDs[op.Id()] = id continue } opAuthor := op.Author() client, err := ge.getClientForIdentity(opAuthor.Id()) if err != nil { continue } var id, url string switch op := op.(type) { case *bug.AddCommentOperation: // send operation to github id, url, err = addCommentGithubIssue(ctx, client, bugGithubID, op.Message) if err != nil { err := errors.Wrap(err, "adding comment") out <- core.NewExportError(err, b.Id()) return } out <- core.NewExportComment(op.Id()) // cache comment id ge.cachedOperationIDs[op.Id()] = id case *bug.EditCommentOperation: // Since github doesn't consider the issue body as a comment if op.Target == createOp.Id() { // case bug creation operation: we need to edit the Github issue if err := updateGithubIssueBody(ctx, client, bugGithubID, op.Message); err != nil { err := errors.Wrap(err, "editing issue") out <- core.NewExportError(err, b.Id()) return } out <- core.NewExportCommentEdition(op.Id()) id = bugGithubID url = bugGithubURL } else { // case comment edition operation: we need to edit the Github comment commentID, ok := ge.cachedOperationIDs[op.Target] if !ok { panic("unexpected error: comment id not found") } eid, eurl, err := editCommentGithubIssue(ctx, client, commentID, op.Message) if err != nil { err := errors.Wrap(err, "editing comment") out <- core.NewExportError(err, b.Id()) return } out <- core.NewExportCommentEdition(op.Id()) // use comment id/url instead of issue id/url id = eid url = eurl } case *bug.SetStatusOperation: if err := updateGithubIssueStatus(ctx, client, bugGithubID, op.Status); err != nil { err := errors.Wrap(err, "editing status") out <- core.NewExportError(err, b.Id()) return } out <- core.NewExportStatusChange(op.Id()) id = bugGithubID url = bugGithubURL case *bug.SetTitleOperation: if err := updateGithubIssueTitle(ctx, client, bugGithubID, op.Title); err != nil { err := errors.Wrap(err, "editing title") out <- core.NewExportError(err, b.Id()) return } out <- core.NewExportTitleEdition(op.Id()) id = bugGithubID url = bugGithubURL case *bug.LabelChangeOperation: if err := ge.updateGithubIssueLabels(ctx, client, bugGithubID, op.Added, op.Removed); err != nil { err := errors.Wrap(err, "updating labels") out <- core.NewExportError(err, b.Id()) return } out <- core.NewExportLabelChange(op.Id()) id = bugGithubID url = bugGithubURL default: panic("unhandled operation type case") } // mark operation as exported if err := markOperationAsExported(b, op.Id(), 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 } bugUpdated = true } if !bugUpdated { out <- core.NewExportNothing(b.Id(), "nothing has been exported") } } // getRepositoryNodeID request github api v3 to get repository node id func getRepositoryNodeID(ctx context.Context, token *auth.Token, owner, project string) (string, error) { url := fmt.Sprintf("%s/repos/%s/%s", githubV3Url, owner, project) client := &http.Client{} req, err := http.NewRequest("GET", url, nil) if err != nil { return "", err } // need the token for private repositories req.Header.Set("Authorization", fmt.Sprintf("token %s", token.Value)) ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() req = req.WithContext(ctx) resp, err := client.Do(req) if err != nil { return "", err } if resp.StatusCode != http.StatusOK { return "", fmt.Errorf("HTTP error %v retrieving repository node id", resp.StatusCode) } aux := struct { NodeID string `json:"node_id"` }{} data, _ := ioutil.ReadAll(resp.Body) err = resp.Body.Close() if err != nil { return "", err } err = json.Unmarshal(data, &aux) if err != nil { return "", err } return aux.NodeID, nil } func markOperationAsExported(b *cache.BugCache, target entity.Id, githubID, githubURL string) error { _, err := b.SetMetadata( target, map[string]string{ metaKeyGithubId: githubID, metaKeyGithubUrl: githubURL, }, ) return err } func (ge *githubExporter) cacheGithubLabels(ctx context.Context, gc *githubv4.Client) error { variables := map[string]interface{}{ "owner": githubv4.String(ge.conf[confKeyOwner]), "name": githubv4.String(ge.conf[confKeyProject]), "first": githubv4.Int(10), "after": (*githubv4.String)(nil), } q := labelsQuery{} hasNextPage := true for hasNextPage { // create a new timeout context at each iteration ctx, cancel := context.WithTimeout(ctx, defaultTimeout) if err := gc.Query(ctx, &q, variables); err != nil { cancel() return err } cancel() for _, label := range q.Repository.Labels.Nodes { ge.cachedLabels[label.Name] = label.ID } hasNextPage = q.Repository.Labels.PageInfo.HasNextPage variables["after"] = q.Repository.Labels.PageInfo.EndCursor } return nil } func (ge *githubExporter) getLabelID(label string) (string, error) { label = strings.ToLower(label) for cachedLabel, ID := range ge.cachedLabels { if label == strings.ToLower(cachedLabel) { return ID, nil } } return "", fmt.Errorf("didn't find label id in cache") } // create a new label and return it github id // NOTE: since createLabel mutation is still in preview mode we use github api v3 to create labels // see https://developer.github.com/v4/mutation/createlabel/ and https://developer.github.com/v4/previews/#labels-preview func (ge *githubExporter) createGithubLabel(ctx context.Context, label, color string) (string, error) { url := fmt.Sprintf("%s/repos/%s/%s/labels", githubV3Url, ge.conf[confKeyOwner], ge.conf[confKeyProject]) client := &http.Client{} params := struct { Name string `json:"name"` Color string `json:"color"` Description string `json:"description"` }{ Name: label, Color: color, } data, err := json.Marshal(params) if err != nil { return "", err } req, err := http.NewRequest("POST", url, bytes.NewBuffer(data)) if err != nil { return "", err } ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() req = req.WithContext(ctx) // need the token for private repositories req.Header.Set("Authorization", fmt.Sprintf("token %s", ge.defaultToken.Value)) resp, err := client.Do(req) if err != nil { return "", err } if resp.StatusCode != http.StatusCreated { return "", fmt.Errorf("error creating label: response status %v", resp.StatusCode) } aux := struct { ID int `json:"id"` NodeID string `json:"node_id"` Color string `json:"color"` }{} data, _ = ioutil.ReadAll(resp.Body) defer resp.Body.Close() err = json.Unmarshal(data, &aux) if err != nil { return "", err } return aux.NodeID, nil } /** // create github label using api v4 func (ge *githubExporter) createGithubLabelV4(gc *githubv4.Client, label, labelColor string) (string, error) { m := createLabelMutation{} input := createLabelInput{ RepositoryID: ge.repositoryID, Name: githubv4.String(label), Color: githubv4.String(labelColor), } parentCtx := context.Background() ctx, cancel := context.WithTimeout(parentCtx, defaultTimeout) defer cancel() if err := gc.Mutate(ctx, &m, input, nil); err != nil { return "", err } return m.CreateLabel.Label.ID, nil } */ func (ge *githubExporter) getOrCreateGithubLabelID(ctx context.Context, gc *githubv4.Client, repositoryID string, label bug.Label) (string, error) { // try to get label id from cache labelID, err := ge.getLabelID(string(label)) if err == nil { return labelID, nil } // RGBA to hex color rgba := label.Color().RGBA() hexColor := fmt.Sprintf("%.2x%.2x%.2x", rgba.R, rgba.G, rgba.B) ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() labelID, err = ge.createGithubLabel(ctx, string(label), hexColor) if err != nil { return "", err } return labelID, nil } func (ge *githubExporter) getLabelsIDs(ctx context.Context, gc *githubv4.Client, repositoryID string, labels []bug.Label) ([]githubv4.ID, error) { ids := make([]githubv4.ID, 0, len(labels)) var err error // check labels ids for _, label := range labels { id, ok := ge.cachedLabels[string(label)] if !ok { // try to query label id id, err = ge.getOrCreateGithubLabelID(ctx, gc, repositoryID, label) if err != nil { return nil, errors.Wrap(err, "get or create github label") } // cache label id ge.cachedLabels[string(label)] = id } ids = append(ids, githubv4.ID(id)) } return ids, nil } // create a github issue and return it ID func createGithubIssue(ctx context.Context, gc *githubv4.Client, repositoryID, title, body string) (string, string, error) { m := &createIssueMutation{} input := githubv4.CreateIssueInput{ RepositoryID: repositoryID, Title: githubv4.String(title), Body: (*githubv4.String)(&body), } ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() if err := gc.Mutate(ctx, m, input, nil); err != nil { return "", "", err } issue := m.CreateIssue.Issue return issue.ID, issue.URL, nil } // add a comment to an issue and return it ID func addCommentGithubIssue(ctx context.Context, gc *githubv4.Client, subjectID string, body string) (string, string, error) { m := &addCommentToIssueMutation{} input := githubv4.AddCommentInput{ SubjectID: subjectID, Body: githubv4.String(body), } ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() if err := gc.Mutate(ctx, m, input, nil); err != nil { return "", "", err } node := m.AddComment.CommentEdge.Node return node.ID, node.URL, nil } func editCommentGithubIssue(ctx context.Context, gc *githubv4.Client, commentID, body string) (string, string, error) { m := &updateIssueCommentMutation{} input := githubv4.UpdateIssueCommentInput{ ID: commentID, Body: githubv4.String(body), } ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() if err := gc.Mutate(ctx, m, input, nil); err != nil { return "", "", err } return commentID, m.UpdateIssueComment.IssueComment.URL, nil } func updateGithubIssueStatus(ctx context.Context, gc *githubv4.Client, id string, status bug.Status) error { m := &updateIssueMutation{} // set state var state githubv4.IssueState switch status { case bug.OpenStatus: state = githubv4.IssueStateOpen case bug.ClosedStatus: state = githubv4.IssueStateClosed default: panic("unknown bug state") } input := githubv4.UpdateIssueInput{ ID: id, State: &state, } ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() if err := gc.Mutate(ctx, m, input, nil); err != nil { return err } return nil } func updateGithubIssueBody(ctx context.Context, gc *githubv4.Client, id string, body string) error { m := &updateIssueMutation{} input := githubv4.UpdateIssueInput{ ID: id, Body: (*githubv4.String)(&body), } ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() if err := gc.Mutate(ctx, m, input, nil); err != nil { return err } return nil } func updateGithubIssueTitle(ctx context.Context, gc *githubv4.Client, id, title string) error { m := &updateIssueMutation{} input := githubv4.UpdateIssueInput{ ID: id, Title: (*githubv4.String)(&title), } ctx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() if err := gc.Mutate(ctx, m, input, nil); err != nil { return err } return nil } // update github issue labels func (ge *githubExporter) updateGithubIssueLabels(ctx context.Context, gc *githubv4.Client, labelableID string, added, removed []bug.Label) error { reqCtx, cancel := context.WithTimeout(ctx, defaultTimeout) defer cancel() wg, ctx := errgroup.WithContext(ctx) if len(added) > 0 { wg.Go(func() error { addedIDs, err := ge.getLabelsIDs(ctx, gc, labelableID, added) if err != nil { return err } m := &addLabelsToLabelableMutation{} inputAdd := githubv4.AddLabelsToLabelableInput{ LabelableID: labelableID, LabelIDs: addedIDs, } // add labels if err := gc.Mutate(reqCtx, m, inputAdd, nil); err != nil { return err } return nil }) } if len(removed) > 0 { wg.Go(func() error { removedIDs, err := ge.getLabelsIDs(ctx, gc, labelableID, removed) if err != nil { return err } m2 := &removeLabelsFromLabelableMutation{} inputRemove := githubv4.RemoveLabelsFromLabelableInput{ LabelableID: labelableID, LabelIDs: removedIDs, } // remove label labels if err := gc.Mutate(reqCtx, m2, inputRemove, nil); err != nil { return err } return nil }) } return wg.Wait() }