15308555518/ kubekey
1
0
Fork 0
mirror of https://github.com/kubesphere/kubekey.git synced 2025-12-26 01:22:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master'

This commit is contained in:
pixiake 2020-05-14 23:23:11 +08:00
parent a4e763605d 278b6c868a
commit d86b1c8153
24 changed files with 143 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
pkg/cluster/etcd/etcd.go
View File

@ -24,7 +24,7 @@ var (
)
func GenerateEtcdCerts(mgr *manager.Manager) error {
mgr.Logger.Infoln("Generate etcd certs")
mgr.Logger.Infoln("Generating etcd certs")
return mgr.RunTaskOnEtcdNodes(generateCerts, true)
}
@ -39,7 +39,7 @@ func generateCerts(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.Conn
certsScriptBase64 := base64.StdEncoding.EncodeToString([]byte(certsScript))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("echo %s | base64 -d > /tmp/kubekey/make-ssl-etcd.sh && chmod +x /tmp/kubekey/make-ssl-etcd.sh", certsScriptBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate etcd certs script")
return errors.Wrap(errors.WithStack(err1), "Failed to generate etcd certs script")
}
certsOpensslCfg, err := tmpl.GenerateEtcdSslCfg(mgr.Cluster)
if err != nil {
@ -48,21 +48,21 @@ func generateCerts(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.Conn
certsOpensslCfgBase64 := base64.StdEncoding.EncodeToString([]byte(certsOpensslCfg))
_, err2 := mgr.Runner.RunCmd(fmt.Sprintf("echo %s | base64 -d > /tmp/kubekey/openssl.conf", certsOpensslCfgBase64))
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to generate etcd certs script")
return errors.Wrap(errors.WithStack(err2), "Failed to generate etcd certs script")
}
cmd := fmt.Sprintf("mkdir -p %s && /bin/bash -x %s/make-ssl-etcd.sh -f %s/openssl.conf -d %s", etcdCertDir, "/tmp/kubekey", "/tmp/kubekey", etcdCertDir)
_, err3 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", cmd))
if err3 != nil {
return errors.Wrap(errors.WithStack(err3), "failed to generate etcd certs")
return errors.Wrap(errors.WithStack(err3), "Failed to generate etcd certs")
}
for _, cert := range generateCertsFiles(mgr) {
certsBase64Cmd := fmt.Sprintf("cat %s/%s | base64 --wrap=0", etcdCertDir, cert)
certsBase64, err4 := mgr.Runner.RunCmd(certsBase64Cmd)
if err4 != nil {
return errors.Wrap(errors.WithStack(err4), "failed to get etcd certs content")
return errors.Wrap(errors.WithStack(err4), "Failed to get etcd certs content")
}
certsContent[cert] = certsBase64
}
@ -77,7 +77,7 @@ func generateCerts(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.Conn
writeCertCmd := fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > %s/%s\"", cert, etcdCertDir, file)
_, err4 := mgr.Runner.RunCmd(writeCertCmd)
if err4 != nil {
return errors.Wrap(errors.WithStack(err4), "failed to write etcd certs content")
return errors.Wrap(errors.WithStack(err4), "Failed to write etcd certs content")
}
}
}
@ -103,7 +103,7 @@ func generateCertsFiles(mgr *manager.Manager) []string {
}
func SyncEtcdCertsToMaster(mgr *manager.Manager) error {
mgr.Logger.Infoln("Sync etcd certs")
mgr.Logger.Infoln("Synchronizing etcd certs")
return mgr.RunTaskOnMasterNodes(syncEtcdCertsToMaster, true)
}
@ -115,7 +115,7 @@ func syncEtcdCertsToMaster(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn
writeCertCmd := fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > %s/%s\"", cert, etcdCertDir, file)
_, err := mgr.Runner.RunCmd(writeCertCmd)
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to sync etcd certs to master")
return errors.Wrap(errors.WithStack(err), "Failed to sync etcd certs to master")
}
}
}
@ -123,7 +123,7 @@ func syncEtcdCertsToMaster(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn
}
func GenerateEtcdService(mgr *manager.Manager) error {
mgr.Logger.Infoln("Start etcd cluster")
mgr.Logger.Infoln("Starting etcd cluster")
return mgr.RunTaskOnEtcdNodes(generateEtcdService, true)
}
@ -136,7 +136,7 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
etcdServiceBase64 := base64.StdEncoding.EncodeToString([]byte(etcdService))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/systemd/system/etcd.service\"", etcdServiceBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate etcd service")
return errors.Wrap(errors.WithStack(err1), "Failed to generate etcd service")
}
etcdEnv, err := tmpl.GenerateEtcdEnv(mgr, node, mgr.Runner.Index)
@ -146,7 +146,7 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
etcdEnvBase64 := base64.StdEncoding.EncodeToString([]byte(etcdEnv))
_, err2 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/etcd.env\"", etcdEnvBase64))
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to generate etcd env")
return errors.Wrap(errors.WithStack(err2), "Failed to generate etcd env")
}
etcdBin, err := tmpl.GenerateEtcdBinary(mgr, mgr.Runner.Index)
@ -156,18 +156,18 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
etcdBinBase64 := base64.StdEncoding.EncodeToString([]byte(etcdBin))
_, err3 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /usr/local/bin/etcd && chmod +x /usr/local/bin/etcd\"", etcdBinBase64))
if err3 != nil {
return errors.Wrap(errors.WithStack(err3), "failed to generate etcd bin")
return errors.Wrap(errors.WithStack(err3), "Failed to generate etcd bin")
}
getEtcdCtlCmd := fmt.Sprintf("docker run --rm -v /usr/local/bin:/systembindir %s /bin/cp /usr/local/bin/etcdctl /systembindir/etcdctl", images.GetImage(mgr, "etcd").ImageName())
_, err4 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", getEtcdCtlCmd))
if err4 != nil {
return errors.Wrap(errors.WithStack(err4), "failed to get etcdctl")
return errors.Wrap(errors.WithStack(err4), "Failed to get etcdctl")
}
_, err5 := mgr.Runner.RunCmd("sudo -E /bin/sh -c \"systemctl daemon-reload && systemctl restart etcd\"")
if err5 != nil {
return errors.Wrap(errors.WithStack(err5), "failed to start etcd")
return errors.Wrap(errors.WithStack(err5), "Failed to start etcd")
}
addrList := []string{}
@ -181,7 +181,7 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
if err != nil {
fmt.Println("Waiting for etcd to start")
if i == 1 {
return errors.Wrap(errors.WithStack(err), "failed to start etcd")
return errors.Wrap(errors.WithStack(err), "Failed to start etcd cluster")
}
} else {
break
@ -196,7 +196,7 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
// joinMemberCmd := fmt.Sprintf("export ETCDCTL_API=2;export ETCDCTL_CERT_FILE='/etc/ssl/etcd/ssl/admin-%s.pem';export ETCDCTL_KEY_FILE='/etc/ssl/etcd/ssl/admin-%s-key.pem';export ETCDCTL_CA_FILE='/etc/ssl/etcd/ssl/ca.pem';%s/etcdctl --endpoints=%s member add %s %s", node.HostName, node.HostName, etcdBinDir, strings.Join(addrList, ","), fmt.Sprintf("etcd%d", mgr.Runner.Index+1), fmt.Sprintf("https://%s:2380", node.InternalAddress))
// _, err := mgr.Runner.RunCmd(joinMemberCmd)
// if err != nil {
// fmt.Println("failed to add etcd member")
// fmt.Println("Failed to add etcd member")
// }
// }
//}
@ -206,7 +206,7 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
if err != nil {
fmt.Println("Waiting for etcd to start")
if i == 1 {
return errors.Wrap(errors.WithStack(err), "failed to start etcd")
return errors.Wrap(errors.WithStack(err), "Failed to start etcd")
}
} else {
break
@ -217,7 +217,7 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
reloadEtcdEnvCmd := "sed -i '/ETCD_INITIAL_CLUSTER_STATE/s/\\:.*/\\: existing/g' /etc/etcd.env && systemctl daemon-reload && systemctl restart etcd"
_, err6 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", reloadEtcdEnvCmd))
if err6 != nil {
return errors.Wrap(errors.WithStack(err6), "failed to reload etcd env")
return errors.Wrap(errors.WithStack(err6), "Failed to reload etcd env")
}
for i := 20; i > 0; i-- {
@ -225,7 +225,7 @@ func generateEtcdService(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
if err != nil {
fmt.Println("Waiting for etcd to start")
if i == 1 {
return errors.Wrap(errors.WithStack(err), "failed to start etcd")
return errors.Wrap(errors.WithStack(err), "Failed to start etcd")
}
} else {
break

38
pkg/cluster/kubernetes/master.go
View File

@ -44,12 +44,12 @@ func getClusterStatus(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.C
clusterIsExist = false
} else {
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to find /etc/kubernetes/admin.conf")
return errors.Wrap(errors.WithStack(err), "Failed to find /etc/kubernetes/admin.conf")
} else {
clusterIsExist = true
output, err := mgr.Runner.RunCmd("sudo cat /etc/kubernetes/manifests/kube-apiserver.yaml | grep 'image:' | awk -F '[:]' '{print $(NF-0)}'")
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to find current version")
return errors.Wrap(errors.WithStack(err), "Failed to find current version")
} else {
if !strings.Contains(output, "No such file or directory") {
clusterStatus["version"] = output
@ -65,7 +65,7 @@ func getClusterStatus(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.C
}
func InitKubernetesCluster(mgr *manager.Manager) error {
mgr.Logger.Infoln("Init kubernetes cluster")
mgr.Logger.Infoln("Initializing kubernetes cluster")
return mgr.RunTaskOnMasterNodes(initKubernetesCluster, true)
}
@ -79,13 +79,13 @@ func initKubernetesCluster(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn
kubeadmCfgBase64 := base64.StdEncoding.EncodeToString([]byte(kubeadmCfg))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"mkdir -p /etc/kubernetes && echo %s | base64 -d > /etc/kubernetes/kubeadm-config.yaml\"", kubeadmCfgBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate kubeadm config")
return errors.Wrap(errors.WithStack(err1), "Failed to generate kubeadm config")
}
output, err2 := mgr.Runner.RunCmd("sudo -E /bin/sh -c \"/usr/local/bin/kubeadm init --config=/etc/kubernetes/kubeadm-config.yaml\"")
if err2 != nil {
fmt.Println(output)
return errors.Wrap(errors.WithStack(err2), "failed to init kubernetes cluster")
return errors.Wrap(errors.WithStack(err2), "Failed to init kubernetes cluster")
}
if err3 := GetKubeConfig(mgr); err3 != nil {
return err3
@ -120,7 +120,7 @@ func GetKubeConfig(mgr *manager.Manager) error {
cmd := strings.Join([]string{createConfigDirCmd, getKubeConfigCmd, getKubeConfigCmdUsr, chownKubeConfig}, " && ")
_, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", cmd))
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to init kubernetes cluster")
return errors.Wrap(errors.WithStack(err), "Failed to init kubernetes cluster")
}
return nil
}
@ -130,7 +130,7 @@ func removeMasterTaint(mgr *manager.Manager, node *kubekeyapi.HostCfg) error {
removeMasterTaintCmd := fmt.Sprintf("/usr/local/bin/kubectl taint nodes %s node-role.kubernetes.io/master=:NoSchedule-", node.Name)
_, err := mgr.Runner.RunCmd(removeMasterTaintCmd)
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to remove master taint")
return errors.Wrap(errors.WithStack(err), "Failed to remove master taint")
}
}
return nil
@ -141,7 +141,7 @@ func addWorkerLabel(mgr *manager.Manager, node *kubekeyapi.HostCfg) error {
addWorkerLabelCmd := fmt.Sprintf("/usr/local/bin/kubectl label node %s node-role.kubernetes.io/worker=", node.Name)
out, err := mgr.Runner.RunCmd(addWorkerLabelCmd)
if err != nil && !strings.Contains(out, "already") {
return errors.Wrap(errors.WithStack(err), "failed to add worker label")
return errors.Wrap(errors.WithStack(err), "Failed to add worker label")
}
}
return nil
@ -164,7 +164,7 @@ func getJoinCmd(mgr *manager.Manager) error {
uploadCertsCmd := "/usr/local/bin/kubeadm init phase upload-certs --upload-certs"
out, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", uploadCertsCmd))
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to upload kubeadm certs")
return errors.Wrap(errors.WithStack(err), "Failed to upload kubeadm certs")
}
reg := regexp.MustCompile("[0-9|a-z]{64}")
certificateKey := reg.FindAllString(out, -1)[0]
@ -177,7 +177,7 @@ func getJoinCmd(mgr *manager.Manager) error {
out, err2 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", tokenCreateMasterCmd))
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to get join node cmd")
return errors.Wrap(errors.WithStack(err2), "Failed to get join node cmd")
}
joinMasterStrList := strings.Split(out, "kubeadm join")
@ -189,20 +189,20 @@ func getJoinCmd(mgr *manager.Manager) error {
out, err3 := mgr.Runner.RunCmd("/usr/local/bin/kubectl get nodes -o wide")
if err3 != nil {
return errors.Wrap(errors.WithStack(err3), "failed to get cluster info")
return errors.Wrap(errors.WithStack(err3), "Failed to get cluster info")
}
clusterStatus["clusterInfo"] = out
kubeCfgBase64Cmd := "cat /etc/kubernetes/admin.conf | base64 --wrap=0"
out, err4 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", kubeCfgBase64Cmd))
if err4 != nil {
return errors.Wrap(errors.WithStack(err4), "failed to get cluster kubeconfig")
return errors.Wrap(errors.WithStack(err4), "Failed to get cluster kubeconfig")
}
clusterStatus["kubeConfig"] = out
currentDir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
return errors.Wrap(err, "faild get current dir")
return errors.Wrap(err, "Faild to get current dir")
}
exec.Command(fmt.Sprintf("mkdir -p %s/kubekey", currentDir))
exec.Command(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > %s/kubekey/kubeconfig.yaml\"", clusterStatus["kubeConfig"], currentDir)).Run()
@ -215,14 +215,14 @@ func PatchKubeadmSecret(mgr *manager.Manager) error {
for _, cert := range externalEtcdCerts {
_, err := mgr.Runner.RunCmd(fmt.Sprintf("/usr/local/bin/kubectl patch -n kube-system secret kubeadm-certs -p '{\"data\": {\"%s\": \"\"}}'", cert))
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to patch kubeadm secret")
return errors.Wrap(errors.WithStack(err), "Failed to patch kubeadm secret")
}
}
return nil
}
func JoinNodesToCluster(mgr *manager.Manager) error {
mgr.Logger.Infoln("Join nodes to cluster")
mgr.Logger.Infoln("Joining nodes to cluster")
return mgr.RunTaskOnK8sNodes(joinNodesToCluster, true)
}
@ -260,7 +260,7 @@ func joinNodesToCluster(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh
func addMaster(mgr *manager.Manager) error {
_, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", clusterStatus["joinMasterCmd"]))
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to add master to cluster")
return errors.Wrap(errors.WithStack(err), "Failed to add master to cluster")
}
err1 := GetKubeConfig(mgr)
if err1 != nil {
@ -272,18 +272,18 @@ func addMaster(mgr *manager.Manager) error {
func addWorker(mgr *manager.Manager) error {
_, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", clusterStatus["joinWorkerCmd"]))
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to add worker to cluster")
return errors.Wrap(errors.WithStack(err), "Failed to add worker to cluster")
}
createConfigDirCmd := "mkdir -p /root/.kube && mkdir -p $HOME/.kube"
chownKubeConfig := "chown $(id -u):$(id -g) $HOME/.kube/config"
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", createConfigDirCmd))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to create kube dir")
return errors.Wrap(errors.WithStack(err1), "Failed to create kube dir")
}
syncKubeconfigCmd := fmt.Sprintf("echo %s | base64 -d > %s && echo %s | base64 -d > %s && %s", clusterStatus["kubeConfig"], "/root/.kube/config", clusterStatus["kubeConfig"], "$HOME/.kube/config", chownKubeConfig)
_, err2 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", syncKubeconfigCmd))
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to sync kube config")
return errors.Wrap(errors.WithStack(err2), "Failed to sync kube config")
}
return nil
}

12
pkg/cluster/kubernetes/nodes.go
View File

@ -14,7 +14,7 @@ import (
)
func SyncKubeBinaries(mgr *manager.Manager) error {
mgr.Logger.Infoln("Syncing kube binaries")
mgr.Logger.Infoln("Synchronizing kube binaries")
return mgr.RunTaskOnK8sNodes(syncKubeBinaries, true)
}
@ -24,7 +24,7 @@ func syncKubeBinaries(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.C
currentDir, err1 := filepath.Abs(filepath.Dir(os.Args[0]))
if err1 != nil {
return errors.Wrap(err1, "faild get current dir")
return errors.Wrap(err1, "Failed to get current dir")
}
filepath := fmt.Sprintf("%s/%s", currentDir, kubekeyapi.DefaultPreDir)
@ -39,7 +39,7 @@ func syncKubeBinaries(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.C
for _, binary := range binaryList {
err2 := mgr.Runner.ScpFile(fmt.Sprintf("%s/%s", filepath, binary), fmt.Sprintf("%s/%s", "/tmp/kubekey", binary))
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), fmt.Sprintf("failed to sync binarys"))
return errors.Wrap(errors.WithStack(err2), fmt.Sprintf("Failed to sync binaries"))
}
}
@ -55,7 +55,7 @@ func syncKubeBinaries(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.C
cmd := strings.Join(cmdlist, " && ")
_, err3 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", cmd))
if err3 != nil {
return errors.Wrap(errors.WithStack(err3), fmt.Sprintf("failed to create kubelet link"))
return errors.Wrap(errors.WithStack(err3), fmt.Sprintf("Failed to create kubelet link"))
}
if err := setKubelet(mgr); err != nil {
@ -73,7 +73,7 @@ func setKubelet(mgr *manager.Manager) error {
kubeletServiceBase64 := base64.StdEncoding.EncodeToString([]byte(kubeletService))
_, err2 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/systemd/system/kubelet.service && systemctl enable kubelet && ln -snf /usr/local/bin/kubelet /usr/bin/kubelet\"", kubeletServiceBase64))
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to generate kubelet service")
return errors.Wrap(errors.WithStack(err2), "Failed to generate kubelet service")
}
kubeletEnv, err3 := tmpl.GenerateKubeletEnv(mgr.Cluster)
@ -83,7 +83,7 @@ func setKubelet(mgr *manager.Manager) error {
kubeletEnvBase64 := base64.StdEncoding.EncodeToString([]byte(kubeletEnv))
_, err4 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"mkdir -p /etc/systemd/system/kubelet.service.d && echo %s | base64 -d > /etc/systemd/system/kubelet.service.d/10-kubeadm.conf\"", kubeletEnvBase64))
if err4 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to generate kubelet env")
return errors.Wrap(errors.WithStack(err2), "Failed to generate kubelet env")
}
return nil

10
pkg/cluster/preinstall/initOS.go
View File

@ -11,7 +11,7 @@ import (
)
func InitOS(mgr *manager.Manager) error {
mgr.Logger.Infoln("Initialize operating system")
mgr.Logger.Infoln("Configurating operating system ...")
return mgr.RunTaskOnAllNodes(initOsOnNode, true)
}
@ -20,12 +20,12 @@ func initOsOnNode(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.Conne
tmpDir := "/tmp/kubekey"
_, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"if [ -d %s ]; then rm -rf %s ;fi\" && mkdir -p %s", tmpDir, tmpDir, tmpDir))
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to init operating system")
return errors.Wrap(errors.WithStack(err), "Failed to configure operating system")
}
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"hostnamectl set-hostname %s && sed -i '/^127.0.1.1/s/.*/127.0.1.1 %s/g' /etc/hosts\"", node.Name, node.Name))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to override hostname")
return errors.Wrap(errors.WithStack(err1), "Failed to override hostname")
}
initOsScript, err2 := tmpl.InitOsScript(mgr)
@ -36,12 +36,12 @@ func initOsOnNode(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.Conne
str := base64.StdEncoding.EncodeToString([]byte(initOsScript))
_, err3 := mgr.Runner.RunCmd(fmt.Sprintf("echo %s | base64 -d > %s/initOS.sh && chmod +x %s/initOS.sh", str, tmpDir, tmpDir))
if err3 != nil {
return errors.Wrap(errors.WithStack(err3), "failed to init operating system")
return errors.Wrap(errors.WithStack(err3), "Failed to configure operating system")
}
_, err4 := mgr.Runner.RunCmd(fmt.Sprintf("sudo %s/initOS.sh", tmpDir))
if err4 != nil {
return errors.Wrap(errors.WithStack(err4), "failed to init operating system")
return errors.Wrap(errors.WithStack(err4), "Failed to configure operating system")
}
return nil
}

16
pkg/cluster/preinstall/preinstall.go
View File

@ -41,7 +41,7 @@ func FilesDownloadHttp(cfg *kubekeyapi.K2ClusterSpec, filepath string, logger *l
if util.IsExist(kubeadm) == false {
if out, err := exec.Command("/bin/sh", "-c", getKubeadmCmd).CombinedOutput(); err != nil {
fmt.Println(string(out))
return errors.Wrap(err, "faild download kubeadm binary")
return errors.Wrap(err, "Failed to download kubeadm binary")
}
}
@ -49,7 +49,7 @@ func FilesDownloadHttp(cfg *kubekeyapi.K2ClusterSpec, filepath string, logger *l
if util.IsExist(kubelet) == false {
if out, err := exec.Command("/bin/sh", "-c", getKubeletCmd).CombinedOutput(); err != nil {
fmt.Println(string(out))
return errors.Wrap(err, "faild download kubelet binary")
return errors.Wrap(err, "Failed to download kubelet binary")
}
}
@ -57,7 +57,7 @@ func FilesDownloadHttp(cfg *kubekeyapi.K2ClusterSpec, filepath string, logger *l
if util.IsExist(kubectl) == false {
if out, err := exec.Command("/bin/sh", "-c", getKubectlCmd).CombinedOutput(); err != nil {
fmt.Println(string(out))
return errors.Wrap(err, "faild download kubectl binary")
return errors.Wrap(err, "Failed to download kubectl binary")
}
}
@ -65,7 +65,7 @@ func FilesDownloadHttp(cfg *kubekeyapi.K2ClusterSpec, filepath string, logger *l
if util.IsExist(kubeCni) == false {
if out, err := exec.Command("/bin/sh", "-c", getKubeCniCmd).CombinedOutput(); err != nil {
fmt.Println(string(out))
return errors.Wrap(err, "faild download kubecni")
return errors.Wrap(err, "Faild to download kubecni")
}
}
@ -73,7 +73,7 @@ func FilesDownloadHttp(cfg *kubekeyapi.K2ClusterSpec, filepath string, logger *l
if util.IsExist(helm) == false {
if out, err := exec.Command("/bin/sh", "-c", getHelmCmd).CombinedOutput(); err != nil {
fmt.Println(string(out))
return errors.Wrap(err, "faild download helm binary")
return errors.Wrap(err, "Failed to download helm binary")
}
}
@ -81,16 +81,16 @@ func FilesDownloadHttp(cfg *kubekeyapi.K2ClusterSpec, filepath string, logger *l
}
func Prepare(cfg *kubekeyapi.K2ClusterSpec, logger *log.Logger) error {
logger.Info("Downloading Install Files")
logger.Info("Downloading Installation Files")
currentDir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
return errors.Wrap(err, "faild get current dir")
return errors.Wrap(err, "Faild to get current dir")
}
filepath := fmt.Sprintf("%s/%s", currentDir, kubekeyapi.DefaultPreDir)
if err := util.CreateDir(filepath); err != nil {
return errors.Wrap(err, "faild create download target dir")
return errors.Wrap(err, "Failed to create download target dir")
}
if err := FilesDownloadHttp(cfg, filepath, logger); err != nil {

4
pkg/config/config.go
View File

@ -165,13 +165,13 @@ func GenerateK2ClusterObj(addons, name string) error {
K2ClusterObjStr, err := GenerateK2ClusterObjStr(&opt, opt.StorageNum)
if err != nil {
return errors.Wrap(err, "faild to generate k2cluster config")
return errors.Wrap(err, "Faild to generate k2cluster config")
}
K2ClusterObjStrBase64 := base64.StdEncoding.EncodeToString([]byte(K2ClusterObjStr))
currentDir, err := filepath.Abs(filepath.Dir(os.Args[0]))
if err != nil {
return errors.Wrap(err, "faild get current dir")
return errors.Wrap(err, "Failed to get current dir")
}
cmd := fmt.Sprintf("echo %s | base64 -d > %s/%s.yaml", K2ClusterObjStrBase64, currentDir, opt.Name)
err1 := exec.Command("/bin/sh", "-c", cmd).Run()

8
pkg/config/default.go
View File

@ -20,21 +20,21 @@ func ParseClusterCfg(clusterCfgPath, addons string, logger *log.Logger) (*kubeke
if len(clusterCfgPath) == 0 {
user, _ := user.Current()
if user.Name != "root" {
return nil, errors.New(fmt.Sprintf("Current user is %s, Please use root !", user.Name))
return nil, errors.New(fmt.Sprintf("Current user is %s. Please use root!", user.Name))
}
clusterCfg = AllinoneCfg(user, addons)
} else {
fp, err := filepath.Abs(clusterCfgPath)
if err != nil {
return nil, errors.Wrap(err, "failed to lookup current directory")
return nil, errors.Wrap(err, "Failed to look up current directory")
}
content, err := ioutil.ReadFile(fp)
if err != nil {
return nil, errors.Wrap(err, "unable to read the given cluster configuration file")
return nil, errors.Wrap(err, "Unable to read the given cluster configuration file")
}
if err := yaml.Unmarshal(content, &clusterCfg); err != nil {
return nil, errors.Wrap(err, "unable to convert file to yaml")
return nil, errors.Wrap(err, "Unable to convert file to yaml")
}
}

6
pkg/container-engine/docker/docker.go
View File

@ -54,7 +54,7 @@ func GenerateDockerConfig(mgr *manager.Manager) (string, error) {
}
func InstallerDocker(mgr *manager.Manager) error {
mgr.Logger.Infoln("Installing docker……")
mgr.Logger.Infoln("Installing docker ...")
return mgr.RunTaskOnAllNodes(installDockerOnNode, true)
}
@ -64,7 +64,7 @@ func installDockerOnNode(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
//out, err := mgr.Runner.RunCmd(cmd)
//if err != nil {
// fmt.Println(out)
// return errors.Wrap(errors.WithStack(err), "failed to install docker")
// return errors.Wrap(errors.WithStack(err), "Failed to install docker")
//}
dockerConfig, err := GenerateDockerConfig(mgr)
if err != nil {
@ -73,7 +73,7 @@ func installDockerOnNode(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ss
dockerConfigBase64 := base64.StdEncoding.EncodeToString([]byte(dockerConfig))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"if [ -z $(which docker) ]; then curl https://kubernetes.pek3b.qingstor.com/tools/kubekey/docker-install.sh | sh && systemctl enable docker && echo %s | base64 -d > /etc/docker/daemon.json && systemctl reload docker; fi\"", dockerConfigBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to install docker")
return errors.Wrap(errors.WithStack(err1), "Failed to install docker")
}
return nil

2
pkg/controller/k2cluster/k2cluster_controller.go
View File

@ -125,7 +125,7 @@ func (r *ReconcileK2Cluster) Reconcile(request reconcile.Request) (reconcile.Res
}
// Pod already exists - don't requeue
reqLogger.Info("Skip reconcile: Pod already exists", "Pod.Namespace", found.Namespace, "Pod.Name", found.Name)
reqLogger.Info("Skip reconciliation: Pod already exists", "Pod.Namespace", found.Namespace, "Pod.Name", found.Name)
return reconcile.Result{}, nil
}

12
pkg/images/images.go
View File

@ -63,24 +63,24 @@ func preDownloadImages(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.
for _, image := range imagesList {
if node.IsMaster && image.Group == "master" && image.Enable {
fmt.Printf("[%s] Download image: %s\n", node.Name, image.ImageName())
fmt.Printf("[%s] Downloading image: %s\n", node.Name, image.ImageName())
_, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E docker pull %s", image.ImageName()))
if err != nil {
return errors.Wrap(errors.WithStack(err), fmt.Sprintf("failed to download image: %s", image.ImageName()))
return errors.Wrap(errors.WithStack(err), fmt.Sprintf("Failed to download image: %s", image.ImageName()))
}
}
if (node.IsMaster || node.IsWorker) && image.Group == "k8s" && image.Enable {
fmt.Printf("[%s] Download image: %s\n", node.Name, image.ImageName())
fmt.Printf("[%s] Downloading image: %s\n", node.Name, image.ImageName())
_, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E docker pull %s", image.ImageName()))
if err != nil {
return errors.Wrap(errors.WithStack(err), fmt.Sprintf("failed to download image: %s", image.ImageName()))
return errors.Wrap(errors.WithStack(err), fmt.Sprintf("Failed to download image: %s", image.ImageName()))
}
}
if node.IsEtcd && image.Group == "etcd" && image.Enable {
fmt.Printf("[%s] Download image: %s\n", node.Name, image.ImageName())
fmt.Printf("[%s] Downloading image: %s\n", node.Name, image.ImageName())
_, err := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E docker pull %s", image.ImageName()))
if err != nil {
return errors.Wrap(errors.WithStack(err), fmt.Sprintf("failed to download image: %s", image.ImageName()))
return errors.Wrap(errors.WithStack(err), fmt.Sprintf("Failed to download image: %s", image.ImageName()))
}
}
}

34
pkg/install/install.go
View File

@ -20,32 +20,32 @@ import (
func CreateCluster(clusterCfgFile string, logger *log.Logger, addons, pkg string, verbose bool) error {
cfg, err := config.ParseClusterCfg(clusterCfgFile, addons, logger)
if err != nil {
return errors.Wrap(err, "failed to download cluster config")
return errors.Wrap(err, "Failed to download cluster config")
}
if err := preinstall.Prepare(&cfg.Spec, logger); err != nil {
return errors.Wrap(err, "failed to load kube binarys")
return errors.Wrap(err, "Failed to load kube binaries")
}
return Execute(executor.NewExecutor(&cfg.Spec, logger, verbose))
}
func ExecTasks(mgr *manager.Manager) error {
createTasks := []manager.Task{
{Task: preinstall.InitOS, ErrMsg: "failed to download kube binaries"},
{Task: docker.InstallerDocker, ErrMsg: "failed to install docker"},
{Task: kubernetes.SyncKubeBinaries, ErrMsg: "failed to sync kube binaries"},
{Task: images.PreDownloadImages, ErrMsg: "failed to pre-download images"},
{Task: etcd.GenerateEtcdCerts, ErrMsg: "failed to generate etcd certs"},
{Task: etcd.SyncEtcdCertsToMaster, ErrMsg: "failed to sync etcd certs"},
{Task: etcd.GenerateEtcdService, ErrMsg: "failed to start etcd cluster"},
{Task: kubernetes.GetClusterStatus, ErrMsg: "failed to get cluster status"},
//{Task: kubernetes.ConfigureKubeletService, ErrMsg: "failed to sync kube binaries"},
{Task: kubernetes.InitKubernetesCluster, ErrMsg: "failed to init kubernetes cluster"},
{Task: network.DeployNetworkPlugin, ErrMsg: "failed to deploy network plugin"},
//{Task: kubernetes.GetJoinNodesCmd, ErrMsg: "failed to get join cmd"},
{Task: kubernetes.JoinNodesToCluster, ErrMsg: "failed to join node"},
{Task: storage.DeployStoragePlugins, ErrMsg: "failed to deploy storage plugin"},
{Task: kubesphere.DeployKubeSphere, ErrMsg: "failed to deploy kubesphere"},
{Task: preinstall.InitOS, ErrMsg: "Failed to download kube binaries"},
{Task: docker.InstallerDocker, ErrMsg: "Failed to install docker"},
{Task: kubernetes.SyncKubeBinaries, ErrMsg: "Failed to sync kube binaries"},
{Task: images.PreDownloadImages, ErrMsg: "Failed to pre-download images"},
{Task: etcd.GenerateEtcdCerts, ErrMsg: "Failed to generate etcd certs"},
{Task: etcd.SyncEtcdCertsToMaster, ErrMsg: "Failed to sync etcd certs"},
{Task: etcd.GenerateEtcdService, ErrMsg: "Failed to start etcd cluster"},
{Task: kubernetes.GetClusterStatus, ErrMsg: "Failed to get cluster status"},
//{Task: kubernetes.ConfigureKubeletService, ErrMsg: "Failed to sync kube binaries"},
{Task: kubernetes.InitKubernetesCluster, ErrMsg: "Failed to init kubernetes cluster"},
{Task: network.DeployNetworkPlugin, ErrMsg: "Failed to deploy network plugin"},
//{Task: kubernetes.GetJoinNodesCmd, ErrMsg: "Failed to get join cmd"},
{Task: kubernetes.JoinNodesToCluster, ErrMsg: "Failed to join node"},
{Task: storage.DeployStoragePlugins, ErrMsg: "Failed to deploy storage plugin"},
{Task: kubesphere.DeployKubeSphere, ErrMsg: "Failed to deploy kubesphere"},
}
for _, step := range createTasks {

6
pkg/kubesphere/kubesphere.go
View File

@ -11,7 +11,7 @@ import (
)
func DeployKubeSphere(mgr *manager.Manager) error {
mgr.Logger.Infoln("Deploy KubeSphere")
mgr.Logger.Infoln("Deploying KubeSphere ...")
return mgr.RunTaskOnMasterNodes(deployKubeSphere, true)
}
@ -39,11 +39,11 @@ func DeployKubeSphereStep(mgr *manager.Manager) error {
kubesphereYamlBase64 := base64.StdEncoding.EncodeToString([]byte(kubesphereYaml))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/kubernetes/addons/kubesphere.yaml\"", kubesphereYamlBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate KubeSphere manifests")
return errors.Wrap(errors.WithStack(err1), "Failed to generate KubeSphere manifests")
}
_, err2 := mgr.Runner.RunCmd("/usr/local/bin/kubectl apply -f /etc/kubernetes/addons/kubesphere.yaml")
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to deploy kubesphere.yaml")
return errors.Wrap(errors.WithStack(err2), "Failed to deploy kubesphere.yaml")
}
CheckKubeSphereStatus(mgr)

10
pkg/plugins/dns/dns.go
View File

@ -15,16 +15,16 @@ func OverrideCorednsService(mgr *manager.Manager) error {
corednsSvcgBase64 := base64.StdEncoding.EncodeToString([]byte(corednsSvc))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/kubernetes/coredns-svc.yaml\"", corednsSvcgBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate kubeadm config")
return errors.Wrap(errors.WithStack(err1), "Failed to generate kubeadm config")
}
deleteKubednsSvcCmd := "/usr/local/bin/kubectl delete -n kube-system svc kube-dns"
_, err2 := mgr.Runner.RunCmd(deleteKubednsSvcCmd)
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to delete kubeadm Kube-DNS service")
return errors.Wrap(errors.WithStack(err2), "Failed to delete kubeadm Kube-DNS service")
}
_, err3 := mgr.Runner.RunCmd("/usr/local/bin/kubectl apply -f /etc/kubernetes/coredns-svc.yaml")
if err3 != nil {
return errors.Wrap(errors.WithStack(err3), "failed to create coredns service")
return errors.Wrap(errors.WithStack(err3), "Failed to create coredns service")
}
return nil
}
@ -37,11 +37,11 @@ func DeployNodelocaldns(mgr *manager.Manager) error {
nodelocaldnsBase64 := base64.StdEncoding.EncodeToString([]byte(nodelocaldns))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/kubernetes/nodelocaldns.yaml\"", nodelocaldnsBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate nodelocaldns manifests")
return errors.Wrap(errors.WithStack(err1), "Failed to generate nodelocaldns manifests")
}
_, err2 := mgr.Runner.RunCmd("/usr/local/bin/kubectl apply -f /etc/kubernetes/nodelocaldns.yaml")
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to create nodelocaldns")
return errors.Wrap(errors.WithStack(err2), "Failed to create nodelocaldns")
}
return nil
}

10
pkg/plugins/network/network.go
View File

@ -12,7 +12,7 @@ import (
)
func DeployNetworkPlugin(mgr *manager.Manager) error {
mgr.Logger.Infoln("Deploy network plugin")
mgr.Logger.Infoln("Deploying network plugin ...")
return mgr.RunTaskOnMasterNodes(deployNetworkPlugin, true)
}
@ -47,12 +47,12 @@ func deployCalico(mgr *manager.Manager, node *kubekeyapi.HostCfg) error {
calicoFileBase64 := base64.StdEncoding.EncodeToString([]byte(calicoFile))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/kubernetes/calico.yaml\"", calicoFileBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate calico file")
return errors.Wrap(errors.WithStack(err1), "Failed to generate calico file")
}
_, err2 := mgr.Runner.RunCmd("/usr/local/bin/kubectl apply -f /etc/kubernetes/calico.yaml")
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to deploy calico")
return errors.Wrap(errors.WithStack(err2), "Failed to deploy calico")
}
return nil
}
@ -65,12 +65,12 @@ func deployFlannel(mgr *manager.Manager) error {
flannelFileBase64 := base64.StdEncoding.EncodeToString([]byte(flannelFile))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/kubernetes/flannel.yaml\"", flannelFileBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate flannel file")
return errors.Wrap(errors.WithStack(err1), "Failed to generate flannel file")
}
_, err2 := mgr.Runner.RunCmd("/usr/local/bin/kubectl apply -f /etc/kubernetes/flannel.yaml")
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to deploy flannel")
return errors.Wrap(errors.WithStack(err2), "Failed to deploy flannel")
}
return nil
}

12
pkg/plugins/storage/storage.go
View File

@ -12,7 +12,7 @@ import (
)
func DeployStoragePlugins(mgr *manager.Manager) error {
mgr.Logger.Infoln("Deploy storage plugin")
mgr.Logger.Infoln("Deploying storage plugin ...")
return mgr.RunTaskOnMasterNodes(deployStoragePlugins, true)
}
@ -42,12 +42,12 @@ func DeployLocalVolume(mgr *manager.Manager) error {
localVolumeFileBase64 := base64.StdEncoding.EncodeToString([]byte(localVolumeFile))
_, err1 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/kubernetes/addons/local-volume.yaml\"", localVolumeFileBase64))
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to generate local-volume file")
return errors.Wrap(errors.WithStack(err1), "Failed to generate local-volume file")
}
_, err2 := mgr.Runner.RunCmd("/usr/local/bin/kubectl apply -f /etc/kubernetes/addons/local-volume.yaml")
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to deploy local-volume.yaml")
return errors.Wrap(errors.WithStack(err2), "Failed to deploy local-volume.yaml")
}
return nil
}
@ -56,7 +56,7 @@ func DeployNfsClient(mgr *manager.Manager) error {
_, err1 := mgr.Runner.RunCmd("sudo -E /bin/sh -c \"rm -rf /etc/kubernetes/addons/nfs-client-provisioner && /usr/local/bin/helm fetch kubesphere/nfs-client-provisioner -d /etc/kubernetes/addons --untar\"")
if err1 != nil {
return errors.Wrap(errors.WithStack(err1), "failed to fetch nfs-client-provisioner chart")
return errors.Wrap(errors.WithStack(err1), "Failed to fetch nfs-client-provisioner chart")
}
nfsClientValuesFile, err := nfs_client.GenerateNfsClientValuesFile(mgr)
@ -66,12 +66,12 @@ func DeployNfsClient(mgr *manager.Manager) error {
nfsClientValuesFileBase64 := base64.StdEncoding.EncodeToString([]byte(nfsClientValuesFile))
_, err2 := mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"echo %s | base64 -d > /etc/kubernetes/addons/custom-values-nfs-client.yaml\"", nfsClientValuesFileBase64))
if err2 != nil {
return errors.Wrap(errors.WithStack(err2), "failed to generate nfs-client values file")
return errors.Wrap(errors.WithStack(err2), "Failed to generate nfs-client values file")
}
_, err3 := mgr.Runner.RunCmd("sudo -E /bin/sh -c \"/usr/local/bin/helm upgrade -i nfs-client /etc/kubernetes/addons/nfs-client-provisioner -f /etc/kubernetes/addons/custom-values-nfs-client.yaml -n kube-system\"")
if err3 != nil {
return errors.Wrap(errors.WithStack(err3), "failed to deploy nfs-client-provisioner")
return errors.Wrap(errors.WithStack(err3), "Failed to deploy nfs-client-provisioner")
}
return nil
}

8
pkg/reset/reset.go
View File

@ -15,7 +15,7 @@ import (
func ResetCluster(clusterCfgFile string, logger *log.Logger, verbose bool) error {
cfg, err := config.ParseClusterCfg(clusterCfgFile, "", logger)
if err != nil {
return errors.Wrap(err, "failed to download cluster config")
return errors.Wrap(err, "Failed to download cluster config")
}
return Execute(executor.NewExecutor(&cfg.Spec, logger, verbose))
@ -31,7 +31,7 @@ func Execute(executor *executor.Executor) error {
func ExecTasks(mgr *manager.Manager) error {
resetTasks := []manager.Task{
{Task: ResetKubeCluster, ErrMsg: "failed to reset kube cluster"},
{Task: ResetKubeCluster, ErrMsg: "Failed to reset kube cluster"},
}
for _, step := range resetTasks {
@ -45,7 +45,7 @@ func ExecTasks(mgr *manager.Manager) error {
}
func ResetKubeCluster(mgr *manager.Manager) error {
mgr.Logger.Infoln("Reset kubernetes cluster")
mgr.Logger.Infoln("Resetting kubernetes cluster ...")
return mgr.RunTaskOnK8sNodes(resetKubeCluster, true)
}
@ -78,7 +78,7 @@ var cmdsList = []string{
func resetKubeCluster(mgr *manager.Manager, node *kubekeyapi.HostCfg, conn ssh.Connection) error {
_, err := mgr.Runner.RunCmd("sudo -E /bin/sh -c \"/usr/local/bin/kubeadm reset -f\"")
if err != nil {
return errors.Wrap(errors.WithStack(err), "failed to reset kube cluster")
return errors.Wrap(errors.WithStack(err), "Failed to reset kube cluster")
}
fmt.Println(strings.Join(cmdsList, " && "))
mgr.Runner.RunCmd(fmt.Sprintf("sudo -E /bin/sh -c \"%s\"", strings.Join(cmdsList, " && ")))

16
pkg/scale/scale.go
View File

@ -14,25 +14,25 @@ import (
func ScaleCluster(clusterCfgFile string, logger *log.Logger, pkg string, verbose bool) error {
cfg, err := config.ParseClusterCfg(clusterCfgFile, "", logger)
if err != nil {
return errors.Wrap(err, "failed to download cluster config")
return errors.Wrap(err, "Failed to download cluster config")
}
//out, _ := json.MarshalIndent(cfg, "", " ")
//fmt.Println(string(out))
if err := preinstall.Prepare(&cfg.Spec, logger); err != nil {
return errors.Wrap(err, "failed to load kube binarys")
return errors.Wrap(err, "Failed to load kube binarys")
}
return NewExecutor(&cfg.Spec, logger, verbose).Execute()
}
func ExecTasks(mgr *manager.Manager) error {
scaleTasks := []manager.Task{
{Task: preinstall.InitOS, ErrMsg: "failed to download kube binaries"},
{Task: docker.InstallerDocker, ErrMsg: "failed to install docker"},
{Task: kubernetes.SyncKubeBinaries, ErrMsg: "failed to sync kube binaries"},
//{Task: kubernetes.ConfigureKubeletService, ErrMsg: "failed to sync kube binaries"},
//{Task: kubernetes.GetJoinNodesCmd, ErrMsg: "failed to get join cmd"},
{Task: kubernetes.JoinNodesToCluster, ErrMsg: "failed to join node"},
{Task: preinstall.InitOS, ErrMsg: "Failed to download kube binaries"},
{Task: docker.InstallerDocker, ErrMsg: "Failed to install docker"},
{Task: kubernetes.SyncKubeBinaries, ErrMsg: "Failed to sync kube binaries"},
//{Task: kubernetes.ConfigureKubeletService, ErrMsg: "Failed to sync kube binaries"},
//{Task: kubernetes.GetJoinNodesCmd, ErrMsg: "Failed to get join cmd"},
{Task: kubernetes.JoinNodesToCluster, ErrMsg: "Failed to join node"},
}
for _, task := range scaleTasks {

6
pkg/util/manager/task-control.go
View File

@ -31,13 +31,13 @@ func (t *Task) Run(mgrTask *Manager) error {
var lastError error
err := wait.ExponentialBackoff(backoff, func() (bool, error) {
if lastError != nil {
mgrTask.Logger.Warn("Retrying task…")
mgrTask.Logger.Warn("Retrying task ...")
}
lastError = t.Task(mgrTask)
if lastError != nil {
mgrTask.Logger.Warn("Task failed…")
mgrTask.Logger.Warn("Task failed ...")
if mgrTask.Verbose {
mgrTask.Logger.Warnf("error was: %s", lastError)
mgrTask.Logger.Warnf("error: %s", lastError)
}
return false, nil
}

2
pkg/util/manager/task-run.go
View File

@ -29,7 +29,7 @@ func (mgr *Manager) runTask(node *kubekeyapi.HostCfg, task NodeTask, prefixed bo
// because we want to re-use it for future task)
conn, err = mgr.Connector.Connect(*node)
if err != nil {
return errors.Wrapf(err, "failed to connect to %s", node.Address)
return errors.Wrapf(err, "Failed to connect to %s", node.Address)
}
prefix := ""

10
pkg/util/runner/runner.go
View File

@ -22,7 +22,7 @@ type TemplateVariables map[string]interface{}
func (r *Runner) RunCmd(cmd string) (string, error) {
if r.Conn == nil {
return "", errors.New("runner is not tied to an opened SSH connection")
return "", errors.New("Runner is not tied to an opened SSH connection")
}
output, _, err := r.Conn.Exec(cmd, r.Host)
if !r.Verbose {
@ -49,18 +49,18 @@ func (r *Runner) RunCmd(cmd string) (string, error) {
func (r *Runner) ScpFile(src, dst string) error {
if r.Conn == nil {
return errors.New("runner is not tied to an opened SSH connection")
return errors.New("Runner is not tied to an opened SSH connection")
}
err := r.Conn.Scp(src, dst)
if err != nil {
if r.Verbose {
fmt.Printf("push %s to %s:%s Failed\n", src, r.Host.Address, dst)
fmt.Printf("Push %s to %s:%s Failed\n", src, r.Host.Address, dst)
return err
}
} else {
if r.Verbose {
fmt.Printf("push %s to %s:%s Done\n", src, r.Host.Address, dst)
fmt.Printf("Push %s to %s:%s Done\n", src, r.Host.Address, dst)
}
}
return nil
@ -70,7 +70,7 @@ func (r *Runner) ScpFile(src, dst string) error {
func (r *Runner) WaitForPod(namespace string, name string, timeout time.Duration) error {
cmd := fmt.Sprintf(`sudo kubectl --kubeconfig=/etc/kubernetes/admin.conf -n "%s" get pod "%s" -o jsonpath='{.status.phase}' --ignore-not-found`, namespace, name)
if !r.WaitForCondition(cmd, timeout, IsRunning) {
return errors.Errorf("timed out while waiting for %s/%s to come up for %v", namespace, name, timeout)
return errors.Errorf("Timed out while waiting for %s/%s to come up for %v", namespace, name, timeout)
}
return nil

2
pkg/util/ssh/dialer.go
View File

@ -32,7 +32,7 @@ func (dialer *Dialer) Tunnel(host kubekeyapi.HostCfg) (Tunneler, error) {
tunn, ok := conn.(Tunneler)
if !ok {
err = errors.New("unable to assert Tunneler")
err = errors.New("Unable to assert Tunneler")
}
return tunn, err

2
pkg/util/ssh/sftp.go
View File

@ -17,7 +17,7 @@ func (c *connection) sftp() (*sftp.Client, error) {
if c.sftpclient == nil {
s, err := sftp.NewClient(c.sshclient)
if err != nil {
return nil, errors.Wrap(err, "failed to get sftp.Client")
return nil, errors.Wrap(err, "Failed to get sftp.Client")
}
c.sftpclient = s
}

18
pkg/util/ssh/ssh.go
View File

@ -60,21 +60,21 @@ type SSHCfg struct {
func validateOptions(cfg SSHCfg) (SSHCfg, error) {
if len(cfg.Username) == 0 {
return cfg, errors.New("no username specified for SSH connection")
return cfg, errors.New("No username specified for SSH connection")
}
if len(cfg.Address) == 0 {
return cfg, errors.New("no address specified for SSH connection")
return cfg, errors.New("No address specified for SSH connection")
}
if len(cfg.Password) == 0 && len(cfg.PrivateKey) == 0 && len(cfg.KeyFile) == 0 && len(cfg.AgentSocket) == 0 {
return cfg, errors.New("must specify at least one of password, private key, keyfile or agent socket")
return cfg, errors.New("Must specify at least one of password, private key, keyfile or agent socket")
}
if len(cfg.KeyFile) > 0 {
content, err := ioutil.ReadFile(cfg.KeyFile)
if err != nil {
return cfg, errors.Wrapf(err, "failed to read keyfile %q", cfg.KeyFile)
return cfg, errors.Wrapf(err, "Failed to read keyfile %q", cfg.KeyFile)
}
cfg.PrivateKey = string(content)
@ -113,7 +113,7 @@ type connection struct {
func NewConnection(cfg SSHCfg) (Connection, error) {
cfg, err := validateOptions(cfg)
if err != nil {
return nil, errors.Wrap(err, "failed to validate ssh connection options")
return nil, errors.Wrap(err, "Failed to validate ssh connection options")
}
authMethods := make([]ssh.AuthMethod, 0)
@ -125,7 +125,7 @@ func NewConnection(cfg SSHCfg) (Connection, error) {
if len(cfg.PrivateKey) > 0 {
signer, parseErr := ssh.ParsePrivateKey([]byte(cfg.PrivateKey))
if parseErr != nil {
return nil, errors.Wrap(parseErr, "the given SSH key could not be parsed (note that password-protected keys are not supported)")
return nil, errors.Wrap(parseErr, "The given SSH key could not be parsed (note that password-protected keys are not supported)")
}
authMethods = append(authMethods, ssh.PublicKeys(signer))
}
@ -219,7 +219,7 @@ func NewConnection(cfg SSHCfg) (Connection, error) {
func (c *connection) File(filename string, flags int) (io.ReadWriteCloser, error) {
sftpClient, err := c.sftp()
if err != nil {
return nil, errors.Wrap(err, "failed to open SFTP")
return nil, errors.Wrap(err, "Failed to open SFTP")
}
return sftpClient.OpenFile(filename, flags)
@ -254,7 +254,7 @@ func (c *connection) Close() error {
func (c *connection) Exec(cmd string, host *v1alpha1.HostCfg) (string, int, error) {
sess, err := c.session()
if err != nil {
return "", 0, errors.Wrap(err, "failed to get SSH session")
return "", 0, errors.Wrap(err, "Failed to get SSH session")
}
defer sess.Close()
modes := ssh.TerminalModes{
@ -311,7 +311,7 @@ func (c *connection) Exec(cmd string, host *v1alpha1.HostCfg) (string, int, erro
exitCode = 1
}
outStr := strings.TrimPrefix(string(output), fmt.Sprintf("[sudo] password for %s:", host.User))
return strings.TrimSpace(outStr), exitCode, errors.Wrapf(err, "failed to exec command: %s", cmd)
return strings.TrimSpace(outStr), exitCode, errors.Wrapf(err, "Failed to exec command: %s", cmd)
}
func (c *connection) session() (*ssh.Session, error) {

4
pkg/util/util.go
View File

@ -65,7 +65,7 @@ func Render(tmpl *template.Template, variables map[string]interface{}) (string,
//buf.WriteString("\n\n")
if err := tmpl.Execute(&buf, variables); err != nil {
return "", errors.Wrap(err, "failed to render cmd or script template")
return "", errors.Wrap(err, "Failed to render cmd or script template")
}
return buf.String(), nil
}
@ -209,7 +209,7 @@ func GetLocalIP() (string, error) {
}
}
}
return "", errors.New("valid local IP not found !")
return "", errors.New("valid local IP not found!")
}
func LocalIP() string {