Go1.7.3运维文件夹比较工具,可以支持远程比较

package main

import (
"bufio"
"bytes"
"crypto/md5"
"encoding/hex"
"errors"
"flag"
"fmt"
"hash"
"io"
"log"
"net/http"
"os"
"path/filepath"
"strings"
)

type compareConfig struct {
dpath   string
spath   string
quick   bool
diff    string
output  string
split   string
getmd5  bool
md5list string
laddr   string
}

var compareCFG compareConfig

func init() {
flag.StringVar(&compareCFG.spath, "s", "", `-s="server" 指定源目录或文件`)
flag.StringVar(&compareCFG.dpath, "d", "", `-d="server_back" 指定目标目录或文件`)
flag.StringVar(&compareCFG.diff, "c", "", `-c="diff" 把源目录不匹配的文件提出来,为空则不拷贝`)
flag.StringVar(&compareCFG.output, "o", "", `指定匹配的结果输出文件,不指定则输出到标准输出`)
flag.StringVar(&compareCFG.split, "S", "    ", `-S=" " 验证指定路径文件的md5值的时候指定md5和路径的分隔符`)
flag.StringVar(&compareCFG.md5list, "F", "", `-F="md5list" 验证指定路径文件的md5值,每行一条数据,md5码和文件路径,结合-d使用`)
flag.BoolVar(&compareCFG.quick, "q", true, `-q=false 快速模式即用文件内容判断文件是否一致,如果为false则使用md5比较`)
flag.BoolVar(&compareCFG.getmd5, "m", false, "-m true 获取指定目录下所有文件的md5,结合-s指定目录使用")
flag.StringVar(&compareCFG.laddr, "l", "", `-l="192.168.1.2:80" 通过http协议共享md5列表,结合-m=true使用`)
flag.Parse()
}

func main() {
if len(os.Args) <= 1 {
flag.PrintDefaults()
return
}
var w = os.Stdout
if compareCFG.output != "" {
var err error
w, err = os.Create(compareCFG.output)
if err != nil {
log.Println(err)
return
}
}

if compareCFG.getmd5 {
if compareCFG.spath != "" {
if compareCFG.laddr != "" {
err := server(compareCFG.laddr, compareCFG.spath)
if err != nil {
log.Println(err)
}
return
}
err := GetMd5(compareCFG.spath, w)
if err != nil {
log.Println(err)
}
} else {
log.Println("必须指定目录路径")
}
return
}

if compareCFG.spath != "" && compareCFG.dpath != "" {
comparePath(compareCFG.spath, compareCFG.dpath, compareCFG.diff, w, compareCFG.quick)
return
}

if compareCFG.md5list != "" && compareCFG.dpath != "" {
var r io.ReadCloser
var err error
defer func() {
if r != nil {
r.Close()
}
}()

if strings.HasPrefix(compareCFG.md5list, "http") {
//  client := &http.Client{Transport: &http.Transport{TLSClientConfig: &tls.Config{InsecureSkipVerify: true}}}
resp, err := http.Get(compareCFG.md5list)
if err != nil {
log.Println(err)
return
}
r = resp.Body
} else {
r, err = os.Open(compareCFG.md5list)
if err != nil {
log.Println(err)
return
}
}
compareFromFile(r, compareCFG.dpath, compareCFG.split, w)
return
}
flag.PrintDefaults()
}

func compareFromFile(File io.Reader, dir, split string, w io.Writer) {
dir = formatSeparator(dir)
buf := bufio.NewReader(File)
h := md5.New()
var m, dfile, md string
var count int = 0
for {
count += 1
line, _, err := buf.ReadLine()
if err != nil {
if err != io.EOF {
log.Println(err)
}
break
}

list := bytes.Split(line, []byte(split))
if len(list) != 2 {
log.Printf("第%d行数据无效,确认分隔符\n", count)
continue
}
dfile = string(bytes.TrimSpace(list[1]))
md, err = getmd5(h, dir+dfile)
if err != nil {
fmt.Fprintf(w, "文件不存在:\t%s\n", dfile)
continue
}

m = string(bytes.TrimSpace(list[0]))
if md != m {
fmt.Fprintf(w, "内容不一致:\t%s\n", dfile)
}
}
}

func comparePath(spath, dpath, diff string, w io.Writer, quick bool) {
sinfo, err := os.Lstat(spath)
if err != nil {
log.Println(err)
return
}
dinfo, err := os.Lstat(dpath)
if err != nil {
log.Println(err)
return
}

if !sinfo.IsDir() && !dinfo.IsDir() {
if comparefile(spath, dpath, quick) {
fmt.Fprintf(w, "内容一致:\t%s\n", dinfo.Name())
} else {
fmt.Fprintf(w, "内容不一致:\t%s\n", dinfo.Name())
}
return
}

if !(sinfo.IsDir() || dinfo.IsDir()) {
log.Println("原路径和目标路径必须同时为文件或者同时为目录")
return
}

if diff != "" {
diff = formatSeparator(diff)
os.RemoveAll(diff)
os.MkdirAll(diff, 0666)
}

spath = formatSeparator(spath)
dpath = formatSeparator(dpath)

filepath.Walk(spath, func(root string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}

path := strings.TrimPrefix(root, spath)
dfile := dpath + path
dinfo, err := os.Lstat(dfile)
if err != nil {
if os.IsNotExist(err) {
fmt.Fprintf(w, "文件不存在:\t%s\n", path)
if diff != "" {
err = copyFile(root, diff+path)
if err != nil {
log.Printf("拷贝文件错误:%s\n", err)
} else {
log.Printf("拷贝文件成功:%s\n", path)
}
}
}
return nil
}

if info.Size() == dinfo.Size() {
if comparefile(root, dfile, quick) {
fmt.Fprintf(w, "内容一致:\t%s\n", path)
return nil
}
}
fmt.Fprintf(w, "内容不一致:\t%s\n", path)
if diff != "" {
err = copyFile(root, diff+path)
if err != nil {
log.Printf("拷贝文件错误:%s\n", err)
} else {
log.Printf("拷贝文件成功:%s\n", path)
}
}
return nil
})
return
}

func comparefile(spath, dpath string, quick bool) bool {
if !quick {
h := md5.New()
smd5, err := getmd5(h, spath)
if err != nil {
return false
}
dmd5, err := getmd5(h, dpath)
if err != nil {
return false
}
return smd5 == dmd5
}

sFile, err := os.Open(spath)
if err != nil {
return false
}
defer sFile.Close()
dFile, err := os.Open(dpath)
if err != nil {
return false
}
defer dFile.Close()
return comparebyte(sFile, dFile)
}

//下面可以代替md5比较.
func comparebyte(sfile io.Reader, dfile io.Reader) bool {
var sbyte []byte = make([]byte, 512)
var dbyte []byte = make([]byte, 512)
var serr, derr error
for {
_, serr = sfile.Read(sbyte)
_, derr = dfile.Read(dbyte)
if serr != nil || derr != nil {
if serr != derr {
return false
}
if serr == io.EOF {
break
}
}
if bytes.Equal(sbyte, dbyte) {
continue
}
return false
}
return true
}

func copyFile(spath, dpath string) error {
err := copyfile(spath, dpath)
if err != nil {
return err
}
info, err := os.Lstat(spath)
if err != nil {
return err
}
os.Chmod(dpath, info.Mode())
os.Chtimes(dpath, info.ModTime(), info.ModTime())
return nil
}

func copyfile(spath, dpath string) error {
basedir := filepath.Dir(dpath)
err := os.MkdirAll(basedir, 0666)
if err != nil {
return err
}
dFile, err := os.Create(dpath)
if err != nil {
return err
}
defer dFile.Close()
sFile, err := os.Open(spath)
if err != nil {
return err
}
defer sFile.Close()
_, err = io.Copy(dFile, sFile)
return err
}

func formatSeparator(path string) string {
Separator := string(filepath.Separator)
if Separator != "/" {
path = strings.Replace(path, "/", Separator, -1)
} else {
path = strings.Replace(path, "\\", Separator, -1)
}
if !strings.HasSuffix(path, Separator) {
path += Separator
}
return path
}

func GetMd5(path string, w io.Writer) error {
path = filepath.Clean(path)
info, err := os.Lstat(path)
if err != nil {
return err
}
if !info.IsDir() {
return errors.New("路径必须是目录")
}
if !strings.HasSuffix(path, string(filepath.Separator)) {
path += string(filepath.Separator)
}
h := md5.New()
return filepath.Walk(path, func(root string, info os.FileInfo, err error) error {
if err != nil {
return err
}
if info.IsDir() {
return nil
}
dir := strings.TrimPrefix(root, path)
m, err := getmd5(h, root)
if err != nil {
log.Println("计算md5失败:", err.Error())
return nil
}
if filepath.Separator == '\\' {
dir = strings.Replace(dir, "\\", "/", -1)
}

fmt.Fprintf(w, "%s\t%s\n", m, dir)
return nil
})
}

func getmd5(md5hash hash.Hash, path string) (string, error) {
File, err := os.Open(path)
if err != nil {
return "", err
}
defer File.Close()
md5hash.Reset()
_, err = io.Copy(md5hash, File)
if err != nil {
return "", err
}
result := make([]byte, 0, 32)
result = md5hash.Sum(result)
return hex.EncodeToString(result), nil
}

func server(laddr string, dirpath string) error {
var list []byte
flush := func() error {
buf := bytes.NewBuffer(nil)
if err := GetMd5(dirpath, buf); err != nil {
return err
}
list = buf.Bytes()
return nil
}

if err := flush(); err != nil {
return err
}

route := func(w http.ResponseWriter, r *http.Request) {
log.Printf("远程地址:%s 访问路径:%s\n", r.RemoteAddr, r.URL.Path)
defer r.Body.Close()
switch r.URL.Path {
default:
fmt.Fprintln(w, `<a href="/getmd5">查看MD5列表</a><br><a href="/flush">刷新MD5列表</a>`)
case "/getmd5":
fmt.Fprintf(w, "%s", list)
case "/flush":
if err := flush(); err != nil {
fmt.Fprintf(w, "刷新md5列表失败,%s\n", err)
} else {
fmt.Fprintln(w, "刷新md5列表成功")
}
}
}

http.HandleFunc("/", route)
return http.ListenAndServe(laddr, nil)
}