frp/server/dashboard_api.go

346 lines
9.8 KiB
Go
Raw Normal View History

2017-03-23 02:01:25 +08:00
// Copyright 2017 fatedier, fatedier@gmail.com
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package server
import (
"encoding/json"
"net/http"
2022-08-29 01:02:53 +08:00
"github.com/gorilla/mux"
"github.com/fatedier/frp/pkg/config/types"
v1 "github.com/fatedier/frp/pkg/config/v1"
2020-09-23 13:49:14 +08:00
"github.com/fatedier/frp/pkg/metrics/mem"
"github.com/fatedier/frp/pkg/util/log"
"github.com/fatedier/frp/pkg/util/version"
)
type GeneralResponse struct {
2019-02-11 11:42:07 +08:00
Code int
Msg string
}
2020-05-24 17:48:37 +08:00
type serverInfoResp struct {
2023-02-22 00:39:56 +08:00
Version string `json:"version"`
BindPort int `json:"bindPort"`
VhostHTTPPort int `json:"vhostHTTPPort"`
VhostHTTPSPort int `json:"vhostHTTPSPort"`
TCPMuxHTTPConnectPort int `json:"tcpmuxHTTPConnectPort"`
KCPBindPort int `json:"kcpBindPort"`
QUICBindPort int `json:"quicBindPort"`
SubdomainHost string `json:"subdomainHost"`
MaxPoolCount int64 `json:"maxPoolCount"`
MaxPortsPerClient int64 `json:"maxPortsPerClient"`
HeartBeatTimeout int64 `json:"heartbeatTimeout"`
AllowPortsStr string `json:"allowPortsStr,omitempty"`
TLSForce bool `json:"tlsForce,omitempty"`
TotalTrafficIn int64 `json:"totalTrafficIn"`
TotalTrafficOut int64 `json:"totalTrafficOut"`
CurConns int64 `json:"curConns"`
ClientCounts int64 `json:"clientCounts"`
ProxyTypeCounts map[string]int64 `json:"proxyTypeCount"`
2017-03-23 02:01:25 +08:00
}
2021-08-04 14:33:53 +08:00
// /healthz
2023-07-21 10:30:46 +08:00
func (svr *Service) Healthz(w http.ResponseWriter, _ *http.Request) {
2021-08-04 14:33:53 +08:00
w.WriteHeader(200)
}
2023-06-30 17:35:37 +08:00
// /api/serverinfo
2020-05-24 17:48:37 +08:00
func (svr *Service) APIServerInfo(w http.ResponseWriter, r *http.Request) {
2019-02-11 11:42:07 +08:00
res := GeneralResponse{Code: 200}
defer func() {
2018-05-20 19:06:05 +08:00
log.Info("Http response [%s]: code [%d]", r.URL.Path, res.Code)
2019-02-11 11:42:07 +08:00
w.WriteHeader(res.Code)
if len(res.Msg) > 0 {
2022-08-29 01:02:53 +08:00
_, _ = w.Write([]byte(res.Msg))
2019-02-11 11:42:07 +08:00
}
}()
2018-05-20 19:06:05 +08:00
log.Info("Http request: [%s]", r.URL.Path)
serverStats := mem.StatsCollector.GetServer()
2020-05-24 17:48:37 +08:00
svrResp := serverInfoResp{
2023-02-22 00:39:56 +08:00
Version: version.Full(),
BindPort: svr.cfg.BindPort,
VhostHTTPPort: svr.cfg.VhostHTTPPort,
VhostHTTPSPort: svr.cfg.VhostHTTPSPort,
TCPMuxHTTPConnectPort: svr.cfg.TCPMuxHTTPConnectPort,
KCPBindPort: svr.cfg.KCPBindPort,
QUICBindPort: svr.cfg.QUICBindPort,
SubdomainHost: svr.cfg.SubDomainHost,
MaxPoolCount: svr.cfg.Transport.MaxPoolCount,
2023-02-22 00:39:56 +08:00
MaxPortsPerClient: svr.cfg.MaxPortsPerClient,
HeartBeatTimeout: svr.cfg.Transport.HeartbeatTimeout,
AllowPortsStr: types.PortsRangeSlice(svr.cfg.AllowPorts).String(),
TLSForce: svr.cfg.Transport.TLS.Force,
2017-03-23 02:01:25 +08:00
2017-03-27 01:39:05 +08:00
TotalTrafficIn: serverStats.TotalTrafficIn,
TotalTrafficOut: serverStats.TotalTrafficOut,
2017-03-23 02:01:25 +08:00
CurConns: serverStats.CurConns,
ClientCounts: serverStats.ClientCounts,
ProxyTypeCounts: serverStats.ProxyTypeCounts,
}
2019-02-11 11:42:07 +08:00
buf, _ := json.Marshal(&svrResp)
res.Msg = string(buf)
}
2018-05-20 19:06:05 +08:00
type BaseOutConf struct {
v1.ProxyBaseConfig
}
2020-05-24 17:48:37 +08:00
type TCPOutConf struct {
2018-05-20 19:06:05 +08:00
BaseOutConf
RemotePort int `json:"remotePort"`
2017-03-23 02:01:25 +08:00
}
2020-05-24 17:48:37 +08:00
type TCPMuxOutConf struct {
BaseOutConf
v1.DomainConfig
Multiplexer string `json:"multiplexer"`
}
2020-05-24 17:48:37 +08:00
type UDPOutConf struct {
2018-05-20 19:06:05 +08:00
BaseOutConf
RemotePort int `json:"remotePort"`
2018-05-20 19:06:05 +08:00
}
2017-03-23 02:01:25 +08:00
2020-05-24 17:48:37 +08:00
type HTTPOutConf struct {
2018-05-20 19:06:05 +08:00
BaseOutConf
v1.DomainConfig
2018-05-20 19:06:05 +08:00
Locations []string `json:"locations"`
HostHeaderRewrite string `json:"hostHeaderRewrite"`
2017-03-23 02:01:25 +08:00
}
2020-05-24 17:48:37 +08:00
type HTTPSOutConf struct {
2018-05-20 19:06:05 +08:00
BaseOutConf
v1.DomainConfig
2018-05-20 19:06:05 +08:00
}
2017-03-23 02:01:25 +08:00
2020-05-24 17:48:37 +08:00
type STCPOutConf struct {
2018-05-20 19:06:05 +08:00
BaseOutConf
}
2017-03-23 02:01:25 +08:00
2020-05-24 17:48:37 +08:00
type XTCPOutConf struct {
2018-05-20 19:06:05 +08:00
BaseOutConf
2017-03-23 02:01:25 +08:00
}
2023-09-20 15:18:50 +08:00
func getConfByType(proxyType string) any {
switch v1.ProxyType(proxyType) {
case v1.ProxyTypeTCP:
2020-05-24 17:48:37 +08:00
return &TCPOutConf{}
2023-09-20 15:18:50 +08:00
case v1.ProxyTypeTCPMUX:
2020-05-24 17:48:37 +08:00
return &TCPMuxOutConf{}
2023-09-20 15:18:50 +08:00
case v1.ProxyTypeUDP:
2020-05-24 17:48:37 +08:00
return &UDPOutConf{}
2023-09-20 15:18:50 +08:00
case v1.ProxyTypeHTTP:
2020-05-24 17:48:37 +08:00
return &HTTPOutConf{}
2023-09-20 15:18:50 +08:00
case v1.ProxyTypeHTTPS:
2020-05-24 17:48:37 +08:00
return &HTTPSOutConf{}
2023-09-20 15:18:50 +08:00
case v1.ProxyTypeSTCP:
2020-05-24 17:48:37 +08:00
return &STCPOutConf{}
2023-09-20 15:18:50 +08:00
case v1.ProxyTypeXTCP:
2020-05-24 17:48:37 +08:00
return &XTCPOutConf{}
2018-05-20 19:06:05 +08:00
default:
return nil
}
}
2017-03-23 02:01:25 +08:00
2018-05-20 19:06:05 +08:00
// Get proxy info.
type ProxyStatsInfo struct {
Name string `json:"name"`
Conf interface{} `json:"conf"`
ClientVersion string `json:"clientVersion,omitempty"`
TodayTrafficIn int64 `json:"todayTrafficIn"`
TodayTrafficOut int64 `json:"todayTrafficOut"`
CurConns int64 `json:"curConns"`
LastStartTime string `json:"lastStartTime"`
LastCloseTime string `json:"lastCloseTime"`
2018-05-20 19:06:05 +08:00
Status string `json:"status"`
}
2017-03-23 02:01:25 +08:00
2018-05-20 19:06:05 +08:00
type GetProxyInfoResp struct {
Proxies []*ProxyStatsInfo `json:"proxies"`
2017-03-23 02:01:25 +08:00
}
2023-06-30 17:35:37 +08:00
// /api/proxy/:type
2020-05-24 17:48:37 +08:00
func (svr *Service) APIProxyByType(w http.ResponseWriter, r *http.Request) {
2019-02-11 11:42:07 +08:00
res := GeneralResponse{Code: 200}
2018-05-20 19:06:05 +08:00
params := mux.Vars(r)
proxyType := params["type"]
2017-03-23 02:01:25 +08:00
defer func() {
2018-05-20 19:06:05 +08:00
log.Info("Http response [%s]: code [%d]", r.URL.Path, res.Code)
2019-02-11 11:42:07 +08:00
w.WriteHeader(res.Code)
if len(res.Msg) > 0 {
2022-08-29 01:02:53 +08:00
_, _ = w.Write([]byte(res.Msg))
2019-02-11 11:42:07 +08:00
}
2017-03-23 02:01:25 +08:00
}()
2018-05-20 19:06:05 +08:00
log.Info("Http request: [%s]", r.URL.Path)
2017-03-23 02:01:25 +08:00
2019-02-11 11:42:07 +08:00
proxyInfoResp := GetProxyInfoResp{}
proxyInfoResp.Proxies = svr.getProxyStatsByType(proxyType)
2018-05-20 19:06:05 +08:00
2019-02-11 11:42:07 +08:00
buf, _ := json.Marshal(&proxyInfoResp)
res.Msg = string(buf)
2017-03-23 02:01:25 +08:00
}
2019-01-10 20:53:06 +08:00
func (svr *Service) getProxyStatsByType(proxyType string) (proxyInfos []*ProxyStatsInfo) {
proxyStats := mem.StatsCollector.GetProxiesByType(proxyType)
2017-03-23 02:01:25 +08:00
proxyInfos = make([]*ProxyStatsInfo, 0, len(proxyStats))
for _, ps := range proxyStats {
proxyInfo := &ProxyStatsInfo{}
2019-01-15 00:11:08 +08:00
if pxy, ok := svr.pxyManager.GetByName(ps.Name); ok {
content, err := json.Marshal(pxy.GetConfigurer())
2018-05-20 19:06:05 +08:00
if err != nil {
log.Warn("marshal proxy [%s] conf info error: %v", ps.Name, err)
continue
}
proxyInfo.Conf = getConfByType(ps.Type)
if err = json.Unmarshal(content, &proxyInfo.Conf); err != nil {
log.Warn("unmarshal proxy [%s] conf info error: %v", ps.Name, err)
continue
}
2023-09-20 15:18:50 +08:00
proxyInfo.Status = "online"
2023-02-22 00:39:56 +08:00
if pxy.GetLoginMsg() != nil {
proxyInfo.ClientVersion = pxy.GetLoginMsg().Version
}
2017-03-23 02:01:25 +08:00
} else {
2023-09-20 15:18:50 +08:00
proxyInfo.Status = "offline"
2017-03-23 02:01:25 +08:00
}
proxyInfo.Name = ps.Name
2017-03-27 01:39:05 +08:00
proxyInfo.TodayTrafficIn = ps.TodayTrafficIn
proxyInfo.TodayTrafficOut = ps.TodayTrafficOut
2017-03-23 02:01:25 +08:00
proxyInfo.CurConns = ps.CurConns
proxyInfo.LastStartTime = ps.LastStartTime
proxyInfo.LastCloseTime = ps.LastCloseTime
2017-03-23 02:01:25 +08:00
proxyInfos = append(proxyInfos, proxyInfo)
}
return
}
// Get proxy info by name.
type GetProxyStatsResp struct {
2018-05-20 19:06:05 +08:00
Name string `json:"name"`
Conf interface{} `json:"conf"`
TodayTrafficIn int64 `json:"todayTrafficIn"`
TodayTrafficOut int64 `json:"todayTrafficOut"`
CurConns int64 `json:"curConns"`
LastStartTime string `json:"lastStartTime"`
LastCloseTime string `json:"lastCloseTime"`
2018-05-20 19:06:05 +08:00
Status string `json:"status"`
}
2023-06-30 17:35:37 +08:00
// /api/proxy/:type/:name
2020-05-24 17:48:37 +08:00
func (svr *Service) APIProxyByTypeAndName(w http.ResponseWriter, r *http.Request) {
2019-02-11 11:42:07 +08:00
res := GeneralResponse{Code: 200}
2018-05-20 19:06:05 +08:00
params := mux.Vars(r)
proxyType := params["type"]
name := params["name"]
defer func() {
2018-05-20 19:06:05 +08:00
log.Info("Http response [%s]: code [%d]", r.URL.Path, res.Code)
2019-02-11 11:42:07 +08:00
w.WriteHeader(res.Code)
if len(res.Msg) > 0 {
2022-08-29 01:02:53 +08:00
_, _ = w.Write([]byte(res.Msg))
2019-02-11 11:42:07 +08:00
}
}()
2018-05-20 19:06:05 +08:00
log.Info("Http request: [%s]", r.URL.Path)
2022-08-29 01:02:53 +08:00
var proxyStatsResp GetProxyStatsResp
2019-02-11 11:42:07 +08:00
proxyStatsResp, res.Code, res.Msg = svr.getProxyStatsByTypeAndName(proxyType, name)
if res.Code != 200 {
return
}
2019-02-11 11:42:07 +08:00
buf, _ := json.Marshal(&proxyStatsResp)
res.Msg = string(buf)
}
2019-02-11 11:42:07 +08:00
func (svr *Service) getProxyStatsByTypeAndName(proxyType string, proxyName string) (proxyInfo GetProxyStatsResp, code int, msg string) {
proxyInfo.Name = proxyName
ps := mem.StatsCollector.GetProxiesByTypeAndName(proxyType, proxyName)
if ps == nil {
2019-02-11 11:42:07 +08:00
code = 404
msg = "no proxy info found"
} else {
2019-01-15 00:11:08 +08:00
if pxy, ok := svr.pxyManager.GetByName(proxyName); ok {
content, err := json.Marshal(pxy.GetConfigurer())
2018-05-20 19:06:05 +08:00
if err != nil {
log.Warn("marshal proxy [%s] conf info error: %v", ps.Name, err)
2019-02-11 11:42:07 +08:00
code = 400
msg = "parse conf error"
2018-05-20 19:06:05 +08:00
return
}
proxyInfo.Conf = getConfByType(ps.Type)
if err = json.Unmarshal(content, &proxyInfo.Conf); err != nil {
log.Warn("unmarshal proxy [%s] conf info error: %v", ps.Name, err)
2019-02-11 11:42:07 +08:00
code = 400
msg = "parse conf error"
2018-05-20 19:06:05 +08:00
return
}
2023-09-20 15:18:50 +08:00
proxyInfo.Status = "online"
} else {
2023-09-20 15:18:50 +08:00
proxyInfo.Status = "offline"
}
proxyInfo.TodayTrafficIn = ps.TodayTrafficIn
proxyInfo.TodayTrafficOut = ps.TodayTrafficOut
proxyInfo.CurConns = ps.CurConns
proxyInfo.LastStartTime = ps.LastStartTime
proxyInfo.LastCloseTime = ps.LastCloseTime
2019-04-21 15:59:35 +08:00
code = 200
}
return
}
2023-06-30 17:35:37 +08:00
// /api/traffic/:name
2017-03-27 01:39:05 +08:00
type GetProxyTrafficResp struct {
Name string `json:"name"`
TrafficIn []int64 `json:"trafficIn"`
TrafficOut []int64 `json:"trafficOut"`
2017-03-23 02:01:25 +08:00
}
2020-05-24 17:48:37 +08:00
func (svr *Service) APIProxyTraffic(w http.ResponseWriter, r *http.Request) {
2019-02-11 11:42:07 +08:00
res := GeneralResponse{Code: 200}
2018-05-20 19:06:05 +08:00
params := mux.Vars(r)
name := params["name"]
2017-03-23 02:01:25 +08:00
defer func() {
2018-05-20 19:06:05 +08:00
log.Info("Http response [%s]: code [%d]", r.URL.Path, res.Code)
2019-02-11 11:42:07 +08:00
w.WriteHeader(res.Code)
if len(res.Msg) > 0 {
2022-08-29 01:02:53 +08:00
_, _ = w.Write([]byte(res.Msg))
2019-02-11 11:42:07 +08:00
}
2017-03-23 02:01:25 +08:00
}()
2018-05-20 19:06:05 +08:00
log.Info("Http request: [%s]", r.URL.Path)
2017-03-23 02:01:25 +08:00
2019-02-11 11:42:07 +08:00
trafficResp := GetProxyTrafficResp{}
trafficResp.Name = name
proxyTrafficInfo := mem.StatsCollector.GetProxyTraffic(name)
2019-02-11 11:42:07 +08:00
2017-03-27 01:39:05 +08:00
if proxyTrafficInfo == nil {
2019-02-11 11:42:07 +08:00
res.Code = 404
2017-03-23 02:01:25 +08:00
res.Msg = "no proxy info found"
2019-02-11 11:42:07 +08:00
return
2017-03-23 02:01:25 +08:00
}
2020-05-24 17:48:37 +08:00
trafficResp.TrafficIn = proxyTrafficInfo.TrafficIn
trafficResp.TrafficOut = proxyTrafficInfo.TrafficOut
2019-02-11 12:15:31 +08:00
buf, _ := json.Marshal(&trafficResp)
2019-02-11 11:42:07 +08:00
res.Msg = string(buf)
}