示例#1
0
func (r *release) prepareForApiCalls() (client *github.Client, owner, repo string, err error) {
	if r.client == nil {
		r.client = ghutil.NewClient(r.tool.config.Token)
	}

	if r.owner == "" || r.repo == "" {
		var err error
		r.owner, r.repo, err = ghutil.ParseUpstreamURL()
		if err != nil {
			return nil, "", "", err
		}
	}

	return r.client, r.owner, r.repo, nil
}
示例#2
0
func loadConfig() (*moduleConfig, error) {
	task := fmt.Sprintf("Load config for module '%v'", ModuleId)

	// Load the config.
	spec := newConfigSpec()
	if err := loader.LoadConfig(spec); err != nil {
		return nil, errs.NewError(task, err)
	}

	// Parse the main repo upstream URL.
	owner, repo, err := github.ParseUpstreamURL()
	if err != nil {
		return nil, errs.NewError(task, err)
	}

	// Assemble the config object.
	var (
		local  = spec.local
		global = spec.global
	)
	return &moduleConfig{
		GitHubOwner:           owner,
		GitHubRepository:      repo,
		UserToken:             global.UserToken,
		StoryLabels:           local.StoryLabels,
		ApprovedLabel:         local.StateLabels.ApprovedLabel,
		BeingImplementedLabel: local.StateLabels.BeingImplementedLabel,
		ImplementedLabel:      local.StateLabels.ImplementedLabel,
		ReviewedLabel:         local.StateLabels.ReviewedLabel,
		SkipReviewLabel:       local.StateLabels.SkipReviewLabel,
		PassedTestingLabel:    local.StateLabels.PassedTestingLabel,
		FailedTestingLabel:    local.StateLabels.FailedTestingLabel,
		SkipTestingLabel:      local.StateLabels.SkipTestingLabel,
		StagedLabel:           local.StateLabels.StagedLabel,
		RejectedLabel:         local.StateLabels.RejectedLabel,
		SkipCheckLabels:       local.SkipCheckLabels,
	}, nil
}
示例#3
0
func (tool *codeReviewTool) PostReviewRequests(
	ctxs []*common.ReviewContext,
	opts map[string]interface{},
) (err error) {

	// Get the GitHub owner and repository from the upstream URL.
	owner, repo, err := ghutil.ParseUpstreamURL()
	if err != nil {
		return err
	}

	// Group commits by story ID.
	//
	// In case the commit is associated with a story, we add it to the relevant story group.
	// Otherwise the commit is marked as unassigned and added to the relevant list.
	var (
		ctxsByStoryId     = make(map[string][]*common.ReviewContext, 1)
		unassignedCommits = make([]*git.Commit, 0, 1)
	)
	for _, ctx := range ctxs {
		story := ctx.Story
		if story != nil {
			sid := story.ReadableId()
			rcs, ok := ctxsByStoryId[sid]
			if ok {
				rcs = append(rcs, ctx)
			} else {
				rcs = []*common.ReviewContext{ctx}
			}
			ctxsByStoryId[sid] = rcs
		} else {
			unassignedCommits = append(unassignedCommits, ctx.Commit)
		}
	}

	// Post the assigned commits.
	_, open := opts["open"]
	for _, ctxs := range ctxsByStoryId {
		var (
			story   = ctxs[0].Story
			commits = make([]*git.Commit, 0, len(ctxs))
		)
		for _, ctx := range ctxs {
			commits = append(commits, ctx.Commit)
		}
		// Create/update the review issue.
		issue, postedCommits, ex := postAssignedReviewRequest(
			tool.config, owner, repo, story, commits, opts)
		if ex != nil {
			errs.Log(ex)
			err = errPostReviewRequest
			continue
		}

		// Add comments to the commits posted for review.
		linkCommitsToReviewIssue(tool.config, owner, repo, *issue.Number, postedCommits)

		// Open the review issue in the browser if requested.
		if open {
			openIssue(issue)
		}
	}

	// Get the value of -fixes.
	var fixes int
	flagFixes, ok := opts["fixes"]
	if ok {
		if v, ok := flagFixes.(uint); ok && v != 0 {
			fixes = int(v)
		}
	}

	// Post the unassigned commits.
	for _, commit := range unassignedCommits {
		var (
			issue         *github.Issue
			postedCommits []*git.Commit
			ex            error
		)
		if fixes != 0 {
			// Extend the specified review issue.
			issue, postedCommits, ex = extendUnassignedReviewRequest(
				tool.config, owner, repo, fixes, commit, opts)
		} else {
			// Create/update the review issue.
			issue, postedCommits, ex = postUnassignedReviewRequest(
				tool.config, owner, repo, commit, opts)
		}
		if ex != nil {
			errs.Log(ex)
			err = errPostReviewRequest
			continue
		}

		// Add comments to the commits posted for review.
		linkCommitsToReviewIssue(tool.config, owner, repo, *issue.Number, postedCommits)

		// Open the review issue in the browser if requested.
		if open {
			openIssue(issue)
		}
	}

	return
}
func (manager *releaseNotesManager) PostReleaseNotes(
	releaseNotes *common.ReleaseNotes,
) (action.Action, error) {

	// Get the GitHub owner and repository from the upstream URL.
	owner, repo, err := github.ParseUpstreamURL()
	if err != nil {
		return nil, err
	}

	// Instantiate the API client.
	client := github.NewClient(manager.config.Token)

	// Format the release notes.
	task := "Format the release notes"
	body := bytes.NewBufferString(`
## Summary ##

**PLEASE FILL IN THE RELEASE SUMMARY**
`)
	encoder, err := notes.NewEncoder(notes.EncodingMarkdown, body)
	if err != nil {
		return nil, errs.NewError(task, err)
	}
	if err := encoder.Encode(releaseNotes, nil); err != nil {
		return nil, errs.NewError(task, err)
	}
	bodyString := body.String()

	// Create GitHub release for the given version.
	tag := releaseNotes.Version.ReleaseTagString()
	releaseTask := fmt.Sprintf("Create GitHub release for tag '%v'", tag)
	log.Run(releaseTask)
	release, _, err := client.Repositories.CreateRelease(owner, repo, &gh.RepositoryRelease{
		TagName: gh.String(tag),
		Name:    gh.String("Release " + releaseNotes.Version.BaseString()),
		Body:    &bodyString,
		Draft:   gh.Bool(true),
	})
	if err != nil {
		return nil, err
	}

	// Delete the GitHub release on rollback.
	rollback := func() error {
		log.Rollback(releaseTask)
		task := fmt.Sprintf("Delete GitHub release for tag '%v'", tag)
		_, err := client.Repositories.DeleteRelease(owner, repo, *release.ID)
		if err != nil {
			return errs.NewError(task, err)
		}
		return nil
	}

	// Open the release in the browser so that the user can fill in the details.
	task = "Open the release notes in the browser"
	if err := webbrowser.Open(*release.HTMLURL); err != nil {
		if ex := rollback(); ex != nil {
			errs.Log(ex)
		}
		return nil, errs.NewError(task, err)
	}

	// Return the rollback function.
	return action.ActionFunc(rollback), nil
}