add security

sunty

2020-11-23 b8bce69ca2d989b54addd89bf067ba0a54b2da02

add security

 EsClient.go

@@ -3,60 +3,18 @@
import (
    "basic.com/pubsub/protomsg.git"
    "bytes"
    "encoding/base64"
    "encoding/json"
    "errors"
    "fmt"
    "io"
    "github.com/spf13/viper"
    "io/ioutil"
    "log"
    "math"
    "net/http"
    "strings"
    "time"
)

func GetEsDataReq(url string, parama string, isSource bool) map[string]interface{} {
    //fmt.Println("es 查询请求路径" + url) //  配置信息 获取
    var dat map[string]interface{}
    req, err := http.NewRequest("POST", url, strings.NewReader(parama))
    req.Header.Add("Content-Type", "application/json")
    timeout := time.Duration(10 * time.Second) //超时时间50ms
    client := &http.Client{Timeout: timeout}
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println(err)
        return dat
    }
    defer resp.Body.Close()
    dec := json.NewDecoder(resp.Body)
    if err := dec.Decode(&dat); err == io.EOF {
        fmt.Println(err.Error())
        return dat
    } else if err != nil {
        fmt.Println(err.Error())
        return dat
    }
    // 是否需要 解析 es 返回的 source
    if isSource {
        dat = dat["hits"].(map[string]interface{})
        var data = make(map[string]interface{}, 2)
        data["total"] = dat["total"]
        sources := []interface{}{}
        for _, value := range dat["hits"].([]interface{}) {
            source := value.(map[string]interface{})["_source"].(map[string]interface{})
            //source["id"] = source["id"]
            /*sdkType := source["sdkType"]
            if sdkType != nil {
                sdk, _ := strconv.Atoi(sdkType.(string))
                source["sdkType"] = sdkTypeToValue(sdk)
            }*/
            sources = append(sources, source)
        }
        data["datalist"] = sources
        return data
    } else {
        return dat
    }
}

func Parsesources(sources []map[string]interface{}) (multiInfos []*protomsg.MultiFeaCache) {
    var ok bool
@@ -1088,6 +1046,7 @@
    }
    request, err := http.NewRequest(method, url, bytes.NewBuffer(parama))
    request.Header.Set("Content-type", "application/json")
    request.Header.Set("Authorization",Token)

    if err != nil {
        fmt.Println("build request fail !")
@@ -1123,3 +1082,27 @@
//            fmt.Println(key, "is nil can not asign") 
//    }
//}

type account struct {
    Username string `mapstructure: "username"`
    Userpassword string `mapstructure: "userpassword"`
}


var Account = &account{}

var Token string

func init() {
    v := viper.New()
    v.SetConfigType("yaml")
    v.SetConfigName("pro")
    v.AddConfigPath("/opt/vasystem/config/")
    err := v.ReadInConfig()
    if err != nil {
        log.Fatal("err on parsing configuration file!",err)
    }
    v.UnmarshalKey("es.account",Account)

    Token = "Basic "+base64.StdEncoding.EncodeToString([]byte(Account.Username+":"+Account.Userpassword))
}

 swfs.go

New file
@@ -0,0 +1,193 @@
package esutil

import (
    "bufio"
    "bytes"
    "errors"
    "fmt"
    "github.com/golang/glog"
    "io"
    "io/ioutil"
    "net/http"
    "os"
    "strings"
    "time"
)

//启动服务
func StartSServer(binPath string) bool {
    resultMsg := CMDSC("sh " + binPath + "/seaweedfs_start.sh")
    if resultMsg == "运行失败" {
        return false
    }
    return true
}

//关闭服务
func StopSServer(binPath string) bool {
    resultMsg := CMDSC("sh " + binPath + "/seaweedfs_stop.sh")
    if resultMsg == "运行失败" {
        return false
    }
    return true
}

type SWFSInfo struct {
    Ip                 string
    DefaultReplication string
    Peers              []string
}

//验证服务
func VerifyServer(ip string) (bool, error) {
    masterUrl := "http://" + ip + ":6333/ui/index.html"
    volumeUrl := "http://" + ip + ":6700/ui/index.html"
    _, mErr := HttpRC("GET", masterUrl, nil)
    if mErr != nil {
        return false, errors.New("master 启动失败")
    }
    _, vErr := HttpRC("GET", volumeUrl, nil)
    if vErr != nil {
        return false, errors.New("volume 启动失败")
    }
    return true, nil

}

//读取配置文件
func GetConfig(configPath string) (SWFSInfo, error) {
    var info SWFSInfo
    cp := configPath + "/seaweedfs_start.sh"
    file, err := os.OpenFile(cp, os.O_RDWR, 0666)
    if err != nil {
        glog.Error("open config file fail, err: ", err)
        return info, err
    }
    defer file.Close()

    buf := bufio.NewReader(file)
    peers := make([]string, 0)
    ip := ""
    defaultReplication := ""
    for {
        line, _, c := buf.ReadLine()
        if c == io.EOF {
            break
        }
        if strings.Contains(string(line), "peers=") {
            rt := strings.Split(string(line), "=")[1]
            if len(rt) < 1 {
                continue
            }
            p := strings.Split(rt, ",")
            peers = append(peers, p...)
        }
        if strings.Contains(string(line), "ip=") {
            ip = strings.Split(string(line), "=")[1]
            continue
        }
        if strings.Contains(string(line), "defaultReplication=") {
            defaultReplication = strings.Split(string(line), "=")[1]
            continue
        }
    }
    info.Ip = ip
    info.DefaultReplication = defaultReplication
    info.Peers = peers
    return info, nil
}

//设置配置文件
func SetConfig(configPath string, ip string, peers []string, defaultReplication string) bool {
    cp := configPath + "/seaweedfs_start.sh"
    file, err := os.OpenFile(cp, os.O_RDWR, 0666)
    if err != nil {
        glog.Error("open config file fail, err: ", err)
        return false
    }
    defer file.Close()

    buf := bufio.NewReader(file)
    output := make([]byte, 0)
    for {
        line, _, c := buf.ReadLine()
        if c == io.EOF {
            break
        }
        if strings.Contains(string(line), "ip=") {
            newline := "ip=" + ip
            line = []byte(newline)
        }
        if strings.Contains(string(line), "peers=") {
            newline := "peers=" + strings.Replace(strings.Trim(fmt.Sprint(peers), "[]"), " ", ",", -1)
            line = []byte(newline)
        }
        if strings.Contains(string(line), "defaultReplication=") {
            newline := "defaultReplication=" + defaultReplication
            line = []byte(newline)
        }
        output = append(output, line...)
        output = append(output, []byte("\n")...)
    }

    if err := writeToFile(cp, output); err != nil {
        glog.Errorf("write config file err: %v", err)
        return false
    }
    return true
}

func writeToFile(filePath string, outPut []byte) error {
    f, err := os.OpenFile(filePath, os.O_WRONLY|os.O_TRUNC, 0600)
    defer f.Close()
    if err != nil {
        return err
    }
    writer := bufio.NewWriter(f)
    _, err = writer.Write(outPut)
    if err != nil {
        return err
    }
    writer.Flush()
    return nil
}

func HttpRCT(method string, url string, parama []byte) (buf []byte, err error) {
    timeout := time.Duration(10 * time.Second)
    client := http.Client{
        Timeout: timeout,
    }
    request, err := http.NewRequest(method, url, bytes.NewBuffer(parama))
    request.Header.Set("Content-type", "application/json")
    request.Header.Add("x-auth-token", "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjQ3ND"+
        "UwMjU5MjMsInVzZXIiOiJ7XCJpZFwiOlwiZTZjY2QzNmQtNGYxNi00NmZjLTg4ZDUtMDczNjU4NjZkMjA1XCIsXCJwZXJtaXNzaW"+
        "9uc1wiOltcInByb2R1Y3RNYW5nZTpwdWJsaXNoXCIsXCJjb2RlTWFuZ2U6dmlld1wiLFwiZGV2aWNlTWFuYWdlOmFkZFwiLFwiYW"+
        "RtaW5NYW5hZ2VcIixcIm9yZGVyTWFuZ2VcIixcImRldmljZU1hbmFnZTp2aWV3XCIsXCJwcm9kdWN0TWFuZ2U6YWRkXCIsXCJhZG"+
        "1pbk1hbmFnZTp2aWV3XCIsXCJjb2RlTWFuZ2U6YWRkXCIsXCJwcm9kdWN0TWFuZ2U6b2ZmU2FsZVwiLFwib3JkZXJNYW5nZTpjYW"+
        "5jZWxcIixcInByb2R1Y3RDZW50ZXI6ZG93bmxvYWRcIixcInByb2R1Y3RDZW50ZXI6YnV5XCIsXCJwcm9kdWN0TWFuZ2U6dmlld1"+
        "wiLFwiYXBpXCIsXCJob21lXCIsXCJvcmRlck1hbmdlOnBheVwiLFwiYWRtaW5NYW5hZ2U6YWRkXCIsXCJvcmRlck1hbmdlOmRvd2"+
        "5sb2FkXCIsXCJwcm9kdWN0Q2VudGVyXCIsXCJkZXZpY2VNYW5hZ2U6dW5iaW5kXCIsXCJvcmRlck1hbmdlOnZpZXdcIixcImFkbW"+
        "luTWFuYWdlOmVkaXRcIixcImRldmljZU1hbmFnZVwiLFwidmlwTWFuYWdlOmFkZFwiLFwidmlwTWFuYWdlOnZpZXdcIixcInByb2"+
        "R1Y3RDZW50ZXI6dmlld1wiLFwidmlwTWFuYWdlOmVkaXRcIixcInZpcE1hbmFnZVwiLFwicHJvZHVjdE1hbmdlOmVkaXRcIixcIm"+
        "NvZGVNYW5nZVwiLFwicHJvZHVjdE1hbmdlXCJdLFwidXNlcm5hbWVcIjpcImJhc2ljXCJ9In0.vwjAFkWuEyadRLvIOGK8LFE3Mj"+
        "pY3SQ7j6AlTXnQDG8")

    if err != nil {
        fmt.Println("build request fail !")
        return nil, err
    }

    resp, err := client.Do(request)
    if err != nil {
        fmt.Println("request error: ", err)
        return nil, err
    }

    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    return body, nil
}