"regexp"
"sort"
"strconv"
+ "sync"
"time"
"git.arvados.org/arvados-dev.git/lib/redmine"
}
issuesCmd.AddCommand(associateIssueCmd)
+
+ setIssueSprintCmd.Flags().IntP("sprint", "r", 0, "Redmine sprint ID")
+ err = setIssueSprintCmd.MarkFlagRequired("sprint")
+ if err != nil {
+ log.Fatalf(err.Error())
+ }
+ setIssueSprintCmd.Flags().IntP("issue", "i", 0, "Redmine issue ID")
+ err = setIssueSprintCmd.MarkFlagRequired("issue")
+ if err != nil {
+ log.Fatalf(err.Error())
+ }
+ issuesCmd.AddCommand(setIssueSprintCmd)
+
+ associateOrphans.Flags().IntP("release", "r", 0, "Redmine release ID")
+ err = associateOrphans.MarkFlagRequired("release")
+ if err != nil {
+ log.Fatalf(err.Error())
+ }
+ associateOrphans.Flags().StringP("project", "p", "", "Redmine project name")
+ err = associateOrphans.MarkFlagRequired("project")
+ if err != nil {
+ log.Fatalf(err.Error())
+ }
+ associateOrphans.Flags().BoolP("dry-run", "", false, "Only report what will happen without making any change")
+ issuesCmd.AddCommand(associateOrphans)
+
findAndAssociateIssuesCmd.Flags().IntP("release", "r", 0, "Redmine release ID")
err = findAndAssociateIssuesCmd.MarkFlagRequired("release")
if err != nil {
}
findAndAssociateIssuesCmd.Flags().BoolP("auto-set", "a", false, "Associate issues without existing release without prompting")
findAndAssociateIssuesCmd.Flags().BoolP("skip-release-change", "s", false, "Skip issues already assigned to another release (do not prompt)")
+ findAndAssociateIssuesCmd.Flags().StringP("source-repo", "", "https://github.com/arvados/arvados.git", "Source repository to clone from")
+ if err != nil {
+ log.Fatalf(err.Error())
+ }
+
issuesCmd.AddCommand(findAndAssociateIssuesCmd)
createReleaseIssueCmd.Flags().StringP("new-release-version", "n", "", "Semantic version number of the new release")
"\nThe REDMINE_APIKEY environment variable must be set to your redmine API key.",
}
+var associateOrphans = &cobra.Command{
+ Use: "associate-orphans", // FIXME
+ Short: "Find open issues without a release and version, assign them to the given release",
+ Long: "Find open issues without a release and version, assign them to the given release.\n" +
+ "\nThe REDMINE_ENDPOINT environment variable must be set to the base URL of your redmine server." +
+ "\nThe REDMINE_APIKEY environment variable must be set to your redmine API key.",
+ Run: func(cmd *cobra.Command, args []string) {
+ rID, err := cmd.Flags().GetInt("release")
+ if err != nil {
+ fmt.Printf("Error converting Redmine release ID to integer: %s", err)
+ os.Exit(1)
+ }
+ pName, err := cmd.Flags().GetString("project")
+ if err != nil {
+ log.Fatalf("Error getting the requested project name: %s", err)
+ }
+ dryRun, err := cmd.Flags().GetBool("dry-run")
+ if err != nil {
+ log.Fatalf("Error getting the dry-run parameter")
+ }
+
+ rm := redmine.NewClient(conf.Endpoint, conf.Apikey)
+ p, err := rm.GetProjectByName(pName)
+ if err != nil {
+ log.Fatalf("Error retrieving project ID for '%s': %s", pName, err)
+ }
+ r, err := rm.GetRelease(rID)
+ if err != nil {
+ log.Fatalf("Error retrieving release '%d': %s", rID, err)
+ }
+ flt := redmine.IssueFilter{
+ StatusID: "open",
+ ProjectID: fmt.Sprintf("%d", p.ID),
+ // No values assigned on the following fields. It seems that using
+ // an empty string is interpreted as 'any value'. The documentation
+ // isn't clear, but after some trial & error, '!*' seems to do the trick.
+ // https://www.redmine.org/projects/redmine/wiki/Rest_Issues
+ ReleaseID: "!*",
+ VersionID: "!*",
+ ParentID: "!*",
+ }
+ issues, err := rm.FilteredIssues(&flt)
+ if err != nil {
+ fmt.Printf("Error requesting unassigned open issues from project %d: %s", p.ID, err)
+ }
+ fmt.Printf("Found %d issues from project '%s' to assign to release '%s'...\n", len(issues), p.Name, r.Name)
+
+ type job struct {
+ issue redmine.Issue
+ rID int
+ dryRun bool
+ }
+ type result struct {
+ msg string
+ success bool
+ }
+ var wg sync.WaitGroup
+ jobs := make(chan job, len(issues))
+ results := make(chan result, len(issues))
+
+ worker := func(id int, jobs <-chan job, results chan<- result) {
+ for j := range jobs {
+ msg := fmt.Sprintf("#%d - %s ", j.issue.ID, j.issue.Subject)
+ success := true
+ if !j.dryRun {
+ err = rm.SetRelease(j.issue, j.rID)
+ if err != nil {
+ success = false
+ msg = fmt.Sprintf("%s [error] (%s)\n", msg, err)
+ } else {
+ msg = fmt.Sprintf("%s [changed]\n", msg)
+ }
+ } else {
+ msg = fmt.Sprintf("%s [skipped]\n", msg)
+ }
+ results <- result{
+ msg: msg,
+ success: success,
+ }
+ }
+ }
+
+ wn := 8
+ if len(issues) < wn {
+ wn = len(issues)
+ }
+ for w := 1; w <= wn; w++ {
+ wg.Add(1)
+ w := w
+ go func() {
+ defer wg.Done()
+ worker(w, jobs, results)
+ }()
+ }
+
+ for _, issue := range issues {
+ jobs <- job{
+ issue: issue,
+ rID: rID,
+ dryRun: dryRun,
+ }
+ }
+ close(jobs)
+
+ succeded := true
+ errCount := 0
+ var wg2 sync.WaitGroup
+ wg2.Add(1)
+ go func() {
+ defer wg2.Done()
+ for r := range results {
+ fmt.Printf(r.msg)
+ if !r.success {
+ succeded = false
+ errCount += 1
+ }
+ }
+ }()
+
+ wg.Wait()
+ close(results)
+ wg2.Wait()
+ if !succeded {
+ log.Fatalf("Warning: %d error(s) found.", errCount)
+ }
+ },
+}
+
var associateIssueCmd = &cobra.Command{
Use: "associate",
Short: "Associate an issue with a release",
},
}
+
+var setIssueSprintCmd = &cobra.Command{
+ Use: "set-sprint",
+ Short: "Set sprint for issue",
+ Long: "Set the sprint for an issue.\n" +
+ "\nThe REDMINE_ENDPOINT environment variable must be set to the base URL of your redmine server." +
+ "\nThe REDMINE_APIKEY environment variable must be set to your redmine API key.",
+ Run: func(cmd *cobra.Command, args []string) {
+ issueID, err := cmd.Flags().GetInt("issue")
+ if err != nil {
+ fmt.Printf("Error converting Redmine issue ID to integer: %s", err)
+ os.Exit(1)
+ }
+
+ sprintID, err := cmd.Flags().GetInt("sprint")
+ if err != nil {
+ fmt.Printf("Error converting Redmine sprint ID to integer: %s", err)
+ os.Exit(1)
+ }
+
+ redmine := redmine.NewClient(conf.Endpoint, conf.Apikey)
+
+ i, err := redmine.GetIssue(issueID)
+ if err != nil {
+ fmt.Printf("%s\n", err.Error())
+ os.Exit(1)
+ }
+
+ var setIt bool
+ if i.FixedVersion == nil {
+ setIt = true
+ } else if i.FixedVersion.ID != sprintID {
+ setIt = true
+ }
+ if setIt {
+ err = redmine.SetSprint(*i, sprintID)
+ if err != nil {
+ fmt.Printf("%s\n", err.Error())
+ os.Exit(1)
+ } else {
+ fmt.Printf("[changed] sprint for issue %d set to %d\n", i.ID, sprintID)
+ }
+ } else {
+ fmt.Printf("[ok] sprint for issue %d was already set to %d, not updating\n", i.ID, i.FixedVersion.ID)
+ }
+ },
+}
+
func checkError(err error) {
if err != nil {
fmt.Printf("%s\n", err.Error())
}
}
+func checkError2(msg string, err error) {
+ if err != nil {
+ fmt.Printf("%s: %s\n", msg, err.Error())
+ os.Exit(1)
+ }
+}
+
var findAndAssociateIssuesCmd = &cobra.Command{
Use: "find-and-associate",
Short: "Find all issue numbers to associate with a release, and associate them",
log.Fatal(fmt.Errorf("Error getting skip-release-change value: %s", err))
return
}
+ arvRepo, err := cmd.Flags().GetString("source-repo")
+ if err != nil {
+ log.Fatal(fmt.Errorf("Error getting source-repo value: %s", err))
+ return
+ }
if len(previousReleaseTag) < 5 || len(previousReleaseTag) > 8 {
log.Fatal(fmt.Errorf("The previous-release-tag argument is of an unexpected format. Expecting a semantic version (e.g. 2.3.0)"))
}
// Clone the repo in memory
- fmt.Println("Cloning https://github.com/arvados/arvados.git")
+
+ // our own arvados repo won't clone,
+ //arvRepo := "https://git.arvados.org/arvados.git"
+ //arvRepo := "https://github.com/arvados/arvados.git"
+
+ fmt.Println("Cloning " + arvRepo)
repo, err := git.Clone(memory.NewStorage(), nil, &git.CloneOptions{
- URL: "https://github.com/arvados/arvados.git",
+ URL: arvRepo,
})
checkError(err)
fmt.Println("... done")
fmt.Println()
start, err := repo.ResolveRevision(plumbing.Revision("refs/tags/" + previousReleaseTag))
- checkError(err)
+ checkError2("repo.ResolveRevision", err)
fmt.Printf("previous-release-tag: %s (%s)\n", previousReleaseTag, start)
fmt.Printf("new-release-commit: %s\n", newReleaseCommitHash)
fmt.Println()
// Build the exclusion list
seen := make(map[plumbing.Hash]bool)
excludeIter, err := repo.Log(&git.LogOptions{From: *start, Order: git.LogOrderCommitterTime})
- checkError(err)
+ checkError2("repo.Log", err)
excludeIter.ForEach(func(c *object.Commit) error {
seen[c.Hash] = true
return nil
}
headCommit, err := repo.CommitObject(plumbing.NewHash(newReleaseCommitHash))
- checkError(err)
+ checkError2("repo.CommitObject", err)
iter := object.NewFilterCommitIter(headCommit, &isValid, nil)
- issues := make(map[int]bool)
+ issues := make(map[int]string)
re := regexp.MustCompile(`Merge branch `)
reNotMain := regexp.MustCompile(`Merge branch .(main|master)`)
reIssueRef := regexp.MustCompile(`(Closes|closes|Refs|refs|Fixes|fixes) #(\d+)`)
if err != nil {
checkError(err)
}
- issues[i] = true
+ issues[i] = fmt.Sprintf("%s: %s", c.Hash, c.Message)
}
}
continue
}
fmt.Println(i.Subject)
+ fmt.Println(issues[k])
if i.Release != nil && i.Release["release"].ID != 0 {
if i.Release["release"].ID == releaseID {
projects / arvados-dev.git / blobdiff