Find new versions by parsing json

cmd/builder-bumper/main.go

@@ -16,6 +16,7 @@ package main
 
 import (
  "bufio"
+ "encoding/json"
  "flag"
  "fmt"
  "io"
@@ -46,6 +47,10 @@ type goVersion struct {
  minor int
 }
 
+type VersionInfo struct {
+ Version string `json:"version"`
+}
+
 func newGoVersion(v string) *goVersion {
  c := semver.Canonical("v" + v)
  if c == "" {
@@ -101,6 +106,47 @@ func (g *goVersion) url() string {
  return fmt.Sprintf("https://dl.google.com/go/go%s.linux-amd64.tar.gz", g.golangVersion())
 }
 
+func fetchJSON(url string) ([]byte, error) {
+ resp, err := http.Get(url)
+ if err != nil {
+ return nil, err
+ }
+ defer resp.Body.Close()
+
+ if resp.StatusCode != http.StatusOK {
+ return nil, fmt.Errorf("unexpected status code: %d", resp.StatusCode)
+ }
+
+ body, err := io.ReadAll(resp.Body)
+ if err != nil {
+ return nil, err
+ }
+
+ return body, nil
+}
+
+func availableVersions() []goVersion {
+
+ const url = "https://go.dev/dl/?mode=json"
+
+ jsonData, err := fetchJSON(url)
+ if err != nil {
+ fmt.Println("Error fetching JSON:", err)
+ }
+
+ var availableVersionsJSON []VersionInfo
+ var availableVersions []goVersion
+ if err := json.Unmarshal(jsonData, &availableVersionsJSON); err != nil {
+ fmt.Println("Error parsing JSON:", err)
+ }
+ for i := range availableVersionsJSON {
+ // remove "go" from a string like "go1.22.0"
+ newGoVersion := newGoVersion(strings.TrimLeft("go", availableVersionsJSON[i].Version))
+ availableVersions = append(availableVersions, *newGoVersion)
+ }
+ return availableVersions
+}
+
 // getSHA256 returns the SHA256 of the Go archive.
 func (g *goVersion) getSHA256() (string, error) {
  resp, err := http.Get(g.url() + ".sha256")
@@ -116,40 +162,34 @@ func (g *goVersion) getSHA256() (string, error) {
 }
 
 // getLastMinorVersion returns the last minor version for a given Go version.
-func (g *goVersion) getLastMinorVersion() (*goVersion, error) {
+// if no new minor version available, it will return the given Go version back.
+func (g *goVersion) getLastMinorVersion(availableVersions []goVersion) *goVersion {
  last := *g
- for {
- next := last
+ next := last
+ // let's check max 40 minor revisions for now before giving up
+ for next.minor < 40 {
  next.minor++
- resp, err := http.Head(next.url())
- if err != nil {
- return nil, err
- }
- defer resp.Body.Close()
-
- if resp.StatusCode/100 != 2 {
- return &last, nil
+ for _, availableVersion := range availableVersions {
+ if next == availableVersion {
+ return &next
+ }
  }
- last = next
  }
+ return &last
 }
 
 // getNextMajor returns the next Go major version for a given Go version.
 // It returns nil if the current version is already the latest.
-func (g *goVersion) getNextMajor() *goVersion {
+func (g *goVersion) getNextMajor(availableVersions []goVersion) *goVersion {
  version := newGoVersion(g.Major() + ".0")
  version.major++
 
- resp, err := http.Head(version.url())
- if err != nil {
- return nil
- }
- defer resp.Body.Close()
- if resp.StatusCode/100 != 2 {
- return nil
+ for _, availableVersion := range availableVersions {
+ if version.major == availableVersion.major {
+ return version
+ }
  }
-
- return version
+ return nil
 }
 
 // getExactVersionFromDir reads the current Go version from a directory.
@@ -301,10 +341,8 @@ func updateNextMinor(dir string) (*goVersion, error) {
  return nil, fmt.Errorf("failed to detect current version of %s: %w", dir, err)
  }
 
- next, err := current.getLastMinorVersion()
- if err != nil {
- return nil, err
- }
+ next := current.getLastMinorVersion(availableVersions())
+
  if next.equal(current) {
  log.Printf("no version change for Go %s", next.golangVersion())
  return nil, nil
@@ -374,9 +412,12 @@ func run() error {
  return fmt.Errorf("Expected 2 versions of Go but got %d\n", len(dirs))
  }
 
+ // Get list of available versions
+ availableVersions := availableVersions()
+
  // Check if a new major Go version exists.
  nexts := make([]*goVersion, 0)
- if next := newGoVersion(dirs[1] + ".0").getNextMajor(); next != nil {
+ if next := newGoVersion(dirs[1] + ".0").getNextMajor(availableVersions); next != nil {
  log.Printf("found a new major version of Go: %s", next)
  old, err := getExactVersionFromDir(dirs[0])
  if err != nil {