frp/server/dashboard_api.go

336 lines
9.3 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"
2020-09-23 13:49:14 +08:00
"github.com/fatedier/frp/pkg/config"
"github.com/fatedier/frp/pkg/consts"
"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 {
2018-05-11 17:14:16 +08:00
Version string `json:"version"`
BindPort int `json:"bind_port"`
2020-05-24 17:48:37 +08:00
BindUDPPort int `json:"bind_udp_port"`
VhostHTTPPort int `json:"vhost_http_port"`
VhostHTTPSPort int `json:"vhost_https_port"`
KCPBindPort int `json:"kcp_bind_port"`
2018-05-11 17:14:16 +08:00
SubdomainHost string `json:"subdomain_host"`
MaxPoolCount int64 `json:"max_pool_count"`
MaxPortsPerClient int64 `json:"max_ports_per_client"`
HeartBeatTimeout int64 `json:"heart_beat_timeout"`
2017-03-23 02:01:25 +08:00
2017-03-27 01:39:05 +08:00
TotalTrafficIn int64 `json:"total_traffic_in"`
TotalTrafficOut int64 `json:"total_traffic_out"`
2017-03-23 02:01:25 +08:00
CurConns int64 `json:"cur_conns"`
ClientCounts int64 `json:"client_counts"`
ProxyTypeCounts map[string]int64 `json:"proxy_type_count"`
}
2021-08-04 14:33:53 +08:00
// /healthz
func (svr *Service) Healthz(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(200)
}
2019-01-10 20:53:06 +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{
2018-05-11 17:14:16 +08:00
Version: version.Full(),
BindPort: svr.cfg.BindPort,
2020-05-24 17:48:37 +08:00
BindUDPPort: svr.cfg.BindUDPPort,
VhostHTTPPort: svr.cfg.VhostHTTPPort,
VhostHTTPSPort: svr.cfg.VhostHTTPSPort,
KCPBindPort: svr.cfg.KCPBindPort,
SubdomainHost: svr.cfg.SubDomainHost,
MaxPoolCount: svr.cfg.MaxPoolCount,
MaxPortsPerClient: svr.cfg.MaxPortsPerClient,
2020-11-23 11:38:21 +08:00
HeartBeatTimeout: svr.cfg.HeartbeatTimeout,
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 {
config.BaseProxyConf
}
2020-05-24 17:48:37 +08:00
type TCPOutConf struct {
2018-05-20 19:06:05 +08:00
BaseOutConf
RemotePort int `json:"remote_port"`
2017-03-23 02:01:25 +08:00
}
2020-05-24 17:48:37 +08:00
type TCPMuxOutConf struct {
BaseOutConf
config.DomainConf
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:"remote_port"`
}
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
config.DomainConf
Locations []string `json:"locations"`
HostHeaderRewrite string `json:"host_header_rewrite"`
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
config.DomainConf
}
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
}
2018-05-20 19:06:05 +08:00
func getConfByType(proxyType string) interface{} {
switch proxyType {
2020-05-24 17:48:37 +08:00
case consts.TCPProxy:
return &TCPOutConf{}
case consts.TCPMuxProxy:
return &TCPMuxOutConf{}
case consts.UDPProxy:
return &UDPOutConf{}
case consts.HTTPProxy:
return &HTTPOutConf{}
case consts.HTTPSProxy:
return &HTTPSOutConf{}
case consts.STCPProxy:
return &STCPOutConf{}
case consts.XTCPProxy:
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"`
TodayTrafficIn int64 `json:"today_traffic_in"`
TodayTrafficOut int64 `json:"today_traffic_out"`
CurConns int64 `json:"cur_conns"`
LastStartTime string `json:"last_start_time"`
LastCloseTime string `json:"last_close_time"`
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
}
2018-05-20 19:06:05 +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 {
2018-05-20 19:06:05 +08:00
content, err := json.Marshal(pxy.GetConf())
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
}
2017-03-23 02:01:25 +08:00
proxyInfo.Status = consts.Online
} else {
proxyInfo.Status = consts.Offline
}
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:"today_traffic_in"`
TodayTrafficOut int64 `json:"today_traffic_out"`
CurConns int64 `json:"cur_conns"`
LastStartTime string `json:"last_start_time"`
LastCloseTime string `json:"last_close_time"`
Status string `json:"status"`
}
2018-05-20 19:06:05 +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 {
2018-05-20 19:06:05 +08:00
content, err := json.Marshal(pxy.GetConf())
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
}
proxyInfo.Status = consts.Online
} else {
proxyInfo.Status = consts.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
}
2018-05-20 19:06:05 +08:00
// api/traffic/:name
2017-03-27 01:39:05 +08:00
type GetProxyTrafficResp struct {
Name string `json:"name"`
TrafficIn []int64 `json:"traffic_in"`
TrafficOut []int64 `json:"traffic_out"`
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)
}