Revert "Use native Ginkgo test runner instead of cmd/e2e (attempt N)"

cmd/e2e/e2e.go

@@ -0,0 +1,88 @@
+/*
+Copyright 2015 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 (
+	"fmt"
+	"os"
+	goruntime "runtime"
+	"strings"
+
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/client/clientcmd"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/cloudprovider"
+	"github.com/GoogleCloudPlatform/kubernetes/pkg/util"
+	"github.com/GoogleCloudPlatform/kubernetes/test/e2e"
+	"github.com/golang/glog"
+	flag "github.com/spf13/pflag"
+)
+
+var (
+	context     = &e2e.TestContextType{}
+	cloudConfig = &context.CloudConfig
+
+	orderseed = flag.Int64("orderseed", 0, "If non-zero, seed of random test shuffle order. (Otherwise random.)")
+	reportDir = flag.String("report-dir", "", "Path to the directory where the JUnit XML reports should be saved. Default is empty, which doesn't generate these reports.")
+	times     = flag.Int("times", 1, "Number of times each test is eligible to be run. Individual order is determined by shuffling --times instances of each test using --orderseed (like a multi-deck shoe of cards).")
+	testList  util.StringList
+)
+
+func init() {
+	flag.VarP(&testList, "test", "t", "Test to execute (may be repeated or comma separated list of tests.) Defaults to running all tests.")
+
+	flag.StringVar(&context.KubeConfig, clientcmd.RecommendedConfigPathFlag, "", "Path to kubeconfig containing embeded authinfo.")
+	flag.StringVar(&context.KubeContext, clientcmd.FlagContext, "", "kubeconfig context to use/override. If unset, will use value from 'current-context'")
+	flag.StringVar(&context.CertDir, "cert-dir", "", "Path to the directory containing the certs. Default is empty, which doesn't use certs.")
+	flag.StringVar(&context.Host, "host", "", "The host, or apiserver, to connect to")
+	flag.StringVar(&context.RepoRoot, "repo-root", "./", "Root directory of kubernetes repository, for finding test files. Default assumes working directory is repository root")
+	flag.StringVar(&context.Provider, "provider", "", "The name of the Kubernetes provider (gce, gke, local, vagrant, etc.)")
+
+	// TODO: Flags per provider?  Rename gce_project/gce_zone?
+	flag.StringVar(&cloudConfig.MasterName, "kube-master", "", "Name of the kubernetes master. Only required if provider is gce or gke")
+	flag.StringVar(&cloudConfig.ProjectID, "gce-project", "", "The GCE project being used, if applicable")
+	flag.StringVar(&cloudConfig.Zone, "gce-zone", "", "GCE zone being used, if applicable")
+}
+
+func main() {
+	util.InitFlags()
+	goruntime.GOMAXPROCS(goruntime.NumCPU())
+	if context.Provider == "" {
+		glog.Info("The --provider flag is not set.  Treating as a conformance test.  Some tests may not be run.")
+		os.Exit(1)
+	}
+	if *times <= 0 {
+		glog.Error("Invalid --times (negative or no testing requested)!")
+		os.Exit(1)
+	}
+
+	if context.Provider == "aws" {
+		awsConfig := "[Global]\n"
+		if cloudConfig.Zone == "" {
+			glog.Error("--gce-zone must be specified for AWS")
+			os.Exit(1)
+		}
+		awsConfig += fmt.Sprintf("Zone=%s\n", cloudConfig.Zone)
+
+		var err error
+		cloudConfig.Provider, err = cloudprovider.GetCloudProvider(context.Provider, strings.NewReader(awsConfig))
+		if err != nil {
+			glog.Error("Error building AWS provider: ", err)
+			os.Exit(1)
+		}
+	}
+
+	e2e.RunE2ETests(context, *orderseed, *times, *reportDir, testList)
+}

hack/ginkgo-e2e.sh

@@ -18,18 +18,54 @@ set -o errexit
 set -o nounset
 set -o pipefail
 
-GINKGO_PARALLEL=${GINKGO_PARALLEL:-n} # set to 'y' to run tests in parallel
 KUBE_ROOT=$(dirname "${BASH_SOURCE}")/..
-
 source "${KUBE_ROOT}/cluster/common.sh"
-source "${KUBE_ROOT}/hack/lib/init.sh"
 
-# Ginkgo will build the e2e tests, so we need to make sure that the environment
-# is set up correctly (including Godeps, etc).
-kube::golang::setup_env
-# Find the ginkgo binary build as part of the release.
-ginkgo=$(kube::util::find-binary "ginkgo")
-e2e_test=$(kube::util::find-binary "e2e.test")
+# --- Find local test binaries.
+
+# Detect the OS name/arch so that we can find our binary
+case "$(uname -s)" in
+  Darwin)
+    host_os=darwin
+    ;;
+  Linux)
+    host_os=linux
+    ;;
+  *)
+    echo "Unsupported host OS.  Must be Linux or Mac OS X." >&2
+    exit 1
+    ;;
+esac
+
+case "$(uname -m)" in
+  x86_64*)
+    host_arch=amd64
+    ;;
+  i?86_64*)
+    host_arch=amd64
+    ;;
+  amd64*)
+    host_arch=amd64
+    ;;
+  arm*)
+    host_arch=arm
+    ;;
+  i?86*)
+    host_arch=x86
+    ;;
+  *)
+    echo "Unsupported host arch. Must be x86_64, 386 or arm." >&2
+    exit 1
+    ;;
+esac
+
+# Gather up the list of likely places and use ls to find the latest one.
+locations=(
+  "${KUBE_ROOT}/_output/dockerized/bin/${host_os}/${host_arch}/e2e"
+  "${KUBE_ROOT}/_output/local/bin/${host_os}/${host_arch}/e2e"
+  "${KUBE_ROOT}/platforms/${host_os}/${host_arch}/e2e"
+)
+e2e=$( (ls -t "${locations[@]}" 2>/dev/null || true) | head -1 )
 
 # --- Setup some env vars.
 
@@ -53,8 +89,8 @@ if [[ -z "${AUTH_CONFIG:-}" ]];  then
 
     if [[ "${KUBERNETES_PROVIDER}" == "conformance_test" ]]; then
       auth_config=(
-        "--auth-config=${KUBERNETES_CONFORMANCE_TEST_AUTH_CONFIG:-}"
-        "--cert-dir=${KUBERNETES_CONFORMANCE_TEST_CERT_DIR:-}"
+        "--auth_config=${KUBERNETES_CONFORMANCE_TEST_AUTH_CONFIG:-}"
+        "--cert_dir=${KUBERNETES_CONFORMANCE_TEST_CERT_DIR:-}"
       )
     else
       auth_config=(
@@ -72,26 +108,21 @@ else
   echo "Conformance Test.  No cloud-provider-specific preparation."
   KUBERNETES_PROVIDER=""
   auth_config=(
-    "--auth-config=${AUTH_CONFIG:-}"
-    "--cert-dir=${CERT_DIR:-}"
+    "--auth_config=${AUTH_CONFIG:-}"
+    "--cert_dir=${CERT_DIR:-}"
   )
 fi
 
-ginkgo_args=()
-if [[ ${GINKGO_PARALLEL} =~ ^[yY]$ ]]; then
-  ginkgo_args+=("-p")
-fi
-
+# Use the kubectl binary from the same directory as the e2e binary.
 # The --host setting is used only when providing --auth_config
 # If --kubeconfig is used, the host to use is retrieved from the .kubeconfig
 # file and the one provided with --host is ignored.
-"${ginkgo}" "${ginkgo_args[@]:+${ginkgo_args[@]}}" "${e2e_test}" -- \
-  "${auth_config[@]:+${auth_config[@]}}" \
+export PATH=$(dirname "${e2e}"):"${PATH}"
+"${e2e}" "${auth_config[@]:+${auth_config[@]}}" \
   --host="https://${KUBE_MASTER_IP-}" \
   --provider="${KUBERNETES_PROVIDER}" \
-  --gce-project="${PROJECT:-}" \
-  --gce-zone="${ZONE:-}" \
-  --kube-master="${KUBE_MASTER:-}" \
-  --repo-root="${KUBE_VERSION_ROOT}" \
-  ${E2E_REPORT_DIR+"--report-dir=${E2E_REPORT_DIR}"} \
+  --gce_project="${PROJECT:-}" \
+  --gce_zone="${ZONE:-}" \
+  --kube_master="${KUBE_MASTER:-}" \
+  ${E2E_REPORT_DIR+"--report_dir=${E2E_REPORT_DIR}"} \
   "${@:-}"

hack/lib/golang.sh

@@ -44,13 +44,13 @@ readonly KUBE_CLIENT_BINARIES_WIN=("${KUBE_CLIENT_BINARIES[@]/%/.exe}")
 
 # The set of test targets that we are building for all platforms
 readonly KUBE_TEST_TARGETS=(
+  cmd/e2e
   cmd/integration
   cmd/gendocs
   cmd/genman
   cmd/genbashcomp
   examples/k8petstore/web-server
   github.com/onsi/ginkgo/ginkgo
-  test/e2e/e2e.test
 )
 readonly KUBE_TEST_BINARIES=("${KUBE_TEST_TARGETS[@]##*/}")
 readonly KUBE_TEST_BINARIES_WIN=("${KUBE_TEST_BINARIES[@]/%/.exe}")
@@ -289,33 +289,14 @@ kube::golang::fallback_if_stdlib_not_installable() {
   use_go_build=true
 }
 
-# Try and replicate the native binary placement of go install without
-# calling go install.
-kube::golang::output_filename_for_binary() {
-  local binary=$1
-  local platform=$2
-  local output_path="${KUBE_GOPATH}/bin"
-  if [[ $platform != $host_platform ]]; then
-    output_path="${output_path}/${platform//\//_}"
-  fi
-  local bin=$(basename "${binary}")
-  if [[ ${GOOS} == "windows" ]]; then
-    bin="${bin}.exe"
-  fi
-  echo "${output_path}/${bin}"
-}
-
 kube::golang::build_binaries_for_platform() {
   local platform=$1
   local use_go_build=${2-}
 
   local -a statics=()
   local -a nonstatics=()
-  local -a tests=()
   for binary in "${binaries[@]}"; do
-    if [[ "${binary}" =~ ".test"$ ]]; then
-      tests+=($binary)
-    elif kube::golang::is_statically_linked_library "${binary}"; then
+    if kube::golang::is_statically_linked_library "${binary}"; then
       statics+=($binary)
     else
       nonstatics+=($binary)
@@ -326,17 +307,27 @@ kube::golang::build_binaries_for_platform() {
   fi
 
   if [[ -n ${use_go_build:-} ]]; then
+    # Try and replicate the native binary placement of go install without
+    # calling go install.  This means we have to iterate each binary.
+    local output_path="${KUBE_GOPATH}/bin"
+    if [[ $platform != $host_platform ]]; then
+      output_path="${output_path}/${platform//\//_}"
+    fi
+
     kube::log::progress "    "
     for binary in "${binaries[@]}"; do
-      local outfile=$(kube::golang::output_filename_for_binary "${binary}" \
-        "${platform}")
+      local bin=$(basename "${binary}")
+      if [[ ${GOOS} == "windows" ]]; then
+        bin="${bin}.exe"
+      fi
+
       if kube::golang::is_statically_linked_library "${binary}"; then
-        CGO_ENABLED=0 go build -o "${outfile}" \
+        CGO_ENABLED=0 go build -o "${output_path}/${bin}" \
           "${goflags[@]:+${goflags[@]}}" \
           -ldflags "${version_ldflags}" \
           "${binary}"
       else
-        go build -o "${outfile}" \
+        go build -o "${output_path}/${bin}" \
           "${goflags[@]:+${goflags[@]}}" \
           -ldflags "${version_ldflags}" \
           "${binary}"
@@ -358,18 +349,6 @@ kube::golang::build_binaries_for_platform() {
     fi
   fi
 
-  for test in "${tests[@]:+${tests[@]}}"; do
-      local outfile=$(kube::golang::output_filename_for_binary "${test}" \
-        "${platform}")
-    # Go 1.4 added -o to control where the binary is saved, but Go 1.3 doesn't
-    # have this flag. Whenever we deprecate go 1.3, update to use -o instead of
-    # calling mv.
-    go test -c \
-      "${goflags[@]:+${goflags[@]}}" \
-      -ldflags "${version_ldflags}" \
-      "$(dirname ${test})"
-    mv -f "$(basename ${outfile})" "${outfile}"
-  done
 }
 
 # Return approximate physical memory in gigabytes.

hack/test-go.sh

@@ -35,7 +35,6 @@ kube::test::find_dirs() {
           -o -wholename '*/third_party/*' \
           -o -wholename '*/Godeps/*' \
           -o -wholename '*/contrib/podex/*' \
-          -o -wholename '*/test/e2e/*' \
           -o -wholename '*/test/integration/*' \
         \) -prune \
       \) -name '*_test.go' -print0 | xargs -0n1 dirname | sed 's|^\./||' | sort -u