all: add "--reload" command for frps, reload ini file without kill old program

src/frp/models/server/config.go

@@ -18,14 +18,17 @@ import (
 	"fmt"
 	"strconv"
 	"strings"
+	"sync"
 
 	ini "github.com/vaughan0/go-ini"
 
+	"frp/utils/log"
 	"frp/utils/vhost"
 )
 
 // common config
 var (
+	ConfigFile       string = "./frps.ini"
 	BindAddr         string = "0.0.0.0"
 	BindPort         int64  = 7000
 	VhostHttpPort    int64  = 0 // if VhostHttpPort equals 0, don't listen a public port for http
@@ -37,20 +40,39 @@ var (
 	HeartBeatTimeout int64  = 90
 	UserConnTimeout  int64  = 10
 
-	VhostMuxer *vhost.HttpMuxer
+	VhostMuxer        *vhost.HttpMuxer
+	ProxyServers      map[string]*ProxyServer = make(map[string]*ProxyServer) // all proxy servers info and resources
+	ProxyServersMutex sync.RWMutex
 )
 
-var ProxyServers map[string]*ProxyServer = make(map[string]*ProxyServer)
-
 func LoadConf(confFile string) (err error) {
-	var tmpStr string
-	var ok bool
-
-	conf, err := ini.LoadFile(confFile)
+	err = loadCommonConf(confFile)
 	if err != nil {
 		return err
 	}
 
+	// load all proxy server's configure and initialize
+	// and set ProxyServers map
+	newProxyServers, err := loadProxyConf(confFile)
+	if err != nil {
+		return err
+	}
+	for _, proxyServer := range newProxyServers {
+		proxyServer.Init()
+	}
+	ProxyServersMutex.Lock()
+	ProxyServers = newProxyServers
+	ProxyServersMutex.Unlock()
+	return nil
+}
+
+func loadCommonConf(confFile string) error {
+	var tmpStr string
+	var ok bool
+	conf, err := ini.LoadFile(confFile)
+	if err != nil {
+		return err
+	}
 	// common
 	tmpStr, ok = conf.Get("common", "bind_addr")
 	if ok {
@@ -95,18 +117,26 @@ func LoadConf(confFile string) (err error) {
 	if ok {
 		LogMaxDays, _ = strconv.ParseInt(tmpStr, 10, 64)
 	}
+	return nil
+}
 
+func loadProxyConf(confFile string) (proxyServers map[string]*ProxyServer, err error) {
+	var ok bool
+	proxyServers = make(map[string]*ProxyServer)
+	conf, err := ini.LoadFile(confFile)
+	if err != nil {
+		return proxyServers, err
+	}
 	// servers
 	for name, section := range conf {
 		if name != "common" {
-			proxyServer := &ProxyServer{}
-			proxyServer.CustomDomains = make([]string, 0)
+			proxyServer := NewProxyServer()
 			proxyServer.Name = name
 
 			proxyServer.Type, ok = section["type"]
 			if ok {
 				if proxyServer.Type != "tcp" && proxyServer.Type != "http" {
-					return fmt.Errorf("Parse ini file error: proxy [%s] type error", proxyServer.Name)
+					return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] type error", proxyServer.Name)
 				}
 			} else {
 				proxyServer.Type = "tcp"
@@ -114,7 +144,7 @@ func LoadConf(confFile string) (err error) {
 
 			proxyServer.AuthToken, ok = section["auth_token"]
 			if !ok {
-				return fmt.Errorf("Parse ini file error: proxy [%s] no auth_token found", proxyServer.Name)
+				return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] no auth_token found", proxyServer.Name)
 			}
 
 			// for tcp
@@ -128,10 +158,10 @@ func LoadConf(confFile string) (err error) {
 				if ok {
 					proxyServer.ListenPort, err = strconv.ParseInt(portStr, 10, 64)
 					if err != nil {
-						return fmt.Errorf("Parse ini file error: proxy [%s] listen_port error", proxyServer.Name)
+						return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] listen_port error", proxyServer.Name)
 					}
 				} else {
-					return fmt.Errorf("Parse ini file error: proxy [%s] listen_port not found", proxyServer.Name)
+					return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] listen_port not found", proxyServer.Name)
 				}
 			} else if proxyServer.Type == "http" {
 				// for http
@@ -142,20 +172,53 @@ func LoadConf(confFile string) (err error) {
 						suffix = fmt.Sprintf(":%d", VhostHttpPort)
 					}
 					proxyServer.CustomDomains = strings.Split(domainStr, ",")
+					if len(proxyServer.CustomDomains) == 0 {
+						return proxyServers, fmt.Errorf("Parse conf error: proxy [%s] custom_domains must be set when type equals http", proxyServer.Name)
+					}
 					for i, domain := range proxyServer.CustomDomains {
 						proxyServer.CustomDomains[i] = strings.ToLower(strings.TrimSpace(domain)) + suffix
 					}
 				}
 			}
+			proxyServers[proxyServer.Name] = proxyServer
+		}
+	}
+	return proxyServers, nil
+}
 
+// the function can only reload proxy configures
+// common section won't be changed
+func ReloadConf(confFile string) (err error) {
+	loadProxyServers, err := loadProxyConf(confFile)
+	if err != nil {
+		return err
+	}
+
+	ProxyServersMutex.Lock()
+	for name, proxyServer := range loadProxyServers {
+		oldProxyServer, ok := ProxyServers[name]
+		if ok {
+			if !oldProxyServer.Compare(proxyServer) {
+				oldProxyServer.Close()
+				proxyServer.Init()
+				ProxyServers[name] = proxyServer
+				log.Info("ProxyName [%s] configure change, restart", name)
+			}
+		} else {
 			proxyServer.Init()
-			ProxyServers[proxyServer.Name] = proxyServer
+			ProxyServers[name] = proxyServer
+			log.Info("ProxyName [%s] is new, init it", name)
 		}
 	}
 
-	if len(ProxyServers) == 0 {
-		return fmt.Errorf("Parse ini file error: no proxy config found")
+	for name, oldProxyServer := range ProxyServers {
+		_, ok := loadProxyServers[name]
+		if !ok {
+			oldProxyServer.Close()
+			delete(ProxyServers, name)
+			log.Info("ProxyName [%s] deleted, close it", name)
+		}
 	}
-
+	ProxyServersMutex.Unlock()
 	return nil
 }

src/frp/models/server/dashboard.go

@@ -28,7 +28,7 @@ func RunDashboardServer(addr string, port int64) (err error) {
 	}()
 	gin.SetMode(gin.ReleaseMode)
 	router := gin.New()
-	router.LoadHTMLGlob("assets/*")
+	//router.LoadHTMLGlob("assets/*")
 	router.GET("/api/reload", apiReload)
 	go router.Run(fmt.Sprintf("%s:%d", addr, port))
 	return

src/frp/models/server/dashboard_api.go

@@ -15,12 +15,32 @@
 package server
 
 import (
+	"encoding/json"
+	"fmt"
+
 	"github.com/gin-gonic/gin"
+
+	"frp/utils/log"
 )
 
-func apiReload(c *gin.Context) {
-	c.JSON(200, gin.H{
-		"code": 0,
-		"msg":  "ok",
-	})
+type GeneralResponse struct {
+	Code int64  `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+func apiReload(c *gin.Context) {
+	res := &GeneralResponse{}
+	defer func() {
+		buf, _ := json.Marshal(res)
+		log.Info("Http response [/api/reload]: %s", string(buf))
+	}()
+
+	log.Info("Http request: [/api/reload]")
+	err := ReloadConf(ConfigFile)
+	if err != nil {
+		res.Code = 2
+		res.Msg = fmt.Sprintf("%v", err)
+		log.Error("frps reload error: %v", err)
+	}
+	c.JSON(200, res)
 }

src/frp/models/server/server.go

@@ -35,21 +35,49 @@ type ProxyServer struct {
 	Type          string
 	BindAddr      string
 	ListenPort    int64
-	UseEncryption bool
 	CustomDomains []string
 
+	// configure in frpc.ini
+	UseEncryption bool
+
 	Status       int64
+	CtlConn      *conn.Conn      // control connection with frpc
 	listeners    []Listener      // accept new connection from remote users
 	ctlMsgChan   chan int64      // every time accept a new user conn, put "1" to the channel
 	workConnChan chan *conn.Conn // get new work conns from control goroutine
 	mutex        sync.Mutex
 }
 
+func NewProxyServer() (p *ProxyServer) {
+	p = &ProxyServer{
+		CustomDomains: make([]string, 0),
+	}
+	return p
+}
+
 func (p *ProxyServer) Init() {
+	p.Lock()
 	p.Status = consts.Idle
 	p.workConnChan = make(chan *conn.Conn, 100)
 	p.ctlMsgChan = make(chan int64)
 	p.listeners = make([]Listener, 0)
+	p.Unlock()
+}
+
+func (p *ProxyServer) Compare(p2 *ProxyServer) bool {
+	if p.Name != p2.Name || p.AuthToken != p2.AuthToken || p.Type != p2.Type ||
+		p.BindAddr != p2.BindAddr || p.ListenPort != p2.ListenPort {
+		return false
+	}
+	if len(p.CustomDomains) != len(p2.CustomDomains) {
+		return false
+	}
+	for i, _ := range p.CustomDomains {
+		if p.CustomDomains[i] != p2.CustomDomains[i] {
+			return false
+		}
+	}
+	return true
 }
 
 func (p *ProxyServer) Lock() {
@@ -61,7 +89,8 @@ func (p *ProxyServer) Unlock() {
 }
 
 // start listening for user conns
-func (p *ProxyServer) Start() (err error) {
+func (p *ProxyServer) Start(c *conn.Conn) (err error) {
+	p.CtlConn = c
 	p.Init()
 	if p.Type == "tcp" {
 		l, err := conn.Listen(p.BindAddr, p.ListenPort)
@@ -79,9 +108,11 @@ func (p *ProxyServer) Start() (err error) {
 		}
 	}
 
+	p.Lock()
 	p.Status = consts.Working
+	p.Unlock()
 
-	// start a goroutine for listener to accept user connection
+	// start a goroutine for every listener to accept user connection
 	for _, listener := range p.listeners {
 		go func(l Listener) {
 			for {
@@ -138,6 +169,9 @@ func (p *ProxyServer) Close() {
 		}
 		close(p.ctlMsgChan)
 		close(p.workConnChan)
+		if p.CtlConn != nil {
+			p.CtlConn.Close()
+		}
 	}
 	p.Unlock()
 }