mirror of
https://gitee.com/rainbond/Rainbond.git
synced 2024-12-01 03:07:51 +08:00
132 lines
3.1 KiB
Go
132 lines
3.1 KiB
Go
//+build license
|
|
|
|
package middleware
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"os"
|
|
"plugin"
|
|
"time"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
"github.com/goodrain/rainbond/cmd/api/option"
|
|
httputil "github.com/goodrain/rainbond/util/http"
|
|
)
|
|
|
|
// License -
|
|
type License struct {
|
|
cfg *option.Config
|
|
}
|
|
|
|
// NewLicense -
|
|
func NewLicense(cfg *option.Config) *License {
|
|
return &License{
|
|
cfg: cfg,
|
|
}
|
|
}
|
|
|
|
// LicInfo license information
|
|
type LicInfo struct {
|
|
Code string `json:"code"`
|
|
Company string `json:"company"`
|
|
Node int64 `json:"node"`
|
|
CPU int64 `json:"cpu"`
|
|
Memory int64 `json:"memory"`
|
|
Tenant int64 `json:"tenant"`
|
|
EndTime string `json:"end_time"`
|
|
StartTime string `json:"start_time"`
|
|
DataCenter int64 `json:"data_center"`
|
|
ModuleList []string `json:"module_list"`
|
|
}
|
|
|
|
// Verify parses the license to make the content inside it take effect.
|
|
func (l *License) Verify(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if err := verifyLicense(l.cfg.LicensePath, l.cfg.LicSoPath); err != nil {
|
|
httputil.Return(r, w, 401, httputil.ResponseBody{
|
|
Bean: map[string]interface{}{
|
|
"msg": err.Error(),
|
|
"code": 10401,
|
|
},
|
|
})
|
|
return
|
|
}
|
|
next.ServeHTTP(w, r)
|
|
})
|
|
}
|
|
|
|
func verifyLicense(licPath, licSoPath string) error {
|
|
lic, err := readFromFile(licPath)
|
|
if err != nil {
|
|
logrus.Errorf("failed to read license from file: %v", err)
|
|
return fmt.Errorf("failed to read license from file: %v", err)
|
|
}
|
|
bytes, err := decrypt(lic, licSoPath)
|
|
if err != nil {
|
|
return fmt.Errorf("error decrypting license: %v", err)
|
|
}
|
|
var licInfo LicInfo
|
|
if err := json.Unmarshal(bytes, &licInfo); err != nil {
|
|
logrus.Errorf("error unmarshalling license: %v", err)
|
|
return fmt.Errorf("error unmarshalling license: %v", err)
|
|
}
|
|
if !takeEffect(&licInfo) {
|
|
return fmt.Errorf("invalid license")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func takeEffect(licInfo *LicInfo) bool {
|
|
layout := "2006-01-02 15:04:05"
|
|
startTime, err := time.Parse(layout, licInfo.StartTime)
|
|
if err != nil {
|
|
logrus.Errorf("start time: %s; error parsing start time: %v", licInfo.StartTime, err)
|
|
return false
|
|
}
|
|
if startTime.After(time.Now()) {
|
|
return false
|
|
}
|
|
endtTime, err := time.Parse(layout, licInfo.EndTime)
|
|
if err != nil {
|
|
logrus.Errorf("end time: %s; error parsing end time: %v", licInfo.EndTime, err)
|
|
return false
|
|
}
|
|
if endtTime.Before(time.Now()) {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func readFromFile(lfile string) (string, error) {
|
|
_, err := os.Stat(lfile)
|
|
if err != nil {
|
|
logrus.Errorf("license file is incorrect: %v", err)
|
|
return "", err
|
|
}
|
|
bytes, err := ioutil.ReadFile(lfile)
|
|
if err != nil {
|
|
logrus.Errorf("license file: %s; error reading license file: %v", lfile, err)
|
|
return "", err
|
|
}
|
|
return string(bytes), nil
|
|
}
|
|
|
|
func decrypt(license string, licSoPath string) ([]byte, error) {
|
|
p, err := plugin.Open(licSoPath)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
f, err := p.Lookup("Decrypt")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
bytes, err := f.(func(string) ([]byte, error))(license)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return bytes, nil
|
|
}
|