in kubetest/extract_k8s.go [428:581]
func (e extractStrategy) Extract(project, zone, region, ciBucket, releaseBucket string, extractSrc bool) error {
switch e.mode {
case localBazel:
vFile := util.K8s("kubernetes", "bazel-bin", "version")
vByte, err := ioutil.ReadFile(vFile)
if err != nil {
return err
}
version := strings.TrimSpace(string(vByte))
log.Printf("extracting version %v\n", version)
root := util.K8s("kubernetes", "bazel-bin", "build")
src := filepath.Join(root, "release-tars")
dst := filepath.Join(root, version)
log.Printf("copying files from %v to %v\n", src, dst)
if err := os.Rename(src, dst); err != nil {
return err
}
return getKube(fmt.Sprintf("file://%s", root), version, extractSrc)
case local:
url := util.K8s("kubernetes", "_output", "gcs-stage")
files, err := ioutil.ReadDir(url)
if err != nil {
return err
}
var release string
for _, file := range files {
r := file.Name()
if strings.HasPrefix(r, "v") {
release = r
break
}
}
if len(release) == 0 {
return fmt.Errorf("No releases found in %s", url)
}
return getKube(fmt.Sprintf("file://%s", url), release, extractSrc)
case gci, gciCi:
family, gciExtractParams := parseGciExtractOption(e.option)
project := gciExtractParams["project"]
k8sMapBucket := gciExtractParams["k8s-map-bucket"]
if i, err := setupGciVars(family, project); err != nil {
return err
} else if e.ciVersion != "" {
return setReleaseFromGcs(fmt.Sprintf("%s/ci", ciBucket), e.ciVersion, extractSrc)
} else {
return setReleaseFromGci(i, k8sMapBucket, releaseBucket, extractSrc)
}
case gke:
// TODO(fejta): prod v staging v test
if project == "" {
return fmt.Errorf("--gcp-project unset")
}
if e.value == "gke" {
log.Print("*** --extract=gke is deprecated, migrate to --extract=gke-default ***")
}
if strings.HasPrefix(e.option, "latest") {
// get latest supported master version
releasePrefix := ""
if strings.HasPrefix(e.option, "latest-") {
releasePrefix = strings.TrimPrefix(e.option, "latest-")
}
version, err := getLatestGKEVersion(project, zone, region, releasePrefix)
if err != nil {
return fmt.Errorf("failed to get latest gke version: %s", err)
}
return getKube("https://storage.googleapis.com/gke-release-staging/kubernetes/release", version, extractSrc)
}
if strings.HasPrefix(e.option, "channel") {
// get latest supported master version
version, err := getChannelGKEVersion(project, zone, region, e.ciVersion)
if err != nil {
return fmt.Errorf("failed to get gke version from channel %s: %s", e.ciVersion, err)
}
return getKube("https://storage.googleapis.com/gke-release-staging/kubernetes/release", version, extractSrc)
}
// TODO(krzyzacy): clean up gke-default logic
if zone == "" {
return fmt.Errorf("--gcp-zone unset")
}
// get default cluster version for default extract strategy
ci, err := control.Output(exec.Command("gcloud", "container", "get-server-config", fmt.Sprintf("--project=%v", project), fmt.Sprintf("--zone=%v", zone), "--format=value(defaultClusterVersion)"))
if err != nil {
return err
}
re := regexp.MustCompile(`(\d+\.\d+)(\..+)?$`) // 1.11.7-beta.0 -> 1.11
mat := re.FindStringSubmatch(strings.TrimSpace(string(ci)))
if mat == nil {
return fmt.Errorf("failed to parse version from %s", ci)
}
// When JENKINS_USE_SERVER_VERSION=y, we launch the default version as determined
// by GKE, but pull the latest version of that branch for tests. e.g. if the default
// version is 1.5.3, we would pull test binaries at ci/latest-1.5.txt, but launch
// the default (1.5.3). We have to unset CLUSTER_API_VERSION here to allow GKE to
// launch the default.
// TODO(fejta): clean up this logic. Setting/unsetting the same env var is gross.
defer os.Unsetenv("CLUSTER_API_VERSION")
return setReleaseFromGcs(fmt.Sprintf("%s/ci", ciBucket), "latest-"+mat[1], extractSrc)
case ci:
if strings.HasPrefix(e.option, "gke-") {
return setReleaseFromGcs("gke-release-staging/kubernetes/release", e.option, extractSrc)
}
url, release, err := setReleaseFromHTTP(fmt.Sprintf("%s/ci", ciBucket), e.option)
if err != nil {
return err
}
return getKube(url, release, extractSrc)
case ciFast:
// ciFast latest version marker is published to
// '<ciBucket>/ci/<version>-fast.txt' but the actual source
// is at '<ciBucket>/ci/fast/<version>/kubernetes.tar.gz'
url, release, err := setReleaseFromHTTP(fmt.Sprintf("%s/ci", ciBucket), fmt.Sprintf("%s-fast", e.option))
if err != nil {
return err
}
return getKube(fmt.Sprintf("%s/fast", url), release, extractSrc)
case rc, stable:
url, release, err := setReleaseFromHTTP(fmt.Sprintf("%s/release", releaseBucket), e.option)
if err != nil {
return err
}
return getKube(url, release, extractSrc)
case version:
var url string
release := e.option
re := regexp.MustCompile(`(v\d+\.\d+\.\d+-gke.\d+)$`) // v1.8.0-gke.0
if re.FindStringSubmatch(release) != nil {
url = "https://storage.googleapis.com/gke-release-staging/kubernetes/release"
} else if strings.Contains(release, "+") {
url = fmt.Sprintf("https://storage.googleapis.com/%s/ci", ciBucket)
} else {
url = fmt.Sprintf("https://storage.googleapis.com/%s/release", releaseBucket)
}
return getKube(url, release, extractSrc)
case gcs:
// strip gs://foo/bar(.txt) -> foo/bar(.txt)
withoutGS := e.option[5:]
if strings.HasSuffix(e.option, ".txt") {
// foo/bar.txt -> bar
suffix := strings.TrimSuffix(path.Base(withoutGS), filepath.Ext(withoutGS))
return setReleaseFromGcs(path.Dir(withoutGS), suffix, extractSrc)
}
url := "https://storage.googleapis.com" + "/" + path.Dir(withoutGS)
return getKube(url, path.Base(withoutGS), extractSrc)
case load:
return loadState(e.option, extractSrc)
case bazel:
return getKube("", e.option, extractSrc)
}
return fmt.Errorf("Unrecognized extraction: %v(%v)", e.mode, e.value)
}