添加server操作

Author: hXoreyer

cmd/mysqlNew.go

@@ -144,8 +144,5 @@ func toFile(name string) {
 
 func isExists(name string) bool {
 	_, err := os.Stat(name)
-	if os.IsNotExist(err) {
-		return false
-	}
-	return true
+	return !os.IsNotExist(err)
 }

cmd/server.go

@@ -0,0 +1,55 @@
+/*
+Copyright © 2023 hxoreyer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+package cmd
+
+import (
+	"fmt"
+
+	"github.com/hxoreyer/ktool/ctl"
+	"github.com/spf13/cobra"
+)
+
+// serverCmd represents the server command
+var serverCmd = &cobra.Command{
+	Use:   "server",
+	Short: "操作server",
+	Long:  `可以向server发起上传下载等命令`,
+	Run: func(cmd *cobra.Command, args []string) {
+		path, err := cmd.Flags().GetString("path")
+		if err != nil {
+			fmt.Println(err)
+			return
+		}
+		if !isExists(path) {
+			fmt.Println(path, "is not exist.")
+			return
+		}
+		c := ctl.NewYaml(path)
+		c.Run()
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(serverCmd)
+
+	serverCmd.Flags().StringP("path", "p", "./server.yaml", "服务器配置")
+}

ctl/bar.go

@@ -0,0 +1,53 @@
+package ctl
+
+import "fmt"
+
+type KBar struct {
+	percent int64  //百分比
+	cur     int64  //当前进度位置
+	total   int64  //总进度
+	rate    string //进度条
+	graph   string //显示符号
+	text    string //后缀内容
+}
+
+func (bar *KBar) New(start, total int64, text string) {
+	bar.cur = start
+	bar.total = total
+	bar.text = text
+	if bar.graph == "" {
+		bar.graph = "█"
+	}
+	bar.percent = bar.getPercent()
+	for i := 0; i < int(bar.percent); i += 2 {
+		bar.rate += bar.graph //初始化进度条位置
+	}
+}
+
+func (bar *KBar) Play(cur int64) {
+	bar.cur = cur
+	last := bar.percent
+	bar.percent = bar.getPercent()
+	if bar.percent != last && bar.percent%2 == 0 {
+		for i := 0; i < int(bar.percent-last)/2; i++ {
+			bar.rate += bar.graph
+		}
+	} else {
+		bar.percent = last
+	}
+	fmt.Printf("\r [%-51s]%3d%%  %8d/%-10d[%-s]", bar.rate, bar.percent, bar.cur, bar.total, bar.text)
+}
+
+func (bar *KBar) getPercent() int64 {
+	pc := int64(float32(bar.cur) / float32(bar.total) * 100)
+	return pc
+}
+
+func (bar *KBar) NewWithGraph(start, total int64, graph string, text string) {
+	bar.graph = graph
+	bar.New(start, total, text)
+}
+
+func (bar *KBar) Finish() {
+	fmt.Println()
+}

ctl/clientConfig.go

@@ -0,0 +1,230 @@
+package ctl
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path"
+	"sync"
+	"time"
+
+	"github.com/pkg/sftp"
+	"golang.org/x/crypto/ssh"
+)
+
+const (
+	Windows = "windows"
+	Linux   = "linux"
+	Macos   = "darwin"
+)
+
+type ClientConfig struct {
+	Host       string
+	Port       string
+	Username   string
+	Password   string
+	sshClient  *ssh.Client
+	sftpClient *sftp.Client
+	LastResult string
+}
+
+func CreateClient(host string, port string, username, password string) *ClientConfig {
+	cf := &ClientConfig{}
+	var (
+		sshClient  *ssh.Client
+		sftpClient *sftp.Client
+		err        error
+	)
+
+	cf.Host = host
+	cf.Port = port
+	cf.Username = username
+	cf.Password = password
+
+	config := ssh.ClientConfig{
+		User: cf.Username,
+		Auth: []ssh.AuthMethod{ssh.Password(cf.Password)},
+		HostKeyCallback: func(hostname string, remote net.Addr, key ssh.PublicKey) error {
+			return nil
+		},
+		Timeout: 10 * time.Second,
+	}
+
+	addr := fmt.Sprintf("%s:%s", cf.Host, cf.Port)
+
+	if sshClient, err = ssh.Dial("tcp", addr, &config); err != nil {
+		log.Fatalf("connect ssh error: %s", err.Error())
+		return nil
+	}
+
+	cf.sshClient = sshClient
+
+	if sftpClient, err = sftp.NewClient(sshClient); err != nil {
+		log.Fatalf("connect sftp error: %s", err.Error())
+		return nil
+	}
+
+	cf.sftpClient = sftpClient
+	return cf
+}
+
+func (cf *ClientConfig) RunShell(shell string) string {
+	var (
+		session *ssh.Session
+		err     error
+	)
+
+	if session, err = cf.sshClient.NewSession(); err != nil {
+		log.Fatalf("new session error: %s", err.Error())
+	}
+	defer session.Close()
+
+	var output bytes.Buffer
+	session.Stdout = &output
+	go func() {
+		var tmp string
+		for {
+			tmp = output.String()
+			if cf.LastResult != tmp {
+				cmd := exec.Command("cmd", "/C", "cls")
+				cmd.Stdout = os.Stdout
+				cmd.Run()
+				fmt.Println(tmp)
+				cf.LastResult = tmp
+			}
+		}
+	}()
+	if err := session.Run(shell); err != nil {
+		fmt.Println(shell)
+		log.Fatalf("run shell error: %s", err.Error())
+	} else {
+		cf.LastResult = output.String()
+	}
+	return cf.LastResult
+}
+
+func (cf *ClientConfig) Upload(srcPath, dstPath string) {
+	fmt.Println("searching...")
+	s, err := os.Stat(srcPath)
+	if err != nil {
+		panic(err)
+	}
+	if s.IsDir() {
+		cf.uploadDirectory(srcPath, dstPath)
+	} else {
+		cf.uploadFile(srcPath, dstPath)
+	}
+}
+
+func (cf *ClientConfig) uploadDirectory(srcPath, dstPath string) {
+
+	localFiles, err := ioutil.ReadDir(srcPath)
+	if err != nil {
+		panic(err)
+	}
+	cf.sftpClient.Mkdir(dstPath)
+
+	for _, backupDir := range localFiles {
+		localFilePath := path.Join(srcPath, backupDir.Name())
+		remoteFilePath := path.Join(dstPath, backupDir.Name())
+
+		if backupDir.IsDir() {
+			cf.sftpClient.Mkdir(remoteFilePath)
+			cf.uploadDirectory(localFilePath, remoteFilePath)
+		} else {
+			cf.uploadFile(localFilePath, remoteFilePath)
+		}
+	}
+}
+
+func (cf *ClientConfig) uploadFile(srcPath, dstPath string) {
+	srcFile, err := os.Open(srcPath)
+	if err != nil {
+		panic("os.Open error : " + err.Error() + srcPath)
+	}
+
+	defer srcFile.Close()
+
+	dstFile, err := cf.sftpClient.Create(dstPath)
+	if err != nil {
+		panic("sftpClient.Create error : " + err.Error())
+
+	}
+
+	defer dstFile.Close()
+	ff, err := ioutil.ReadAll(srcFile)
+	if err != nil {
+		panic("ReadAll error : " + err.Error())
+	}
+	wg := sync.WaitGroup{}
+	wg.Add(1)
+	go func() {
+		stat, _ := dstFile.Stat()
+		state2, _ := srcFile.Stat()
+		bar := KBar{}
+		bar.New(stat.Size(), state2.Size(), dstFile.Name())
+		for {
+			stat, _ := dstFile.Stat()
+			if stat.Size() < state2.Size() {
+				bar.Play(stat.Size())
+				time.Sleep(time.Duration(100 * time.Millisecond))
+			} else {
+				bar.Play(stat.Size())
+				bar.Finish()
+				break
+			}
+		}
+		wg.Done()
+	}()
+	dstFile.Write(ff)
+	dstFile.Chmod(0777)
+	wg.Wait()
+
+}
+
+func (cf *ClientConfig) Download(srcPath, dstPath string) {
+	srcFile, _ := cf.sftpClient.Open(srcPath)
+	dstFile, _ := os.Create(dstPath)
+
+	defer func() {
+		_ = srcFile.Close()
+		_ = dstFile.Close()
+	}()
+
+	if _, err := srcFile.WriteTo(dstFile); err != nil {
+		log.Fatalf("download erroe: %s", err.Error())
+	}
+
+	fmt.Println("download success")
+}
+
+func (cf *ClientConfig) waitForQuit() {
+	c := make(chan os.Signal)
+	signal.Notify(c, os.Interrupt, os.Kill)
+	<-c
+}
+
+func BuildExec(path, system, name string) {
+	var cmdStr string
+	if system == Windows {
+		cmdStr = fmt.Sprintf("cd %s&SET CGO_ENABLED=0&SET GOOS=%s&SET GOARCH=amd64&go build %s", path, system, name)
+	} else {
+		cmdStr = fmt.Sprintf("cd %s&CGO_ENABLED=0&GOOS=%s&GOARCH=amd64&go build %s", path, system, name)
+	}
+	cmd := exec.Command("cmd", "/C", cmdStr)
+	_ = cmd.Run()
+}
+
+func (cf *ClientConfig) Run(procName string) {
+	defer func() {
+		pid := cf.RunShell(fmt.Sprintf("pgrep %s", path.Base(procName)))
+		cf.RunShell(fmt.Sprintf("kill %s", pid))
+	}()
+	go cf.RunShell(procName)
+	cf.waitForQuit()
+}