[TODO]MultiClient

MulitClient:

package plugin

import (
	"log"
	"sync"
	"time"
)

type MultiClientConfig struct {
	FirstAddress   string
	FirstPort      int
	SecondEnable   bool
	SecondAddress  string
	SecondPort     int
	ConnectionType int
}

const (
	CLIENT_NONE = iota
	CLIENT_FIRST
	CLIENT_SECOND
)

type MultiClientConSate struct {
	IsConnected  bool
	ClientObject int
}

const (
	DETECT_MODE_NONE = iota
	DETECT_MODE_ONLY_FIRST
	DETECT_MODE_FIRST_TO_SECOND
	DETECT_MODE_SECOND_TO_FIRST
)

type MultiClient struct {
	Config         MultiClientConfig
	ClientConState MultiClientConSate
	FirstClient    TCPClient
	SecondClient   TCPClient
	Mtx            sync.Mutex
	DetectMode     int
	StopCh         chan string
	wg             sync.WaitGroup
}

func (p *MultiClient) SetClientConState(state *MultiClientConSate) {
	p.Mtx.Lock()
	defer p.Mtx.Unlock()
	p.ClientConState.IsConnected = state.IsConnected
	p.ClientConState.ClientObject = state.ClientObject
	log.Printf("set %v,%v", p.ClientConState.IsConnected, p.ClientConState.ClientObject)
	return
}

func (p *MultiClient) getClientConState() MultiClientConSate {
	p.Mtx.Lock()
	defer p.Mtx.Unlock()
	return p.ClientConState
}

func (p *MultiClient) SetConfig(cfg *MultiClientConfig) {
	p.Mtx.Lock()
	defer p.Mtx.Unlock()
	p.Config.FirstAddress = cfg.FirstAddress
	p.Config.FirstPort = cfg.FirstPort
	p.Config.SecondEnable = cfg.SecondEnable
	p.Config.SecondAddress = cfg.SecondAddress
	p.Config.SecondPort = cfg.SecondPort
	p.Config.ConnectionType = cfg.ConnectionType

	// 同步至主、备
	firstCfg := TCPClientConfig{
		Address:        p.Config.FirstAddress,
		Port:           p.Config.FirstPort,
		ConnectionType: p.Config.ConnectionType,
	}
	p.FirstClient.SetConfig(&firstCfg)

	if p.Config.SecondEnable {
		secondCfg := TCPClientConfig{
			Address:        p.Config.SecondAddress,
			Port:           p.Config.SecondPort,
			ConnectionType: p.Config.ConnectionType,
		}
		p.SecondClient.SetConfig(&secondCfg)
	}
}

// 外部业务判定网络异常时候，调用接口通知
func (p *MultiClient) NotifyConAbnormal() {
	//根据现状来判定网络异常的切换逻辑
	if !p.isEnableFirstAndSecond() {
		//仅主配置了
		p.FirstClient.Stop()
		p.SetClientConState(&MultiClientConSate{IsConnected: false, ClientObject: CLIENT_FIRST})
		p.setDetectMode(DETECT_MODE_ONLY_FIRST)
		return
	} else {
		currentMultiClientCon := p.getClientConState()
		log.Printf("notify check %v,%v", currentMultiClientCon.IsConnected, currentMultiClientCon.ClientObject)

		switch currentMultiClientCon.ClientObject {
		case CLIENT_FIRST:
			p.FirstClient.Stop()
			p.SetClientConState(&MultiClientConSate{IsConnected: false, ClientObject: CLIENT_FIRST})
			p.setDetectMode(DETECT_MODE_FIRST_TO_SECOND)
		case CLIENT_SECOND:
			p.SecondClient.Stop()
			p.SetClientConState(&MultiClientConSate{IsConnected: false, ClientObject: CLIENT_SECOND})
			p.setDetectMode(DETECT_MODE_SECOND_TO_FIRST)
		default:
			return
		}
	}
	return
}
func (p *MultiClient) setDetectMode(mode int) {
	p.Mtx.Lock()
	defer p.Mtx.Unlock()
	p.DetectMode = mode
	return
}
func (p *MultiClient) getDetectMode() int {
	p.Mtx.Lock()
	defer p.Mtx.Unlock()
	return p.DetectMode
}

func (p *MultiClient) getConfig() MultiClientConfig {
	p.Mtx.Lock()
	defer p.Mtx.Unlock()
	return p.Config
}

func (p *MultiClient) Start() {
	log.Printf("MultiClient start enter\n")

	// 1.启动检测携程
	if p.StopCh == nil {
		p.StopCh = make(chan string, 1)
	}
	p.wg.Add(1)
	go p.handleMultiCenterProc()

	// 2.启动主连接
	p.SetClientConState(&MultiClientConSate{IsConnected: false, ClientObject: CLIENT_FIRST})
	if p.FirstClient.Start() {
		p.SetClientConState(&MultiClientConSate{IsConnected: true, ClientObject: CLIENT_FIRST})
	} else {
		log.Printf("start first fail\n")
		if p.isEnableFirstAndSecond() {
			p.setDetectMode(DETECT_MODE_FIRST_TO_SECOND)
		} else {
			p.setDetectMode(DETECT_MODE_ONLY_FIRST)
		}
	}

	log.Printf("MultiClient start leave\n")

}

func (p *MultiClient) Stop() {
	log.Printf("MultiClient Stop enter!\n")

	p.StopCh <- "EXIT"
	close(p.StopCh)
	p.StopCh = nil
	p.wg.Wait()
	log.Printf("proc wait over\n")

	p.FirstClient.Stop()
	p.SecondClient.Stop()

	log.Printf("MultiClient Stop leave\n")
}

func (p *MultiClient) isEnableFirstAndSecond() bool {
	if p.Config.SecondEnable && p.Config.SecondAddress != "" {
		return true
	}
	return false
}

func (p *MultiClient) handleMultiCenterProc() {
	log.Printf("enter handle Multi proc")

	defer p.wg.Done()

	ticker := time.NewTicker(3 * time.Second)
	defer ticker.Stop()

	for {
		if p.StopCh == nil {
			log.Printf("stop ch closed\n")
			return
		}

		select {
		case value := <-p.StopCh:
			log.Printf("ch:%v\n", value)
			if value == "EXIT" {
				log.Printf("MAIN stop proc\n")
				return
			}
		case <-ticker.C:
			p.timerProc()
			log.Printf("================\n")
		}
	}

	return
}

func (p *MultiClient) timerProc() {
	switch p.DetectMode {
	case DETECT_MODE_NONE:
		log.Printf("NONE\n")
		return
	//当第一连接异常时
	case DETECT_MODE_ONLY_FIRST:
		log.Printf("ONLY_FIRST\n")
		if p.FirstClient.TestCon() {
			if p.FirstClient.Start() {
				p.SetClientConState(&MultiClientConSate{IsConnected: true, ClientObject: CLIENT_FIRST})
				p.setDetectMode(DETECT_MODE_NONE)
			} else {
				log.Printf("FirstClient test ok but start fail\n")
			}
		} else {
			log.Printf("FirstClient test fail\n")
			p.SetClientConState(&MultiClientConSate{IsConnected: false, ClientObject: CLIENT_FIRST})
		}
	//当第一连接异常时
	case DETECT_MODE_FIRST_TO_SECOND:
		log.Printf("FIRST_TO_SECOND\n")
		if p.FirstClient.TestCon() {
			if p.FirstClient.Start() {
				p.SetClientConState(&MultiClientConSate{IsConnected: true, ClientObject: CLIENT_FIRST})
				p.setDetectMode(DETECT_MODE_NONE)
			} else {
				log.Printf("FirstClient test ok but start fail\n")
			}
		} else {
			log.Printf("FirstClient test fail, to test second\n")
			if p.SecondClient.TestCon() {
				if p.SecondClient.Start() {
					p.SetClientConState(&MultiClientConSate{IsConnected: true, ClientObject: CLIENT_SECOND})
					p.setDetectMode(DETECT_MODE_SECOND_TO_FIRST)
				} else {
					log.Printf("SecondClient test ok but start fail\n")
				}
			} else {
				log.Printf("FirstClient test fail, second test fail\n")
			}
		}
	//当第二连接异常时或正常时
	case DETECT_MODE_SECOND_TO_FIRST:
		log.Printf("SECOND_TO_FIRST\n")
		if p.FirstClient.TestCon() {
			if p.FirstClient.Start() {
				p.SetClientConState(&MultiClientConSate{IsConnected: true, ClientObject: CLIENT_FIRST})
				p.setDetectMode(DETECT_MODE_NONE)
			} else {
				log.Printf("FirstClient test ok but start fail\n")
			}
		} else {
			// 判断当前第2连接是否处于异常状态
			currentConstate := p.getClientConState()
			if currentConstate.ClientObject == CLIENT_SECOND && currentConstate.IsConnected {
				return
			} else {
				if p.SecondClient.TestCon() {
					if p.SecondClient.Start() {
						p.SetClientConState(&MultiClientConSate{IsConnected: true, ClientObject: CLIENT_SECOND})
						p.setDetectMode(DETECT_MODE_SECOND_TO_FIRST)
					} else {
						log.Printf("SecondClient test ok but start fail\n")
					}
				}
			}

		}
	}
}

func (p *MultiClient) SendAndRecv() {

	// 根据当前状态决定
}

　　TCPClient

package plugin

import (
	"fmt"
	"log"
	"net"
	"sync"
	"time"
)

type TCPClientConfig struct {
	Address        string
	Port           int
	ConnectionType int
}

type TCPClient struct {
	Address string
	Port    int
	Config  TCPClientConfig
	Mtx     sync.Mutex
	LongCon net.Conn
}

func (p *TCPClient) SetConfig(cfg *TCPClientConfig) {
	p.Mtx.Lock()
	defer p.Mtx.Unlock()
	p.Config.Address = cfg.Address
	p.Config.Port = cfg.Port
	p.Config.ConnectionType = cfg.ConnectionType
}

func (p *TCPClient) Start() bool {
	return p.conServer(p.Config.Address, p.Config.Port)
}

func (p *TCPClient) Stop() bool {
	if p.LongCon != nil {
		p.LongCon.Close()
	}
	return true
}

func (p *TCPClient) conServer(addr string, port int) bool {
	serverAddress := fmt.Sprintf("%s:%d", addr, port)
	// 尝试创建TCP连接
	conn, err := net.DialTimeout("tcp", serverAddress, 3*time.Second)
	if err != nil {
		log.Println("连接失败:", err)
		return false
	}

	//defer conn.Close() // 确保连接最后能关闭
	p.LongCon = conn
	log.Println("conServer ok, ", serverAddress)
	return true
}

func (p *TCPClient) TestCon() bool {
	serverAddress := fmt.Sprintf("%s:%d", p.Config.Address, p.Config.Port)
	// 尝试创建TCP连接
	conn, err := net.DialTimeout("tcp", serverAddress, 3*time.Second)
	if err != nil {
		log.Println("连接失败:", err)
		return false
	}
	defer conn.Close() // 确保连接最后能关闭

	log.Println("TestCon ok, ", serverAddress)
	return true
}

　　main

func testMultiClient() {
	fmt.Println("testMultiClient begin")
	mult := plugin.MultiClient{StopCh: make(chan string, 1)}

	cfg := plugin.MultiClientConfig{
		FirstAddress:  "192.168.163.1",
		FirstPort:     60000,
		SecondEnable:  true,
		SecondAddress: "192.168.163.1",
		SecondPort:    60001}

	mult.SetConfig(&cfg)

	mult.Start()

	time.Sleep(30 * time.Second)
	fmt.Println("test notify abnormal -1")
	mult.NotifyConAbnormal()
	fmt.Println("test notify abnormal -1 over")

	time.Sleep(30 * time.Second)
	fmt.Println("test notify abnormal -2")
	mult.NotifyConAbnormal()

	time.Sleep(30 * time.Second)
	mult.Stop()
	fmt.Println("testMultiClient end")
}

func main() {
	fmt.Println("hello world")

	//testMutilGO()

	//testMutilGOSub()
	testMultiClient()

	fmt.Println("main over")
}