守护进程 负载均衡

README.md

@@ -29,6 +29,11 @@ go语言编写，无第三方依赖，各个平台都已经编译在release中
     * [release安装](#release安装)
 * [web管理](#web管理模式)（多隧道时推荐）
     * [启动](#启动)
+       * [服务端测试](#服务端测试)
+       * [服务端启动](#服务端启动)
+       * [web管理](#web管理)
+       * [客户端启动](#客户端启动)
+       * [服务端停止或重启](#服务端停止或重启)
     * [配置文件说明](#服务端配置文件)
     * [详细使用说明](#详细说明)
        * [http|https域名解析](#域名解析)
@@ -54,6 +59,8 @@ go语言编写，无第三方依赖，各个平台都已经编译在release中
    * [自定义404页面](#404页面配置)
    * [流量限制](#流量限制)
    * [带宽限制](#带宽限制)
+   * [负载均衡](#负载均衡)
+   * [守护进程](#守护进程)
 * [相关说明](#相关说明)
    * [流量统计](#流量统计)
    * [热更新支持](#热更新支持)
@@ -81,9 +88,9 @@ go语言编写，无第三方依赖，各个平台都已经编译在release中
 - 安装源码(另有snappy、beego包)
 > go get github.com/cnlh/easyProxy
 - 编译
-> go build cmd/proxy_server/proxy_server.go
+> go build cmd/server/proxy_server.go
 
-> go build cmd/proxy_client/proxy_client.go
+> go build cmd/client/proxy_client.go
 
 ## web管理模式
 
@@ -98,22 +105,32 @@ go语言编写，无第三方依赖，各个平台都已经编译在release中
 ### 启动
 
 
-- 服务端
-
+#### 服务端测试
 ```
- ./proxy_server
+ ./proxy_server test
 ```
-
-- 客户端
+如有错误请及时修改配置文件，无错误可继续进行下去
+#### 服务端启动
 ```
- ./proxy_server -server=ip:port -vkey=web界面中显示的密钥
+ ./proxy_server start
 ```
+如果无需daemon运行，去掉start即可
 
-- 配置
+#### web管理
 
 进入web界面，公网ip:web界面端口（默认8080），密码默认为123
 
-进入web管理界面，有详细的命令
+进入web管理界面，有详细的说明
+
+#### 客户端启动
+```
+ ./proxy_server -server=ip:port -vkey=web界面中显示的密钥
+```
+#### 服务端停止或重启
+如果是daemon启动
+```
+ ./proxy_server stop|restart
+```
 
 ### 服务端配置文件
 - /conf/app.conf
@@ -122,6 +139,7 @@ go语言编写，无第三方依赖，各个平台都已经编译在release中
 ---|---
 httpport | web管理端口
 password | web界面管理密码
+hostPort | 域名代理模式监听端口
 tcpport  | 服务端客户端通信端口
 pemPath | ssl certFile绝对路径
 keyPath | ssl keyFile绝对路径
@@ -138,12 +156,13 @@ httpProxyPort | http代理监听端口
 - 有一个域名proxy.com，有一台公网机器ip为1.1.1.1
 - 两个内网开发站点127.0.0.1:81，127.0.0.1:82
 - 想通过（http|https://）a.proxy.com访问127.0.0.1:81，通过（http|https://）b.proxy.com访问127.0.0.1:82
+- 例如配置文件中tcpport为8284
 
 **使用步骤**
 - 将*.proxy.com解析到公网服务器1.1.1.1
 - 在客户端管理中创建一个客户端，记录下验证密钥
 - 点击该客户端的域名管理，添加两条规则规则：1、域名：a.proxy.com，内网目标：127.0.0.1:81，2、域名：b.proxy.com，内网目标：127.0.0.1:82
--内网客户端运行
+- 内网客户端运行
 
 ```
 ./proxy_client server=1.1.1.1:8284 -vkey=客户端的密钥
@@ -158,7 +177,7 @@ httpProxyPort | http代理监听端口
 **适用范围：**  ssh、远程桌面等tcp连接场景
 
 **假设场景：**
- 想通过访问公网服务器1.1.1.1的8001端口，连接内网机器10.1.50.101的22端口，实现ssh连接
+ 想通过访问公网服务器1.1.1.1的8001端口，连接内网机器10.1.50.101的22端口，实现ssh连接，例如配置文件中tcpport为8284
 
 **使用步骤**
 - 在客户端管理中创建一个客户端，记录下验证密钥
@@ -176,7 +195,7 @@ httpProxyPort | http代理监听端口
 **适用范围：**  内网dns解析等udp连接场景
 
 **假设场景：**
-内网有一台dns（10.1.50.102:53），在非内网环境下想使用该dns，公网服务器为1.1.1.1
+内网有一台dns（10.1.50.102:53），在非内网环境下想使用该dns，公网服务器为1.1.1.1，例如配置文件中tcpport为8284
 
 **使用步骤**
 - 在客户端管理中创建一个客户端，记录下验证密钥
@@ -193,7 +212,7 @@ httpProxyPort | http代理监听端口
 **适用范围：**  在外网环境下如同使用vpn一样访问内网设备或者资源
 
 **假设场景：**
-想将公网服务器1.1.1.1的8003端口作为socks5代理，达到访问内网任意设备或者资源的效果
+想将公网服务器1.1.1.1的8003端口作为socks5代理，达到访问内网任意设备或者资源的效果，例如配置文件中tcpport为8284
 
 **使用步骤**
 - 在客户端管理中创建一个客户端，记录下验证密钥
@@ -209,7 +228,7 @@ httpProxyPort | http代理监听端口
 **适用范围：**  在外网环境下使用http代理访问内网站点
 
 **假设场景：**
-想将公网服务器1.1.1.1的8004端口作为http代理，访问内网网站
+想将公网服务器1.1.1.1的8004端口作为http代理，访问内网网站，例如配置文件中tcpport为8284
 
 **使用步骤**
 - 在客户端管理中创建一个客户端，记录下验证密钥
@@ -220,13 +239,14 @@ httpProxyPort | http代理监听端口
 - 在该客户端隧道管理中添加一条http代理，填写监听的端口（8004），选择压缩方式，保存。
 - 在外网环境的本机配置http代理，ip为公网服务器ip（127.0.0.1），端口为填写的监听端口(8004)，即可访问了
 
+
 ### 使用https
 
 在配置文件中将httpsProxyPort设置为443或者其他你想配置的端口，和将对应的证书文件路径添加到配置文件中，即可畅销https了
 
 ### 与nginx配合
 
-普通场景下使用本代理已经能满足使用要求，但是有时候我们还需要在云服务器上运行nginx来保证静态文件缓存等，本代理可和nginx配合使用，在配置文件中将httpProxyPort设置为非80端口，并在nginx中配置代理，例
+有时候我们还需要在云服务器上运行https来保证静态文件缓存等，本代理可和nginx配合使用，在配置文件中将httpProxyPort设置为非80端口，并在nginx中配置代理，例
 ```
 server {
     listen 80;
@@ -491,6 +511,18 @@ authip | 免验证ip，适用于web api
 
 支持客户端级带宽限制，带宽计算方式为入口和出口总和，权重均衡
 
+### 负载均衡
+本代理支持域名解析模式的负载均衡，在web域名添加或者编辑中内网目标分行填写多个目标即可实现轮训级别的负载均衡
+
+### 守护进程
+本代理支持守护进程，使用示例如下，服务端客户端所有模式通用,支持linux，darwin，windows。
+```
+./proxy_(client|server) start|stop|restart xxxxxx
+```
+```
+proxy_(client|server).exe start|stop|restart xxxxxx
+```
+
 ## 相关说明
 
 ### 获取用户真实ip
@@ -531,4 +563,4 @@ authip | 免验证ip，适用于web api
 ## webAPI
 
 为方便第三方扩展，在web模式下可利用webAPI进行相关操作，详情见
-[webAPI文档](https://github.com/cnlh/easyProxy/wiki/webAPI%E6%96%87%E6%A1%A3)
+[webAPI文档](https://github.com/cnlh/easyProxy/wiki/webAPI%E6%96%87%E6%A1%A3)

bridge/bridge.go

@@ -3,7 +3,6 @@ package bridge
 import (
 	"errors"
 	"github.com/cnlh/easyProxy/utils"
-	"log"
 	"net"
 	"sync"
 	"time"
@@ -52,7 +51,7 @@ func (s *Bridge) tunnelProcess() error {
 	for {
 		conn, err := s.listener.Accept()
 		if err != nil {
-			log.Println(err)
+			utils.Println(err)
 			continue
 		}
 		go s.cliProcess(utils.NewConn(conn))
@@ -77,7 +76,7 @@ func (s *Bridge) cliProcess(c *utils.Conn) {
 	//验证
 	id, err := utils.GetCsvDb().GetIdByVerifyKey(string(buf), c.Conn.RemoteAddr().String())
 	if err != nil {
-		log.Println("当前客户端连接校验错误，关闭此客户端:", c.Conn.RemoteAddr())
+		utils.Println("当前客户端连接校验错误，关闭此客户端:", c.Conn.RemoteAddr())
 		s.verifyError(c)
 		return
 	}
@@ -116,7 +115,7 @@ func (s *Bridge) typeDeal(typeVal string, c *utils.Conn, id int) {
 			stop:          make(chan bool),
 			linkStatusMap: make(map[int]bool),
 		}
-		log.Printf("客户端%d连接成功,地址为：%s", id, c.Conn.RemoteAddr())
+		utils.Printf("客户端%d连接成功,地址为：%s", id, c.Conn.RemoteAddr())
 		s.Client[id].signal = c
 		s.clientLock.Unlock()
 		go s.GetStatus(id)
@@ -168,7 +167,7 @@ func (s *Bridge) SendLinkInfo(clientId int, link *utils.Link) (tunnel *utils.Con
 		s.clientLock.Unlock()
 		v.signal.SendLinkInfo(link)
 		if err != nil {
-			log.Println("send error:", err, link.Id)
+			utils.Println("send error:", err, link.Id)
 			s.DelClient(clientId)
 			return
 		}
@@ -258,7 +257,7 @@ func (s *Bridge) clientCopy(clientId int) {
 	for {
 		if id, err := client.tunnel.GetLen(); err != nil {
 			s.closeClient(clientId)
-			log.Println("读取msg id 错误", err, id)
+			utils.Println("读取msg id 错误", err, id)
 			break
 		} else {
 			client.Lock()
@@ -267,7 +266,7 @@ func (s *Bridge) clientCopy(clientId int) {
 				if content, err := client.tunnel.GetMsgContent(link); err != nil {
 					utils.PutBufPoolCopy(content)
 					s.closeClient(clientId)
-					log.Println("read msg content error", err, "close client")
+					utils.Println("read msg content error", err, "close client")
 					break
 				} else {
 					if len(content) == len(utils.IO_EOF) && string(content) == utils.IO_EOF {

client/client.go

@@ -2,7 +2,6 @@ package client
 
 import (
 	"github.com/cnlh/easyProxy/utils"
-	"log"
 	"net"
 	"sync"
 	"time"
@@ -40,7 +39,7 @@ func (s *TRPClient) NewConn() {
 retry:
 	conn, err := net.Dial("tcp", s.svrAddr)
 	if err != nil {
-		log.Println("连接服务端失败,五秒后将重连")
+		utils.Println("连接服务端失败,五秒后将重连")
 		time.Sleep(time.Second * 5)
 		goto retry
 		return
@@ -61,12 +60,12 @@ func (s *TRPClient) processor(c *utils.Conn) {
 	for {
 		flags, err := c.ReadFlag()
 		if err != nil {
-			log.Println("服务端断开,正在重新连接")
+			utils.Println("服务端断开,正在重新连接")
 			break
 		}
 		switch flags {
 		case utils.VERIFY_EER:
-			log.Fatalf("vKey:%s不正确,服务端拒绝连接,请检查", s.vKey)
+			utils.Fatalf("vKey:%s不正确,服务端拒绝连接,请检查", s.vKey)
 		case utils.NEW_CONN:
 			if link, err := c.GetLinkInfo(); err != nil {
 				break
@@ -77,12 +76,12 @@ func (s *TRPClient) processor(c *utils.Conn) {
 				go s.linkProcess(link, c)
 			}
 		case utils.RES_CLOSE:
-			log.Fatal("该vkey被另一客户连接")
+			utils.Fatalln("该vkey被另一客户连接")
 		case utils.RES_MSG:
-			log.Println("服务端返回错误，重新连接")
+			utils.Println("服务端返回错误，重新连接")
 			break
 		default:
-			log.Println("无法解析该错误，重新连接")
+			utils.Println("无法解析该错误，重新连接")
 			break
 		}
 	}
@@ -96,7 +95,7 @@ func (s *TRPClient) linkProcess(link *utils.Link, c *utils.Conn) {
 
 	if err != nil {
 		c.WriteFail(link.Id)
-		log.Println("connect to ", link.Host, "error:", err)
+		utils.Println("connect to ", link.Host, "error:", err)
 		return
 	}
 
@@ -135,12 +134,12 @@ func (s *TRPClient) dealChan() {
 	//创建一个tcp连接
 	conn, err := net.Dial("tcp", s.svrAddr)
 	if err != nil {
-		log.Println("connect to ", s.svrAddr, "error:", err)
+		utils.Println("connect to ", s.svrAddr, "error:", err)
 		return
 	}
 	//验证
 	if _, err := conn.Write([]byte(utils.Getverifyval(s.vKey))); err != nil {
-		log.Println("connect to ", s.svrAddr, "error:", err)
+		utils.Println("connect to ", s.svrAddr, "error:", err)
 		return
 	}
 	//默认长连接保持
@@ -152,14 +151,14 @@ func (s *TRPClient) dealChan() {
 	go func() {
 		for {
 			if id, err := s.tunnel.GetLen(); err != nil {
-				log.Println("get msg id error")
+				utils.Println("get msg id error")
 				break
 			} else {
 				s.Lock()
 				if v, ok := s.linkMap[id]; ok {
 					s.Unlock()
 					if content, err := s.tunnel.GetMsgContent(v); err != nil {
-						log.Println("get msg content error:", err, id)
+						utils.Println("get msg content error:", err, id)
 						break
 					} else {
 						if len(content) == len(utils.IO_EOF) && string(content) == utils.IO_EOF {

cmd/proxy_client/proxy_client.go

@@ -3,20 +3,30 @@ package main
 import (
 	"flag"
 	"github.com/cnlh/easyProxy/client"
-	"log"
+	"github.com/cnlh/easyProxy/utils"
+	_ "github.com/cnlh/easyProxy/utils"
 	"strings"
 )
 
+const VERSION = "v0.0.13"
+
 var (
 	serverAddr = flag.String("server", "", "服务器地址ip:端口")
 	verifyKey  = flag.String("vkey", "", "验证密钥")
+	logType    = flag.String("log", "stdout", "日志输出方式（stdout|file）")
 )
 
 func main() {
 	flag.Parse()
+	utils.InitDaemon("client")
+	if *logType == "stdout" {
+		utils.InitLogFile("client", true)
+	} else {
+		utils.InitLogFile("client", false)
+	}
 	stop := make(chan int)
 	for _, v := range strings.Split(*verifyKey, ",") {
-		log.Println("客户端启动，连接：", *serverAddr, " 验证令牌：", v)
+		utils.Println("客户端启动，连接：", *serverAddr, " 验证令牌：", v)
 		go client.NewRPClient(*serverAddr, v).Start()
 	}
 	<-stop