273 lines
6.2 KiB
Go
273 lines
6.2 KiB
Go
/*
|
|
Copyright 2022 The Kubernetes Authors All rights reserved.
|
|
|
|
Licensed under the Apache License, Version 2.0 (the "License");
|
|
you may not use this file except in compliance with the License.
|
|
You may obtain a copy of the License at
|
|
|
|
http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
Unless required by applicable law or agreed to in writing, software
|
|
distributed under the License is distributed on an "AS IS" BASIS,
|
|
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
See the License for the specific language governing permissions and
|
|
limitations under the License.
|
|
*/
|
|
|
|
package main
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"os"
|
|
)
|
|
|
|
type operatingSystems struct {
|
|
Darwin string `json:"darwin,omitempty"`
|
|
Linux string `json:"linux,omitempty"`
|
|
Windows string `json:"windows,omitempty"`
|
|
}
|
|
|
|
type checksums struct {
|
|
AMD64 *operatingSystems `json:"amd64,omitempty"`
|
|
ARM *operatingSystems `json:"arm,omitempty"`
|
|
ARM64 *operatingSystems `json:"arm64,omitempty"`
|
|
PPC64LE *operatingSystems `json:"ppc64le,omitempty"`
|
|
S390X *operatingSystems `json:"s390x,omitempty"`
|
|
operatingSystems
|
|
}
|
|
|
|
type release struct {
|
|
Checksums checksums `json:"checksums"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
type releases struct {
|
|
Releases []release
|
|
}
|
|
|
|
func (r *releases) UnmarshalJSON(p []byte) error {
|
|
return json.Unmarshal(p, &r.Releases)
|
|
}
|
|
|
|
func main() {
|
|
legacy := flag.Bool("legacy", false, "Updated the releases file using the legacy format")
|
|
releasesFile := flag.String("releases-file", "", "The path to the releases file")
|
|
version := flag.String("version", "", "The version of minikube to create the entry for")
|
|
flag.Parse()
|
|
|
|
if *releasesFile == "" || *version == "" {
|
|
fmt.Println("The releases-file & version flags are required and cannot be empty")
|
|
flag.PrintDefaults()
|
|
os.Exit(1)
|
|
}
|
|
|
|
if *legacy {
|
|
if err := updateReleasesLegacy(*releasesFile, *version); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := updateReleases(*releasesFile, *version); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func updateReleases(releasesFile, version string) error {
|
|
r, err := getReleases(releasesFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
e := createBareRelease(version)
|
|
|
|
shaMap := getSHAMap(&e.Checksums)
|
|
for os, archs := range shaMap {
|
|
for arch, sumVars := range archs {
|
|
sha, err := getSHA(os, arch)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, sumVar := range sumVars {
|
|
*sumVar = sha
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
r.Releases = append([]release{e}, r.Releases...)
|
|
|
|
if err := updateJSON(releasesFile, r); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func getReleases(path string) (releases, error) {
|
|
r := releases{}
|
|
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return r, fmt.Errorf("failed to read in releases file %q: %v", path, err)
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return r, fmt.Errorf("failed to unmarshal releases file: %v", err)
|
|
}
|
|
|
|
return r, nil
|
|
}
|
|
|
|
func createBareRelease(name string) release {
|
|
return release{
|
|
Checksums: checksums{
|
|
AMD64: &operatingSystems{},
|
|
ARM: &operatingSystems{},
|
|
ARM64: &operatingSystems{},
|
|
PPC64LE: &operatingSystems{},
|
|
S390X: &operatingSystems{},
|
|
},
|
|
Name: name,
|
|
}
|
|
}
|
|
|
|
func getSHAMap(c *checksums) map[string]map[string][]*string {
|
|
return map[string]map[string][]*string{
|
|
"darwin": {
|
|
"amd64": {&c.AMD64.Darwin, &c.Darwin},
|
|
"arm64": {&c.ARM64.Darwin},
|
|
},
|
|
"linux": {
|
|
"amd64": {&c.AMD64.Linux, &c.Linux},
|
|
"arm": {&c.ARM.Linux},
|
|
"arm64": {&c.ARM64.Linux},
|
|
"ppc64le": {&c.PPC64LE.Linux},
|
|
"s390x": {&c.S390X.Linux},
|
|
},
|
|
"windows": {
|
|
"amd64": {&c.AMD64.Windows, &c.Windows},
|
|
},
|
|
}
|
|
}
|
|
|
|
func getSHA(operatingSystem, arch string) (string, error) {
|
|
if operatingSystem == "windows" {
|
|
arch += ".exe"
|
|
}
|
|
filePath := fmt.Sprintf("out/minikube-%s-%s.sha256", operatingSystem, arch)
|
|
b, err := os.ReadFile(filePath)
|
|
if err != nil {
|
|
return "", fmt.Errorf("failed to read file %q: %v", filePath, err)
|
|
}
|
|
// trim off new line character
|
|
sha := string(b[:len(b)-1])
|
|
fmt.Printf("%s-%s: `%s`\n", operatingSystem, arch, sha)
|
|
return sha, nil
|
|
}
|
|
|
|
func updateJSON(path string, r releases) error {
|
|
b, err := json.MarshalIndent(r.Releases, "", " ")
|
|
if err != nil {
|
|
return fmt.Errorf("failed to marshal releases to JSON: %v", err)
|
|
}
|
|
|
|
if err := os.WriteFile(path, b, 0644); err != nil {
|
|
return fmt.Errorf("failed to write JSON to file: %v", err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type releaseLegacy struct {
|
|
Checksums *operatingSystems `json:"checksums,omitempty"`
|
|
Name string `json:"name"`
|
|
}
|
|
|
|
type releasesLegacy struct {
|
|
Releases []releaseLegacy
|
|
}
|
|
|
|
func (r *releasesLegacy) UnmarshalJSON(p []byte) error {
|
|
return json.Unmarshal(p, &r.Releases)
|
|
}
|
|
|
|
func updateReleasesLegacy(releasesFile, version string) error {
|
|
r, err := getReleasesLegacy(releasesFile)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
e := createBareReleaseLegacy(version)
|
|
|
|
shaMap := getSHAMapLegacy(e.Checksums)
|
|
for os, archs := range shaMap {
|
|
for arch, sumVars := range archs {
|
|
sha, err := getSHA(os, arch)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, sumVar := range sumVars {
|
|
*sumVar = sha
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
r.Releases = append([]releaseLegacy{e}, r.Releases...)
|
|
|
|
if err := updateJSONLegacy(releasesFile, r); err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func getReleasesLegacy(path string) (releasesLegacy, error) {
|
|
r := releasesLegacy{}
|
|
|
|
b, err := os.ReadFile(path)
|
|
if err != nil {
|
|
return r, fmt.Errorf("failed to read in releases file %q: %v", path, err)
|
|
}
|
|
|
|
if err := json.Unmarshal(b, &r); err != nil {
|
|
return r, fmt.Errorf("failed to unmarshal releases file: %v", err)
|
|
}
|
|
|
|
return r, nil
|
|
}
|
|
|
|
func createBareReleaseLegacy(name string) releaseLegacy {
|
|
return releaseLegacy{
|
|
Checksums: &operatingSystems{},
|
|
Name: name,
|
|
}
|
|
}
|
|
|
|
func getSHAMapLegacy(c *operatingSystems) map[string]map[string][]*string {
|
|
return map[string]map[string][]*string{
|
|
"darwin": {
|
|
"amd64": {&c.Darwin},
|
|
},
|
|
"linux": {
|
|
"amd64": {&c.Linux},
|
|
},
|
|
"windows": {
|
|
"amd64": {&c.Windows},
|
|
},
|
|
}
|
|
}
|
|
|
|
func updateJSONLegacy(path string, r releasesLegacy) error {
|
|
b, err := json.MarshalIndent(r.Releases, "", " ")
|
|
if err != nil {
|
|
return fmt.Errorf("failed to marshal releases to JSON: %v", err)
|
|
}
|
|
|
|
if err := os.WriteFile(path, b, 0644); err != nil {
|
|
return fmt.Errorf("failed to write JSON to file: %v", err)
|
|
}
|
|
return nil
|
|
}
|