468 lines
9.4 KiB
Go
468 lines
9.4 KiB
Go
package remote
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httputil"
|
|
"net/url"
|
|
"platform/pkg/env"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
type client struct {
|
|
url string
|
|
token string
|
|
}
|
|
|
|
var Client client
|
|
|
|
func Init() {
|
|
Client = client{
|
|
url: env.RemoteAddr,
|
|
token: env.RemoteToken,
|
|
}
|
|
}
|
|
|
|
type AutoConfig struct {
|
|
Province string `json:"province"`
|
|
City string `json:"city"`
|
|
Isp string `json:"isp"`
|
|
Count int `json:"count"`
|
|
}
|
|
|
|
// region cloud:/edges
|
|
|
|
type CloudEdgesReq struct {
|
|
Province string
|
|
City string
|
|
Isp string
|
|
Offset int
|
|
Limit int
|
|
}
|
|
|
|
type CloudEdgesResp struct {
|
|
Edges []Edge `json:"edges"`
|
|
Total int `json:"total"`
|
|
Offset int `json:"offset"`
|
|
Limit int `json:"limit"`
|
|
}
|
|
|
|
type Edge struct {
|
|
EdgesId int `json:"edges_id"`
|
|
Province string `json:"province"`
|
|
City string `json:"city"`
|
|
Isp string `json:"isp"`
|
|
Ip string `json:"ip"`
|
|
Rtt int `json:"rtt"`
|
|
PacketLoss int `json:"packet_loss"`
|
|
}
|
|
|
|
func (c *client) CloudEdges(param CloudEdgesReq) (*CloudEdgesResp, error) {
|
|
data := strings.Builder{}
|
|
data.WriteString("province=")
|
|
data.WriteString(param.Province)
|
|
data.WriteString("&city=")
|
|
data.WriteString(param.City)
|
|
data.WriteString("&isp=")
|
|
data.WriteString(param.Isp)
|
|
data.WriteString("&offset=")
|
|
data.WriteString(strconv.Itoa(param.Offset))
|
|
data.WriteString("&limit=")
|
|
data.WriteString(strconv.Itoa(param.Limit))
|
|
|
|
resp, err := c.requestCloud("GET", "/edges?"+data.String(), "")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func(Body io.ReadCloser) {
|
|
_ = Body.Close()
|
|
}(resp.Body)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, errors.New("failed to get edges")
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var result CloudEdgesResp
|
|
err = json.Unmarshal(body, &result)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &result, nil
|
|
}
|
|
|
|
// endregion
|
|
|
|
// region cloud:/connect
|
|
|
|
type CloudConnectReq struct {
|
|
Uuid string `json:"uuid"`
|
|
Edge []string `json:"edge,omitempty"`
|
|
AutoConfig []AutoConfig `json:"auto_config,omitempty"`
|
|
}
|
|
|
|
func (c *client) CloudConnect(param CloudConnectReq) error {
|
|
data, err := json.Marshal(param)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp, err := c.requestCloud("POST", "/connect", string(data))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
defer func(Body io.ReadCloser) {
|
|
_ = Body.Close()
|
|
}(resp.Body)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return errors.New("failed to connect")
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
var result map[string]any
|
|
err = json.Unmarshal(body, &result)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if result["status"] == "error" {
|
|
return errors.New(result["details"].(string))
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// endregion
|
|
|
|
// region cloud:/disconnect
|
|
|
|
type CloudDisconnectReq struct {
|
|
Uuid string `json:"uuid"`
|
|
Edge []string `json:"edge,omitempty"`
|
|
Config []Config `json:"auto_config,omitempty"`
|
|
}
|
|
|
|
type Config struct {
|
|
Province string `json:"province"`
|
|
City string `json:"city"`
|
|
Isp string `json:"isp"`
|
|
Count int `json:"count"`
|
|
Online bool `json:"online"`
|
|
}
|
|
|
|
func (c *client) CloudDisconnect(param CloudDisconnectReq) (int, error) {
|
|
data, err := json.Marshal(param)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
resp, err := c.requestCloud("POST", "/disconnect", string(data))
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
defer func(Body io.ReadCloser) {
|
|
_ = Body.Close()
|
|
}(resp.Body)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return 0, errors.New("failed to disconnect")
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
var result map[string]any
|
|
err = json.Unmarshal(body, &result)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
|
|
if result["status"] == "error" {
|
|
return 0, errors.New(result["details"].(string))
|
|
}
|
|
|
|
return int(result["disconnected_edges"].(float64)), nil
|
|
}
|
|
|
|
// endregion
|
|
|
|
// region cloud:/auto_query
|
|
|
|
type CloudConnectResp map[string][]AutoConfig
|
|
|
|
func (c *client) CloudAutoQuery() (CloudConnectResp, error) {
|
|
resp, err := c.requestCloud("GET", "/auto_query", "")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func(Body io.ReadCloser) {
|
|
_ = Body.Close()
|
|
}(resp.Body)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, errors.New("failed to get auto_query")
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var result CloudConnectResp
|
|
err = json.Unmarshal(body, &result)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// endregion
|
|
|
|
func (c *client) requestCloud(method string, url string, data string) (*http.Response, error) {
|
|
|
|
url = fmt.Sprintf("%s/api%s", c.url, url)
|
|
req, err := http.NewRequest(method, url, strings.NewReader(data))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("token", c.token)
|
|
|
|
if env.DebugHttpDump {
|
|
str, err := httputil.DumpRequest(req, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fmt.Println("==============================")
|
|
fmt.Println(string(str))
|
|
}
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if env.DebugHttpDump {
|
|
str, err := httputil.DumpResponse(resp, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fmt.Println("==============================")
|
|
fmt.Println(string(str))
|
|
}
|
|
|
|
return resp, nil
|
|
}
|
|
|
|
type Gateway struct {
|
|
url string
|
|
username string
|
|
password string
|
|
}
|
|
|
|
func InitGateway(url, username, password string) *Gateway {
|
|
return &Gateway{url, username, password}
|
|
}
|
|
|
|
// region gateway:/port/configs
|
|
|
|
type PortConfigsReq struct {
|
|
Port int `json:"port"`
|
|
Edge *[]string `json:"edge,omitempty"`
|
|
Type string `json:"type,omitempty"`
|
|
Time int `json:"time,omitempty"`
|
|
Status bool `json:"status"`
|
|
Rate int `json:"rate,omitempty"`
|
|
Whitelist *[]string `json:"whitelist,omitempty"`
|
|
Userpass *string `json:"userpass,omitempty"`
|
|
AutoEdgeConfig *AutoEdgeConfig `json:"auto_edge_config,omitempty"`
|
|
}
|
|
|
|
type AutoEdgeConfig struct {
|
|
Province string `json:"province,omitempty"`
|
|
City string `json:"city,omitempty"`
|
|
Isp string `json:"isp,omitempty"`
|
|
Count *int `json:"count,omitempty"`
|
|
PacketLoss int `json:"packet_loss,omitempty"`
|
|
}
|
|
|
|
func (c *Gateway) GatewayPortConfigs(params []PortConfigsReq) error {
|
|
if len(params) == 0 {
|
|
return errors.New("params is empty")
|
|
}
|
|
|
|
data, err := json.Marshal(params)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
resp, err := c.requestGateway("POST", "/port/configs", string(data))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func(Body io.ReadCloser) {
|
|
_ = Body.Close()
|
|
}(resp.Body)
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return errors.New("failed to get port configs: " + string(body))
|
|
}
|
|
|
|
var result map[string]any
|
|
err = json.Unmarshal(body, &result)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if result["code"].(float64) != 0 {
|
|
return errors.New("failed to configure port")
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// endregion
|
|
|
|
// region gateway:/port/active
|
|
|
|
type PortActiveReq struct {
|
|
Port string `json:"port"`
|
|
Active *bool `json:"active"`
|
|
Status *bool `json:"status"`
|
|
}
|
|
|
|
type PortActiveResp struct {
|
|
Code int `json:"code"`
|
|
Msg string `json:"msg"`
|
|
Data map[string]PortData `json:"data"`
|
|
}
|
|
|
|
type PortData struct {
|
|
Edge []string `json:"edge"`
|
|
Type string `json:"type"`
|
|
Status bool `json:"status"`
|
|
Active bool `json:"active"`
|
|
Time int `json:"time"`
|
|
Whitelist []string `json:"whitelist"`
|
|
Userpass string `json:"userpass"`
|
|
}
|
|
|
|
func (c *Gateway) GatewayPortActive(param ...PortActiveReq) (map[string]PortData, error) {
|
|
_param := PortActiveReq{}
|
|
if len(param) != 0 {
|
|
_param = param[0]
|
|
}
|
|
|
|
path := strings.Builder{}
|
|
path.WriteString("/port/active")
|
|
|
|
if _param.Port != "" {
|
|
path.WriteString("/")
|
|
path.WriteString(_param.Port)
|
|
}
|
|
|
|
values := url.Values{}
|
|
if _param.Active != nil {
|
|
values.Set("active", strconv.FormatBool(*_param.Active))
|
|
}
|
|
if _param.Status != nil {
|
|
values.Set("status", strconv.FormatBool(*_param.Status))
|
|
}
|
|
|
|
if len(values) > 0 {
|
|
path.WriteString("?")
|
|
path.WriteString(values.Encode())
|
|
}
|
|
|
|
resp, err := c.requestGateway("GET", path.String(), "")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer func(Body io.ReadCloser) {
|
|
_ = Body.Close()
|
|
}(resp.Body)
|
|
|
|
if resp.StatusCode != http.StatusOK {
|
|
return nil, errors.New("failed to get port active")
|
|
}
|
|
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
var result PortActiveResp
|
|
err = json.Unmarshal(body, &result)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if result.Code != 0 {
|
|
return nil, errors.New(result.Msg)
|
|
}
|
|
|
|
return result.Data, nil
|
|
}
|
|
|
|
// endregion
|
|
|
|
func (c *Gateway) requestGateway(method string, url string, data string) (*http.Response, error) {
|
|
url = fmt.Sprintf("http://%s:%s@%s:9990%s", c.username, c.password, c.url, url)
|
|
req, err := http.NewRequest(method, url, strings.NewReader(data))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
if env.DebugHttpDump {
|
|
str, err := httputil.DumpRequest(req, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fmt.Println("==============================")
|
|
fmt.Println(string(str))
|
|
}
|
|
|
|
resp, err := http.DefaultClient.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if env.DebugHttpDump {
|
|
str, err := httputil.DumpResponse(resp, true)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
fmt.Println("==============================")
|
|
fmt.Println(string(str))
|
|
}
|
|
|
|
return resp, nil
|
|
}
|