// Start a multi-node cluster from offcial kubernetes 1.0 guides. Once
// up, do a couple basic smoke checks. See:
// http://kubernetes.io/v1.0/docs/getting-started-guides/coreos/coreos_multinode_cluster.html
func MultiNodeSmoke(c platform.TestCluster) error {
const clusterSize = 3
// spawn master
master, err := c.NewMachine(masterConfig)
if err != nil {
return err
}
// get master private IP and place into nodeConfig
nodeConfig = strings.Replace(nodeConfig, "<master-private-ip>", master.PrivateIP(), -1)
var nodeConfigs []string
for i := 0; i < clusterSize-1; i++ {
nodeConfigs = append(nodeConfigs, nodeConfig)
}
// spawn nodes
nodes, err := platform.NewMachines(c, nodeConfigs)
if err != nil {
return err
}
// get kubectl in master
_, err = master.SSH("wget -q https://storage.googleapis.com/kubernetes-release/release/v1.0.1/bin/linux/amd64/kubectl")
if err != nil {
return err
}
_, err = master.SSH("chmod +x kubectl")
if err != nil {
return err
}
// check that all nodes appear in kubectl
f := func() error {
if err = nodeCheck(master, nodes); err != nil {
return err
}
return nil
}
if err := util.Retry(10, 5*time.Second, f); err != nil {
return err
}
// start nginx pod and curl endpoint
if err = nginxCheck(master, nodes); err != nil {
return err
}
// http://kubernetes.io/v1.0/docs/user-guide/secrets/ Also, ensures
// https://github.com/coreos/bugs/issues/447 does not re-occur.
if err = secretCheck(master, nodes); err != nil {
return err
}
return nil
}
// Start a multi-node cluster from offcial coreos guides on manual
// installation. Once up, do a couple basic smoke checks. See:
// https://coreos.com/kubernetes/docs/latest/getting-started.html
func CoreOSBasic(c platform.TestCluster, version string) error {
// start single-node etcd
etcdNode, err := c.NewMachine(etcdConfig)
if err != nil {
return err
}
if err := etcd.GetClusterHealth(etcdNode, 1); err != nil {
return err
}
master, err := c.NewMachine("")
if err != nil {
return err
}
options := map[string]string{
"HYPERKUBE_ACI": "quay.io/coreos/hyperkube",
"MASTER_HOST": master.PrivateIP(),
"ETCD_ENDPOINTS": fmt.Sprintf("http://%v:2379", etcdNode.PrivateIP()),
"CONTROLLER_ENDPOINT": fmt.Sprintf("https://%v:443", master.PrivateIP()),
"K8S_SERVICE_IP": "10.3.0.1",
"K8S_VER": version,
"KUBELET_PATH": "/usr/lib/coreos/kubelet-wrapper",
}
// generate TLS assets on master
if err := generateMasterTLSAssets(master, options); err != nil {
return err
}
// create 3 worker nodes
workerConfigs := []string{"", "", ""}
workers, err := platform.NewMachines(c, workerConfigs)
if err != nil {
return err
}
// generate tls assets on workers by transfering ca from master
if err := generateWorkerTLSAssets(master, workers); err != nil {
return err
}
// configure nodes via generic install scripts
if err := runInstallScript(master, controllerInstallScript, options); err != nil {
return fmt.Errorf("Installing controller: %v", err)
}
for _, worker := range workers {
if err := runInstallScript(worker, workerInstallScript, options); err != nil {
return fmt.Errorf("Installing worker: %v", err)
}
}
// configure kubectl
if err := configureKubectl(master, master.PrivateIP(), version); err != nil {
return err
}
// check that all nodes appear in kubectl
f := func() error {
return nodeCheck(master, workers)
}
if err := util.Retry(15, 10*time.Second, f); err != nil {
return err
}
// start nginx pod and curl endpoint
if err = nginxCheck(master, workers); err != nil {
return err
}
// http://kubernetes.io/v1.0/docs/user-guide/secrets/ Also, ensures
// https://github.com/coreos/bugs/issues/447 does not re-occur.
if err = secretCheck(master, workers); err != nil {
return err
}
return nil
}
// create a cluster and run test
func RunTest(t *Test, pltfrm string) error {
var err error
var cluster platform.Cluster
switch pltfrm {
case "qemu":
cluster, err = platform.NewQemuCluster(QEMUOptions)
case "gce":
cluster, err = platform.NewGCECluster(GCEOptions)
case "aws":
cluster, err = platform.NewAWSCluster(AWSOptions)
default:
err = fmt.Errorf("invalid platform %q", pltfrm)
}
if err != nil {
return fmt.Errorf("Cluster failed: %v", err)
}
defer func() {
if err := cluster.Destroy(); err != nil {
plog.Errorf("cluster.Destroy(): %v", err)
}
}()
url, err := cluster.GetDiscoveryURL(t.ClusterSize)
if err != nil {
return fmt.Errorf("Failed to create discovery endpoint: %v", err)
}
cfgs := makeConfigs(url, t.CloudConfig, t.ClusterSize)
if t.ClusterSize > 0 {
_, err := platform.NewMachines(cluster, cfgs)
if err != nil {
return fmt.Errorf("Cluster failed starting machines: %v", err)
}
}
// pass along all registered native functions
var names []string
for k := range t.NativeFuncs {
names = append(names, k)
}
// prevent unsafe access if tests ever become parallel and access
tempTestOptions := make(map[string]string, 0)
for k, v := range testOptions {
tempTestOptions[k] = v
}
// Cluster -> TestCluster
tcluster := platform.TestCluster{
Name: t.Name,
NativeFuncs: names,
Options: tempTestOptions,
Cluster: cluster,
}
// drop kolet binary on machines
if t.NativeFuncs != nil {
err = scpKolet(tcluster)
if err != nil {
return fmt.Errorf("dropping kolet binary: %v", err)
}
}
// run test
err = t.Run(tcluster)
// give some time for the remote journal to be flushed so it can be read
// before we run the deferred machine destruction
if err != nil {
time.Sleep(10 * time.Second)
}
return err
}