使用GO实现游戏批量搭服的小程序,

package main

import (
	"archive/zip"
	"bufio"
	"bytes"
	"crypto/md5"
	"encoding/gob"
	"flag"
	"fmt"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"os"
	"strings"
	"text/template"
	"time"
)

type Template struct {
	Name       string
	Md5        string
	ConfigList []string
}

var url string
var homedir string
var Temp_Path map[string]string = make(map[string]string)
var HeadList []string
var Replational []string

func main() {
	flag.StringVar(&url, "u", "http://127.0.0.1:1789", "Specify server address.")
	flag.StringVar(&homedir, "d", "/data/gamehome", "Specify home directory.")
	L := flag.Bool("l", false, "local generation config.")
	cfgTempRelational := flag.String("c", "CfgTempRelational.ini", "Specify CfgTempRelational config")
	relationalTable := flag.String("r", "RelationalTable.ini", "Specify RelationalTable config.")
	name := flag.String("n", "server.zip", "Specify server package name.")
	flag.Parse()
	if !strings.HasSuffix(homedir, "/") {
		homedir = homedir + "/"
	}
	if *L {
		if Unzip(*name, homedir) {
			LocalReplace(*cfgTempRelational, *relationalTable)
			return
		}
		return
	}
	fmt.Printf("%s Start request template info.From %s\n", GetNow(), url)
	req, err := http.Get(url)
	if err != nil {
		fmt.Printf("%s Request info error\n", GetNow())
		return
	}
	var TemplateInfo Template
	func(t *Template) {
		defer req.Body.Close()
		err := gob.NewDecoder(req.Body).Decode(t)
		if err != nil {
			fmt.Printf("%s Parse template info:\n%s\n", GetNow(), err)
			os.Exit(1)
		}
	}(&TemplateInfo)
	fmt.Printf("%s Parse Template info is OK.\n", GetNow())
	fmt.Printf("%s Print Template Info:\n%s\n", GetNow(), TemplateInfo)
	if Download(TemplateInfo) {
		if !Unzip(TemplateInfo.Name, homedir) {
			fmt.Printf("%s Unzip file error.\n", GetNow())
			os.Exit(2)
		}
	}
	ConfigDownload(TemplateInfo.ConfigList)
}

func LocalReplace(CfgTempRelational, RelationalTable string) {
	fmt.Printf("start parse %s\n", CfgTempRelational)
	GetPathConfig(CfgTempRelational)
	fmt.Printf("start parse %s\n", RelationalTable)
	ParseServerConfig(RelationalTable)
	localip := GetLocalIP()
	fmt.Printf("get local ip %s\n", localip)
	for _, v := range localip {
		info := Matching(v)
		if len(info) > 0 {
			valueList := Split(info)
			fmt.Printf("Match values %s\n", valueList)
			Key_Map := Merge(valueList)
			for k, v := range Temp_Path {
				fmt.Printf("create config %s%s\n", homedir, v)
				File, err := os.Create(fmt.Sprintf("%s%s", homedir, v))
				if err != nil {
					fmt.Printf("%s create %s faild\n%s\n", GetNow(), v, err)
					os.Exit(1)
				}
				ExecuteReplace(File, k, Key_Map)
			}
			return
		}
	}
}

func ConfigDownload(TemplateList []string) {
	for _, v := range TemplateList {
		resp, err := http.Get(fmt.Sprintf("%s/config?key=%s", url, v))
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
		defer resp.Body.Close()

		path := homedir + resp.Header.Get("path")
		fmt.Printf("%s Start create %s file\n", GetNow(), path)
		File, err := os.Create(path)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
		io.Copy(File, resp.Body)
	}
	fmt.Printf("%s Create config is Ok.\n", GetNow())
}

func Download(TemplateInfo Template) bool {
	_, err := os.Lstat(TemplateInfo.Name)
	if err == nil {
		if Md5(TemplateInfo.Name) == TemplateInfo.Md5 {
			fmt.Printf("%s local is exist %s\n", GetNow(), TemplateInfo.Name)
			return true
		}
	}
	fmt.Printf("%s Start download %s\n", GetNow(), TemplateInfo.Name)
	u := fmt.Sprintf("%s/template/%s", url, TemplateInfo.Name)
	req, err := http.Get(u)
	if err != nil {
		fmt.Printf("%s Open %s error:\n%s\n", GetNow(), u, err)
		return false
	}
	defer req.Body.Close()
	File, err := os.Create(TemplateInfo.Name)
	if err != nil {
		fmt.Printf("%s Create %s error:\n%s\n", GetNow(), TemplateInfo.Name, err)
		return false
	}
	io.Copy(File, req.Body)
	if Md5(TemplateInfo.Name) != TemplateInfo.Md5 {
		fmt.Printf("%s Check md5 faild!\n", GetNow())
		return false
	}
	return true
}

func Md5(path string) string {
	fmt.Printf("%s Check md5 %s\n", GetNow(), path)
	File, err := os.Open(path)
	if err != nil {
		fmt.Printf("%s Check md5 error:\n%s\n", GetNow(), err)
		return ""
	}
	m := md5.New()
	io.Copy(m, File)
	return fmt.Sprintf("%X", string(m.Sum([]byte{})))
}

func Unzip(filename, dir string) bool {
	fmt.Printf("%s Unzip to %s\n", GetNow(), dir)
	File, err := zip.OpenReader(filename)
	if err != nil {
		fmt.Printf("%s Open zip faild:\n%s\n", GetNow(), err)
		return false
	}
	defer File.Close()
	for _, v := range File.File {
		v.Name = fmt.Sprintf("%s%s", dir, v.Name)
		info := v.FileInfo()
		if info.IsDir() {
			err := os.MkdirAll(v.Name, 0644)
			if err != nil {
				fmt.Printf("%s Create direcotry %s faild:\n%s\n", GetNow(), v.Name, err)
				return false
			}
			continue
		}
		srcFile, err := v.Open()
		if err != nil {
			fmt.Printf("%s Read from zip faild:\n%s\n", GetNow(), err)
			return false
		}
		defer srcFile.Close()
		newFile, err := os.Create(v.Name)
		if err != nil {
			fmt.Printf("%s Create file faild:\n%s\n", GetNow(), err)
			return false
		}
		io.Copy(newFile, srcFile)
		newFile.Close()
	}
	return true
}

func ExecuteReplace(w *os.File, temp_path string, funcs map[string]string) error {
	fmt.Println(funcs)
	T := template.New("")
	buf, err := ioutil.ReadFile(temp_path)
	if err != nil {
		return err
	}
	T, err = T.Parse(string(buf))
	if err != nil {
		return err
	}
	err = T.Execute(w, funcs)
	if err != nil {
		return err
	}
	return nil
}

func GetPathConfig(path string) {
	File, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		os.Exit(4)
	}
	defer File.Close()
	M := make(map[string]string)
	Buf := bufio.NewReader(File)
	var linenum int = 1
	for {
		line, _, err := Buf.ReadLine()
		if err != nil {
			if err.Error() == "EOF" {
				break
			}
			fmt.Println(err)
			os.Exit(5)
		}
		if len(bytes.TrimSpace(line)) == 0 {
			continue
		}
		list := bytes.Split(line, []byte("="))
		if len(list) != 2 {
			fmt.Printf("check config %s ,line %d\n", path, linenum)
			os.Exit(6)
		}
		key := string(bytes.TrimSpace(list[0]))
		value := string(bytes.TrimSpace(list[1]))
		TestPath(key)
		M[key] = value
		Check(key)
		linenum++
	}
	if len(M) < 1 {
		fmt.Printf("config %s can't emptey!\n", path)
		os.Exit(7)
	}
	Temp_Path = M
}
func TestPath(path string) {
	info, err := os.Lstat(path)
	if err != nil {
		fmt.Printf("check %s .error_info :%s", path, err)
		os.Exit(9)
	}
	if info.IsDir() {
		fmt.Printf("check %s is directory", path)
		os.Exit(10)
	}
	return
}
func Merge(list []string) map[string]string {
	ExecuteReplaceValue := make(map[string]string)
	for k, v := range HeadList {
		ExecuteReplaceValue[v] = list[k]
	}
	return ExecuteReplaceValue
}

func ParseServerConfig(path string) {
	File, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		os.Exit(1)
	}
	defer File.Close()
	buf := bufio.NewReader(File)
	var linenum int = 1
	for i := 0; i < 1001; i++ { //just init top 1000
		line, _, err := buf.ReadLine()
		if err != nil {
			if err.Error() == "EOF" {
				break
			}
			fmt.Println(err)
			os.Exit(1)
		}
		if len(HeadList) == 0 {
			list := Split(string(line))
			if len(list) > 0 {
				HeadList = list
			}
			continue
		}
		list := Split(string(line))
		if len(list) != len(HeadList) {
			fmt.Printf("Line %d parse error.", linenum)
			continue
		}
		Replational = append(Replational, string(line))
	}
	if len(Replational) <= 0 {
		fmt.Println("read config error.")
		os.Exit(1)
	}
}

func Split(str string) []string {
	var l []string
	list := strings.Split(str, " ")
	for _, v := range list {
		if len(v) == 0 {
			continue
		}
		if strings.Contains(v, "	") {
			list := strings.Split(v, "	")
			for _, v := range list {
				if len(v) == 0 {
					continue
				}
				l = append(l, v)
			}
			continue
		}
		l = append(l, v)
	}
	return l
}
func GetLocalIP() []string {
	list, err := net.InterfaceAddrs()
	if err != nil {
		fmt.Println(err)
		return []string{}
	}
	var l []string
	for _, v := range list {
		if strings.Contains(v.String(), ":") {
			continue
		}
		ip := strings.Split(v.String(), "/")
		if len(ip) != 2 {
			continue
		}
		l = append(l, ip[0])
	}
	return l
}
func Matching(srcip string) string {
	for _, v := range Replational {
		if strings.Contains(v, srcip) {
			return v
		}
	}
	return ""
}

func GetNow() string {
	return time.Now().Format("2006-01-02 15:04:05")
}

func Check(path string) {
	File, err := os.Open(path)
	if err != nil {
		fmt.Println(err)
		return
	}
	defer File.Close()
	buf := bufio.NewReader(File)
	var num int = 1
	var errornum int = 0
	s := []byte("{{")
	e := []byte("}}")
	for {
		line, _, err := buf.ReadLine()
		if err != nil {
			if err.Error() == "EOF" {
				break
			}
			return
		}
		if bytes.Count(line, s) != bytes.Count(line, e) {
			fmt.Printf("Line%d: %s\n", num, string(line))
			errornum++
			continue
		}
		if bytes.Count(line, []byte("{{.}}")) != 0 {
			fmt.Printf("Line%d: %s\n", num, string(line))
			errornum++
			continue
		}

		for i := 0; i < bytes.Count(line, s); i++ {
			first := bytes.Index(line, s)
			last := bytes.Index(line, e)
			if first == -1 || last == -1 {
				continue
			}
			if bytes.Index(line[first:last], []byte("{{.")) != 0 {
				fmt.Printf("Error Line %d: %s\n", num, string(line))
				errornum++
				break
			}
			line = line[last:]
		}
	}
	if errornum != 0 {
		fmt.Printf("Error num %d From %s\n", errornum, path)
		return
	}
	return
}