pcm-coordinator/internal/storeLink/octopusHttp/token.go

package octopusHttp

import (
	"crypto/tls"
	"encoding/json"
	"github.com/go-resty/resty/v2"
	"time"
)

const (
	GetToken = "api/v1/token"
)

type TokenModel struct {
	Success bool `json:"success"`
	Payload struct {
		Token      string `json:"token"`
		Expiration int    `json:"expiration"`
	} `json:"payload"`
	Error interface{} `json:"error"`
}

type TokenTimePair struct {
	Token     string
	ExpiredAt time.Time
}

type Login struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type Token struct {
	server   string
	host     string
	user     string
	pwd      string
	tokenUrl string
	ttp      *TokenTimePair
}

func NewToken(server, host, user, pwd string) (*Token, error) {
	login := Login{
		Username: user,
		Password: pwd,
	}
	jsonStr, _ := json.Marshal(login)
	tokenUrl := server + GetToken

	token, tm, err := generateToken(jsonStr, tokenUrl, host)
	if err != nil {
		return nil, err
	}
	ttp := &TokenTimePair{
		Token:     token,
		ExpiredAt: tm,
	}
	return &Token{ttp: ttp, host: host, user: user, pwd: pwd, tokenUrl: tokenUrl}, nil
}

func (t *Token) update() error {
	login := Login{
		Username: t.user,
		Password: t.pwd,
	}
	jsonStr, _ := json.Marshal(login)
	token, tm, err := generateToken(jsonStr, t.tokenUrl, t.host)
	if err != nil {
		return err
	}
	ttp := &TokenTimePair{
		Token:     token,
		ExpiredAt: tm,
	}
	t.ttp = ttp
	return nil
}

func (t *Token) Get() (string, error) {
	if time.Now().After(t.ttp.ExpiredAt) {
		err := t.update()
		if err != nil {
			return "", err
		}
	}
	return t.ttp.Token, nil
}

func generateToken(jsonStr []byte, tokenUrl string, host string) (string, time.Time, error) {
	client := resty.New().SetTimeout(time.Duration(5) * time.Second)
	req := client.R()

	var tokenResp TokenModel

	client.SetTLSClientConfig(&tls.Config{
		InsecureSkipVerify: true,
	})

	_, err := req.
		SetResult(&tokenResp).
		SetHeader("Content-Type", "application/json").
		SetQueryString("addr=" + host).
		SetBody(jsonStr).
		Post(tokenUrl)
	if err != nil {
		return "", time.Time{}, err
	}

	var d time.Duration
	d = time.Second * time.Duration(tokenResp.Payload.Expiration)
	return tokenResp.Payload.Token, time.Now().Add(d), nil
}