package github import ( "context" "fmt" "time" "github.com/shurcooL/githubv4" "github.com/MichaelMure/git-bug/bridge/core" "github.com/MichaelMure/git-bug/bridge/core/auth" "github.com/MichaelMure/git-bug/cache" "github.com/MichaelMure/git-bug/entities/bug" "github.com/MichaelMure/git-bug/entity" "github.com/MichaelMure/git-bug/util/text" ) const EmptyTitlePlaceholder = "" // githubImporter implement the Importer interface type githubImporter struct { conf core.Configuration // default client client *rateLimitHandlerClient // mediator to access the Github API mediator *importMediator // send only channel out chan<- core.ImportResult } func (gi *githubImporter) Init(_ context.Context, repo *cache.RepoCache, conf core.Configuration) error { gi.conf = conf creds, err := auth.List(repo, auth.WithTarget(target), auth.WithKind(auth.KindToken), auth.WithMeta(auth.MetaKeyLogin, conf[confKeyDefaultLogin]), ) if err != nil { return err } if len(creds) <= 0 { return ErrMissingIdentityToken } gi.client = buildClient(creds[0].(*auth.Token)) return nil } // ImportAll iterate over all the configured repository issues and ensure the creation of the // missing issues / timeline items / edits / label events ... func (gi *githubImporter) ImportAll(ctx context.Context, repo *cache.RepoCache, since time.Time) (<-chan core.ImportResult, error) { gi.mediator = NewImportMediator(ctx, gi.client, gi.conf[confKeyOwner], gi.conf[confKeyProject], since) out := make(chan core.ImportResult) gi.out = out go func() { defer close(gi.out) var currBug *cache.BugCache var currEvent ImportEvent var nextEvent ImportEvent var err error for { // An IssueEvent contains the issue in its most recent state. If an issue // has at least one issue edit, then the history of the issue edits is // represented by IssueEditEvents. That is, the unedited (original) issue // might be saved only in the IssueEditEvent following the IssueEvent. // Since we replicate the edit history we need to either use the IssueEvent // (if there are no edits) or the IssueEvent together with its first // IssueEditEvent (if there are edits). // Exactly the same is true for comments and comment edits. // As a consequence we need to look at the current event and one look ahead // event. currEvent = nextEvent if currEvent == nil { currEvent = gi.getEventHandleMsgs() } if currEvent == nil { break } nextEvent = gi.getEventHandleMsgs() switch event := currEvent.(type) { case RateLimitingEvent: out <- core.NewImportRateLimiting(event.msg) case IssueEvent: // first: commit what is being held in currBug if err = gi.commit(currBug, out); err != nil { out <- core.NewImportError(err, "") return } // second: create new issue switch next := nextEvent.(type) { case IssueEditEvent: // consuming and using next event nextEvent = nil currBug, err = gi.ensureIssue(ctx, repo, &event.issue, &next.userContentEdit) default: currBug, err = gi.ensureIssue(ctx, repo, &event.issue, nil) } if err != nil { err := fmt.Errorf("issue creation: %v", err) out <- core.NewImportError(err, "") return } case IssueEditEvent: err = gi.ensureIssueEdit(ctx, repo, currBug, event.issueId, &event.userContentEdit) if err != nil { err = fmt.Errorf("issue edit: %v", err) out <- core.NewImportError(err, "") return } case TimelineEvent: if next, ok := nextEvent.(CommentEditEvent); ok && event.Typename == "IssueComment" { // consuming and using next event nextEvent = nil err = gi.ensureComment(ctx, repo, currBug, &event.timelineItem.IssueComment, &next.userContentEdit) } else { err = gi.ensureTimelineItem(ctx, repo, currBug, &event.timelineItem) } if err != nil { err = fmt.Errorf("timeline item creation: %v", err) out <- core.NewImportError(err, "") return } case CommentEditEvent: err = gi.ensureCommentEdit(ctx, repo, currBug, event.commentId, &event.userContentEdit) if err != nil { err = fmt.Errorf("comment edit: %v", err) out <- core.NewImportError(err, "") return } default: panic("Unknown event type") } } // commit what is being held in currBug before returning if err = gi.commit(currBug, out); err != nil { out <- core.NewImportError(err, "") } if err = gi.mediator.Error(); err != nil { gi.out <- core.NewImportError(err, "") } }() return out, nil } func (gi *githubImporter) getEventHandleMsgs() ImportEvent { for { // read event from import mediator event := gi.mediator.NextImportEvent() // consume (and use) all rate limiting events if e, ok := event.(RateLimitingEvent); ok { gi.out <- core.NewImportRateLimiting(e.msg) continue } return event } } func (gi *githubImporter) commit(b *cache.BugCache, out chan<- core.ImportResult) error { if b == nil { return nil } if !b.NeedCommit() { out <- core.NewImportNothing(b.Id(), "no imported operation") return nil } else if err := b.Commit(); err != nil { // commit bug state return fmt.Errorf("bug commit: %v", err) } return nil } func (gi *githubImporter) ensureIssue(ctx context.Context, repo *cache.RepoCache, issue *issue, issueEdit *userContentEdit) (*cache.BugCache, error) { author, err := gi.ensurePerson(ctx, repo, issue.Author) if err != nil { return nil, err } // resolve bug b, err := repo.ResolveBugMatcher(func(excerpt *cache.BugExcerpt) bool { return excerpt.CreateMetadata[metaKeyGithubUrl] == issue.Url.String() && excerpt.CreateMetadata[metaKeyGithubId] == parseId(issue.Id) }) if err == nil { return b, nil } if err != bug.ErrBugNotExist { return nil, err } // At Github there exist issues with seemingly empty titles. An example is // https://github.com/NixOS/nixpkgs/issues/72730 (here the title is actually // a zero width space U+200B). // Set title to some non-empty string, since git-bug does not accept empty titles. title := text.CleanupOneLine(string(issue.Title)) if text.Empty(title) { title = EmptyTitlePlaceholder } var textInput string if issueEdit != nil { // use the first issue edit: it represents the bug creation itself textInput = string(*issueEdit.Diff) } else { // if there are no issue edits then the issue struct holds the bug creation textInput = string(issue.Body) } // create bug b, _, err = repo.NewBugRaw( author, issue.CreatedAt.Unix(), text.CleanupOneLine(title), // TODO: this is the *current* title, not the original one text.Cleanup(textInput), nil, map[string]string{ core.MetaKeyOrigin: target, metaKeyGithubId: parseId(issue.Id), metaKeyGithubUrl: issue.Url.String(), }) if err != nil { return nil, err } // importing a new bug gi.out <- core.NewImportBug(b.Id()) return b, nil } func (gi *githubImporter) ensureIssueEdit(ctx context.Context, repo *cache.RepoCache, bug *cache.BugCache, ghIssueId githubv4.ID, edit *userContentEdit) error { return gi.ensureCommentEdit(ctx, repo, bug, ghIssueId, edit) } func (gi *githubImporter) ensureTimelineItem(ctx context.Context, repo *cache.RepoCache, b *cache.BugCache, item *timelineItem) error { switch item.Typename { case "IssueComment": err := gi.ensureComment(ctx, repo, b, &item.IssueComment, nil) if err != nil { return fmt.Errorf("timeline comment creation: %v", err) } return nil case "LabeledEvent": id := parseId(item.LabeledEvent.Id) _, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id) if err == nil { return nil } if err != cache.ErrNoMatchingOp { return err } author, err := gi.ensurePerson(ctx, repo, item.LabeledEvent.Actor) if err != nil { return err } op, err := b.ForceChangeLabelsRaw( author, item.LabeledEvent.CreatedAt.Unix(), []string{ text.CleanupOneLine(string(item.LabeledEvent.Label.Name)), }, nil, map[string]string{metaKeyGithubId: id}, ) if err != nil { return err } gi.out <- core.NewImportLabelChange(b.Id(), op.Id()) return nil case "UnlabeledEvent": id := parseId(item.UnlabeledEvent.Id) _, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id) if err == nil { return nil } if err != cache.ErrNoMatchingOp { return err } author, err := gi.ensurePerson(ctx, repo, item.UnlabeledEvent.Actor) if err != nil { return err } op, err := b.ForceChangeLabelsRaw( author, item.UnlabeledEvent.CreatedAt.Unix(), nil, []string{ text.CleanupOneLine(string(item.UnlabeledEvent.Label.Name)), }, map[string]string{metaKeyGithubId: id}, ) if err != nil { return err } gi.out <- core.NewImportLabelChange(b.Id(), op.Id()) return nil case "ClosedEvent": id := parseId(item.ClosedEvent.Id) _, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id) if err != cache.ErrNoMatchingOp { return err } if err == nil { return nil } author, err := gi.ensurePerson(ctx, repo, item.ClosedEvent.Actor) if err != nil { return err } op, err := b.CloseRaw( author, item.ClosedEvent.CreatedAt.Unix(), map[string]string{metaKeyGithubId: id}, ) if err != nil { return err } gi.out <- core.NewImportStatusChange(b.Id(), op.Id()) return nil case "ReopenedEvent": id := parseId(item.ReopenedEvent.Id) _, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id) if err != cache.ErrNoMatchingOp { return err } if err == nil { return nil } author, err := gi.ensurePerson(ctx, repo, item.ReopenedEvent.Actor) if err != nil { return err } op, err := b.OpenRaw( author, item.ReopenedEvent.CreatedAt.Unix(), map[string]string{metaKeyGithubId: id}, ) if err != nil { return err } gi.out <- core.NewImportStatusChange(b.Id(), op.Id()) return nil case "RenamedTitleEvent": id := parseId(item.RenamedTitleEvent.Id) _, err := b.ResolveOperationWithMetadata(metaKeyGithubId, id) if err != cache.ErrNoMatchingOp { return err } if err == nil { return nil } author, err := gi.ensurePerson(ctx, repo, item.RenamedTitleEvent.Actor) if err != nil { return err } // At Github there exist issues with seemingly empty titles. An example is // https://github.com/NixOS/nixpkgs/issues/72730 (here the title is actually // a zero width space U+200B). // Set title to some non-empty string, since git-bug does not accept empty titles. title := text.CleanupOneLine(string(item.RenamedTitleEvent.CurrentTitle)) if text.Empty(title) { title = EmptyTitlePlaceholder } op, err := b.SetTitleRaw( author, item.RenamedTitleEvent.CreatedAt.Unix(), title, map[string]string{metaKeyGithubId: id}, ) if err != nil { return err } gi.out <- core.NewImportTitleEdition(b.Id(), op.Id()) return nil } return nil } func (gi *githubImporter) ensureCommentEdit(ctx context.Context, repo *cache.RepoCache, b *cache.BugCache, ghTargetId githubv4.ID, edit *userContentEdit) error { // find comment target, err := b.ResolveOperationWithMetadata(metaKeyGithubId, parseId(ghTargetId)) if err != nil { return err } // check if the comment edition already exist _, err = b.ResolveOperationWithMetadata(metaKeyGithubId, parseId(edit.Id)) if err == nil { return nil } if err != cache.ErrNoMatchingOp { // real error return err } editor, err := gi.ensurePerson(ctx, repo, edit.Editor) if err != nil { return err } if edit.DeletedAt != nil { // comment deletion, not supported yet return nil } commentId := entity.CombineIds(b.Id(), target) // comment edition _, err = b.EditCommentRaw( editor, edit.CreatedAt.Unix(), commentId, text.Cleanup(string(*edit.Diff)), map[string]string{ metaKeyGithubId: parseId(edit.Id), }, ) if err != nil { return err } gi.out <- core.NewImportCommentEdition(b.Id(), commentId) return nil } func (gi *githubImporter) ensureComment(ctx context.Context, repo *cache.RepoCache, b *cache.BugCache, comment *issueComment, firstEdit *userContentEdit) error { author, err := gi.ensurePerson(ctx, repo, comment.Author) if err != nil { return err } _, err = b.ResolveOperationWithMetadata(metaKeyGithubId, parseId(comment.Id)) if err == nil { return nil } if err != cache.ErrNoMatchingOp { // real error return err } var textInput string if firstEdit != nil { // use the first comment edit: it represents the comment creation itself textInput = string(*firstEdit.Diff) } else { // if there are not comment edits, then the comment struct holds the comment creation textInput = string(comment.Body) } // add comment operation commentId, _, err := b.AddCommentRaw( author, comment.CreatedAt.Unix(), text.Cleanup(textInput), nil, map[string]string{ metaKeyGithubId: parseId(comment.Id), metaKeyGithubUrl: comment.Url.String(), }, ) if err != nil { return err } gi.out <- core.NewImportComment(b.Id(), commentId) return nil } // ensurePerson create a bug.Person from the Github data func (gi *githubImporter) ensurePerson(ctx context.Context, repo *cache.RepoCache, actor *actor) (*cache.IdentityCache, error) { // When a user has been deleted, Github return a null actor, while displaying a profile named "ghost" // in it's UI. So we need a special case to get it. if actor == nil { return gi.getGhost(ctx, repo) } // Look first in the cache i, err := repo.ResolveIdentityImmutableMetadata(metaKeyGithubLogin, string(actor.Login)) if err == nil { return i, nil } if entity.IsErrMultipleMatch(err) { return nil, err } // importing a new identity var name string var email string switch actor.Typename { case "User": if actor.User.Name != nil { name = string(*(actor.User.Name)) } email = string(actor.User.Email) case "Organization": if actor.Organization.Name != nil { name = string(*(actor.Organization.Name)) } if actor.Organization.Email != nil { email = string(*(actor.Organization.Email)) } case "Bot": } // Name is not necessarily set, fallback to login as a name is required in the identity if name == "" { name = string(actor.Login) } i, err = repo.NewIdentityRaw( name, email, string(actor.Login), string(actor.AvatarUrl), nil, map[string]string{ metaKeyGithubLogin: string(actor.Login), }, ) if err != nil { return nil, err } gi.out <- core.NewImportIdentity(i.Id()) return i, nil } func (gi *githubImporter) getGhost(ctx context.Context, repo *cache.RepoCache) (*cache.IdentityCache, error) { loginName := "ghost" // Look first in the cache i, err := repo.ResolveIdentityImmutableMetadata(metaKeyGithubLogin, loginName) if err == nil { return i, nil } if entity.IsErrMultipleMatch(err) { return nil, err } user, err := gi.mediator.User(ctx, loginName) if err != nil { return nil, err } userName := "" if user.Name != nil { userName = string(*user.Name) } return repo.NewIdentityRaw( userName, "", string(user.Login), string(user.AvatarUrl), nil, map[string]string{ metaKeyGithubLogin: string(user.Login), }, ) } // parseId converts the unusable githubv4.ID (an interface{}) into a string func parseId(id githubv4.ID) string { return fmt.Sprintf("%v", id) }