frp/server/dashboard_api.go

324 lines
9.0 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"
2018-04-10 17:46:49 +08:00
"github.com/fatedier/frp/g"
2017-03-23 02:01:25 +08:00
"github.com/fatedier/frp/models/config"
"github.com/fatedier/frp/models/consts"
"github.com/fatedier/frp/utils/log"
"github.com/fatedier/frp/utils/version"
2017-03-23 02:01:25 +08:00
2018-05-20 19:06:05 +08:00
"github.com/gorilla/mux"
)
type GeneralResponse struct {
2019-02-11 11:42:07 +08:00
Code int
Msg string
}
2017-03-23 02:01:25 +08:00
type ServerInfoResp struct {
2018-05-11 17:14:16 +08:00
Version string `json:"version"`
BindPort int `json:"bind_port"`
BindUdpPort int `json:"bind_udp_port"`
VhostHttpPort int `json:"vhost_http_port"`
VhostHttpsPort int `json:"vhost_https_port"`
KcpBindPort int `json:"kcp_bind_port"`
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"`
}
2019-01-10 20:53:06 +08:00
// api/serverinfo
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 {
w.Write([]byte(res.Msg))
}
}()
2018-05-20 19:06:05 +08:00
log.Info("Http request: [%s]", r.URL.Path)
2018-04-10 17:46:49 +08:00
cfg := &g.GlbServerCfg.ServerCommonConf
2019-01-15 00:11:08 +08:00
serverStats := svr.statsCollector.GetServer()
2019-02-11 11:42:07 +08:00
svrResp := ServerInfoResp{
2018-05-11 17:14:16 +08:00
Version: version.Full(),
BindPort: cfg.BindPort,
BindUdpPort: cfg.BindUdpPort,
VhostHttpPort: cfg.VhostHttpPort,
VhostHttpsPort: cfg.VhostHttpsPort,
KcpBindPort: cfg.KcpBindPort,
SubdomainHost: cfg.SubDomainHost,
MaxPoolCount: cfg.MaxPoolCount,
MaxPortsPerClient: cfg.MaxPortsPerClient,
HeartBeatTimeout: 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
}
2018-05-20 19:06:05 +08:00
type TcpOutConf struct {
BaseOutConf
RemotePort int `json:"remote_port"`
2017-03-23 02:01:25 +08:00
}
2018-05-20 19:06:05 +08:00
type UdpOutConf struct {
BaseOutConf
RemotePort int `json:"remote_port"`
}
2017-03-23 02:01:25 +08:00
2018-05-20 19:06:05 +08:00
type HttpOutConf struct {
BaseOutConf
config.DomainConf
Locations []string `json:"locations"`
HostHeaderRewrite string `json:"host_header_rewrite"`
2017-03-23 02:01:25 +08:00
}
2018-05-20 19:06:05 +08:00
type HttpsOutConf struct {
BaseOutConf
config.DomainConf
}
2017-03-23 02:01:25 +08:00
2018-05-20 19:06:05 +08:00
type StcpOutConf struct {
BaseOutConf
}
2017-03-23 02:01:25 +08:00
2018-05-20 19:06:05 +08:00
type XtcpOutConf struct {
BaseOutConf
2017-03-23 02:01:25 +08:00
}
2018-05-20 19:06:05 +08:00
func getConfByType(proxyType string) interface{} {
switch proxyType {
case consts.TcpProxy:
return &TcpOutConf{}
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{}
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
2019-01-10 20:53:06 +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 {
w.Write([]byte(res.Msg))
}
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) {
2019-01-15 00:11:08 +08:00
proxyStats := svr.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
2019-01-10 20:53:06 +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 {
w.Write([]byte(res.Msg))
}
}()
2018-05-20 19:06:05 +08:00
log.Info("Http request: [%s]", r.URL.Path)
2019-02-11 11:42:07 +08:00
proxyStatsResp := GetProxyStatsResp{}
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
2019-01-15 00:11:08 +08:00
ps := svr.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
}
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
}
2019-01-10 20:53:06 +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 {
w.Write([]byte(res.Msg))
}
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
2019-01-15 00:11:08 +08:00
proxyTrafficInfo := svr.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
} else {
2019-02-11 11:42:07 +08:00
trafficResp.TrafficIn = proxyTrafficInfo.TrafficIn
trafficResp.TrafficOut = proxyTrafficInfo.TrafficOut
2017-03-23 02:01:25 +08:00
}
2019-02-11 12:15:31 +08:00
buf, _ := json.Marshal(&trafficResp)
2019-02-11 11:42:07 +08:00
res.Msg = string(buf)
}