// Options is a configuration container to setup the XFF middleware.type Options struct {// AllowedSubnets is a list of Subnets from which we will accept the// X-Forwarded-For header.// If this list is empty we will accept every Subnets (default).AllowedSubnets []string// Debugging flag adds additional output to debug server side XFF issues.Debug bool}// New creates a new XFF handler with the provided options.func New(options Options) (*XFF, error) {    allowedMasks, err := toMasks(options.AllowedSubnets)    if err != nil {       return nil, err    }    xff := &XFF{       allowAll:     len(options.AllowedSubnets) == 0,       allowedMasks: allowedMasks,    }    if options.Debug {       xff.Log = log.New(os.Stdout, "[xff] ", log.LstdFlags)    }    return xff, nil}// XFF http handlertype XFF struct {// Debug loggerLog *log.Logger// Set to true if all IPs or Subnets are allowed.allowAll bool// List of IP subnets that are allowed.allowedMasks []net.IPNet}// New creates a new XFF handler with the provided options.func New(options Options) (*XFF, error) {allowedMasks, err := toMasks(options.AllowedSubnets)if err != nil {return nil, err}xff := &XFF{allowAll:     len(options.AllowedSubnets) == 0,allowedMasks: allowedMasks,}if options.Debug {xff.Log = log.New(os.Stdout, "[xff] ", log.LstdFlags)}return xff, nil}// Default creates a new XFF handler with default options.func Default() (*XFF, error) {return New(Options{})}

// HandlerFunc provides Martini compatible handlerfunc (xff *XFF) HandlerFunc(w http.ResponseWriter, r *http.Request) {r.RemoteAddr = GetRemoteAddrIfAllowed(r, xff.allowed)}// Handler updates RemoteAdd from X-Fowarded-For Headers.func (xff *XFF) Handler(h http.Handler) http.Handler {return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {r.RemoteAddr = GetRemoteAddrIfAllowed(r, xff.allowed)h.ServeHTTP(w, r)})}// Negroni compatible interfacefunc (xff *XFF) ServeHTTP(w http.ResponseWriter, r *http.Request, next http.HandlerFunc) {r.RemoteAddr = GetRemoteAddrIfAllowed(r, xff.allowed)next(w, r)}

// Parse parses the value of the X-Forwarded-For Header and returns the IP address.func Parse(ipList string) string {for _, ip := range strings.Split(ipList, ",") {ip = strings.TrimSpace(ip)if IP := net.ParseIP(ip); IP != nil && IsPublicIP(IP) {return ip}}return ""}

// list of private subnetsvar privateMasks, _ = toMasks([]string{"127.0.0.0/8","10.0.0.0/8","172.16.0.0/12","192.168.0.0/16","fc00::/7",})// IsPublicIP returns true if the given IP can be routed on the Internet.func IsPublicIP(ip net.IP) bool {if !ip.IsGlobalUnicast() {return false}return !ipInMasks(ip, privateMasks)}// IsGlobalUnicast reports whether ip is a global unicast// address.//// The identification of global unicast addresses uses address type// identification as defined in RFC 1122, RFC 4632 and RFC 4291 with// the exception of IPv4 directed broadcast addresses.// It returns true even if ip is in IPv4 private address space or// local IPv6 unicast address space.func (ip IP) IsGlobalUnicast() bool {return (len(ip) == IPv4len || len(ip) == IPv6len) &&!ip.Equal(IPv4bcast) &&!ip.IsUnspecified() &&!ip.IsLoopback() &&!ip.IsMulticast() &&!ip.IsLinkLocalUnicast()}

// IsPrivate reports whether ip is a private address, according to// RFC 1918 (IPv4 addresses) and RFC 4193 (IPv6 addresses).func (ip IP) IsPrivate() bool {if ip4 := ip.To4(); ip4 != nil {// Following RFC 1918, Section 3. Private Address Space which says://   The Internet Assigned Numbers Authority (IANA) has reserved the//   following three blocks of the IP address space for private internets://     10.0.0.0        -   10.255.255.255  (10/8 prefix)//     172.16.0.0      -   172.31.255.255  (172.16/12 prefix)//     192.168.0.0     -   192.168.255.255 (192.168/16 prefix)return ip4[0] == 10 ||(ip4[0] == 172 && ip4[1]&0xf0 == 16) ||(ip4[0] == 192 && ip4[1] == 168)}// Following RFC 4193, Section 8. IANA Considerations which says://   The IANA has assigned the FC00::/7 prefix to "Unique Local Unicast".return len(ip) == IPv6len && ip[0]&0xfe == 0xfc}

type RetryConfig struct {  // 外部取消重试动作的上下文context         context.Context  // 最大重试次数retryTimes      uint  // 重试间隔策略backoffStrategy BackoffStrategy}

// BackoffStrategy is an interface that defines a method for calculating backoff intervals.type BackoffStrategy interface {// CalculateInterval returns the time.Duration after which the next retry attempt should be made.CalculateInterval() time.Duration}

 type RetryFunc func() error funcPath := runtime.FuncForPC(reflect.ValueOf(retryFunc).Pointer()).Name()lastSlash := strings.LastIndex(funcPath, "/")funcName := funcPath[lastSlash+1:]

// RetryFunc is function that retry executestype RetryFunc func() error// Option is for adding retry configtype Option func(*RetryConfig)func Retry(retryFunc RetryFunc, opts ...Option) error {config := &RetryConfig{retryTimes: DefaultRetryTimes,context:    context.TODO(),}for _, opt := range opts {opt(config)}if config.backoffStrategy == nil {config.backoffStrategy = &linear{interval: DefaultRetryLinearInterval,}}var i uintfor i < config.retryTimes {err := retryFunc()if err != nil {select {case <-time.After(config.backoffStrategy.CalculateInterval()):case <-config.context.Done():return errors.New("retry is cancelled")}} else {return nil}i++}funcPath := runtime.FuncForPC(reflect.ValueOf(retryFunc).Pointer()).Name()lastSlash := strings.LastIndex(funcPath, "/")funcName := funcPath[lastSlash+1:]return fmt.Errorf("function %s run failed after %d times retry", funcName, i)}

// linear is a struct that implements the BackoffStrategy interface using a linear backoff strategy.type linear struct {    // interval specifies the fixed duration to wait between retry attempts.    interval time.Duration}// CalculateInterval calculates the next interval returns a constant.func (l *linear) CalculateInterval() time.Duration {    return l.interval}

// exponentialWithJitter is a struct that implements the BackoffStrategy interface using a exponential backoff strategy.type exponentialWithJitter struct {    base      time.Duration // base is the multiplier for the exponential backoff.    interval  time.Duration // interval is the current backoff interval, which will be adjusted over time.    maxJitter time.Duration // maxJitter is the maximum amount of jitter to apply to the backoff interval.}// CalculateInterval calculates the next backoff interval with jitter and updates the interval.func (e *exponentialWithJitter) CalculateInterval() time.Duration {    current := e.interval    e.interval = e.interval * e.base    return current + jitter(e.maxJitter)}

// shiftExponentialWithJitter is a struct that implements the BackoffStrategy interface using a exponential backoff strategy.type shiftExponentialWithJitter struct {interval  time.Duration // interval is the current backoff interval, which will be adjusted over time.maxJitter time.Duration // maxJitter is the maximum amount of jitter to apply to the backoff interval.shifter   uint64        // shift by n faster than multiplication}// CalculateInterval calculates the next backoff interval with jitter and updates the interval.// Uses shift instead of multiplicationfunc (e *shiftExponentialWithJitter) CalculateInterval() time.Duration {current := e.intervale.interval = e.interval << e.shifterreturn current + jitter(e.maxJitter)}

////Oldtype NewCacheConfig struct {  MaxSize int64}func NewCacheConfig(maxSize int64)*NewCacheConfig{  return &NewCacheConfig{    MaxSize: maxSize,  }}NewCacheConfig(20)//Newtype NewCacheConfig struct {  MaxSize int64  MaxLifeTime time.Duration}func NewCacheConfig(maxSize int64,maxLifeTime time.Duration)*NewCacheConfig{  return &NewCacheConfig{    MaxSize: maxSize,    MaxLifeTime: maxLifeTime,  }}//caller need to be changedNewCacheConfig(20,2*time.Second)

//Oldtype Option func(*CacheConfig)type CacheConfig struct {  MaxSize int64}func NewCacheConfig(maxSize int64,opts ...Option)*CacheConfig{    cc := &CacheConfig{    MaxSize: maxSize,  }    for _,opt := range opts {    opt(cc)  }    return cc  }NewCacheConfig(20)//Newtype Cacher struct {  MaxSize int64  MaxLifeTime time.Duration}func WithMaxLifeTime(maxLifeTime time.Duration)Option{  return func(cc *CacheConfig){    cc.MaxLifeTime = maxLifeTime  }}func NewCacheConfig(maxSize int64,maxLifeTime time.Duration)*CacheConfig{  cc := &CacheConfig{    MaxSize: maxSize,    MaxLifeTime: 3*time.Second,  }    for _,opt := range opts {    opt(cc)  }    return cc}//caller no need to be changedNewCacheConfig(20) //output &{20 3s}NewCacheConfig(20,WithMaxLifeTime(1*time.Second)) //output &{20 1s}

package maintype Face interface {FaceShape() string}type RoundFace struct {}func (rf RoundFace) FaceShape() string {return "round"}func GetFace() Face {var rf RoundFacereturn rf}func main() {if GetFace() == nil {println("nil")} else {println("not nil")}}

package mainimport ("sync")func main() {  var once sync.Oncech := make(chan struct{}, 1)ch <- struct{}{}once.Do(func() {close(ch)})}

package mainimport ("fmt""time")func main() {ch := make(chan struct{}, 1)ch <- struct{}{}close(ch)for {select {case zero, open := <-ch:        fmt.Println(open)        // 当channel被关闭后，open 会变成false        if !closed {          return        }fmt.Println(zero)time.Sleep(time.Second)}}}

package mainimport ("fmt""time")func main() {ch := make(chan struct{}, 1)ch <- struct{}{}close(ch)for {select {case zero, open := <-ch:fmt.Println(zero)fmt.Println(open)time.Sleep(time.Second)}}}

package mainimport ("net/http""time")func main() {client := http.DefaultClient  // 创建两个tcp连接go request(client)go request(client)  // 间隔5s让前面两个http请求处理完毕time.Sleep(5 * time.Second)  // 正常来说下面的两个http请求会复用上面的tcp链接go request(client)go request(client)time.Sleep(6 * time.Second)}func request(client *http.Client) {resp, _ := client.Get("https://www.baidu.com")defer resp.Body.Close()// 未读取response.Body//io.Copy(io.Discard, resp.Body)}

package mainimport ("io""net/http""time")func main() {client := http.DefaultClient// 创建两个tcp连接go request(client)go request(client)// 间隔5s让前面两个http请求处理完毕time.Sleep(5 * time.Second)// 正常来说下面的两个http请求会复用上面的tcp链接go request(client)go request(client)time.Sleep(6 * time.Second)}func request(client *http.Client) {resp, _ := client.Get("https://www.baidu.com")defer resp.Body.Close()// 读取response.Bodyio.Copy(io.Discard, resp.Body)}

if cr.Annotations != nil {if v, ok := cr.Annotations["key"]; ok && v == "false" {return false}}

var s1 = []int{1, 2, 3}var s2 = []int{2, 1, 3}func TestDeepEqual() {log.Println(reflect.DeepEqual(s1, s2)) // false}func TestDeepEqualWithSort() {slices.Sort(s1)slices.Sort(s2)log.Println(reflect.DeepEqual(s1, s2)) // true}

package mainimport ("net""syscall")func NewRstDialer() *net.Dialer {return &net.Dialer{Control: func(network, address string, c syscall.RawConn) error {return c.Control(func(fd uintptr) {        // 此处激活so_linger，同时设置超时时间为0syscall.SetsockoptLinger(int(fd), syscall.SOL_SOCKET, syscall.SO_LINGER, &syscall.Linger{Onoff: 1, Linger: 0})})},}}func main() {rstDialer := NewRstDialer()rstConn, _ := rstDialer.Dial("tcp", "127.0.0.1:8080")_ = rstConn.Close()finDialer := net.Dialer{}finConn, _ := finDialer.Dial("tcp", "127.0.0.1:8080")_ = finConn.Close()}

type HTTPProxy struct {    // ReverseProxy为原始net.httputil封装的 http/https 代理对象    hostMap map[string]*httputil.ReverseProxy    // 负载均衡对象    lb      balancer.Balancer    //用于 保证 alive map 读写安全，因为针对每个单独的节点都会起一个协程 用来读写alive map    sync.RWMutex // protect alive    //用于保存 后端节点健康状态    alive        map[string]bool}

import ("log""net/http""strconv""github.com/gorilla/mux""github.com/zehuamama/balancer/proxy")router := mux.NewRouter()for _, l := range config.Location {httpProxy, err := proxy.NewHTTPProxy(l.ProxyPass, l.BalanceMode)if err != nil {log.Fatalf("create proxy error: %s", err)}// start health checkif config.HealthCheck {httpProxy.HealthCheck(config.HealthCheckInterval)}router.Handle(l.Pattern, httpProxy)}if config.MaxAllowed > 0 {router.Use(maxAllowedMiddleware(config.MaxAllowed))}

//负载均衡策略接口type Balancer interface {  // 新增节点Add(string)  // 删除节点Remove(string)  // 选择节点Balance(string) (string, error)  // 节点新增连接Inc(string)  // 节点结束连接Done(string)}

// 定义了默认的 基础负载均衡策略，没有实现任何负载均衡算法，直接单纯实现 balance 接口，具体的算法实现不一定需要实现所有的接口，所以由 BaseBalancer 负责实现默认/空实现接口的功能函数，其他具体的实现只需要引用BaseBalancer即可type BaseBalancer struct {    sync.RWMutex    hosts []string}// Add new host to the balancerfunc (b *BaseBalancer) Add(host string) {b.Lock()defer b.Unlock()for _, h := range b.hosts {if h == host {return}}b.hosts = append(b.hosts, host)}// Remove new host from the balancerfunc (b *BaseBalancer) Remove(host string) {b.Lock()defer b.Unlock()for i, h := range b.hosts {if h == host {b.hosts = append(b.hosts[:i], b.hosts[i+1:]...)return}}}// Balance selects a suitable host accordingfunc (b *BaseBalancer) Balance(key string) (string, error) {return "", nil}// Inc .func (b *BaseBalancer) Inc(_ string) {}// Done .func (b *BaseBalancer) Done(_ string) {}

// Balance selects a suitable host accordingfunc (r *Random) Balance(_ string) (string, error) {r.RLock()defer r.RUnlock()if len(r.hosts) == 0 {return "", NoHostError}return r.hosts[r.rnd.Intn(len(r.hosts))], nil}

// Balance selects a suitable host accordingfunc (r *IPHash) Balance(key string) (string, error) {    r.RLock()    defer r.RUnlock()    if len(r.hosts) == 0 {       return "", NoHostError    }    value := crc32.ChecksumIEEE([]byte(key)) % uint32(len(r.hosts))    return r.hosts[value], nil}

import ("sync"fibHeap "github.com/starwander/GoFibonacciHeap")// Tag .func (h *host) Tag() interface{} { return h.name }// Key .func (h *host) Key() float64 { return float64(h.load) }

// Done refers to the number of connections to the server `-1`func (l *LeastLoad) Done(hostName string) {    l.Lock()    defer l.Unlock()    if ok := l.heap.GetValue(hostName); ok == nil {       return    }    h := l.heap.GetValue(hostName)    h.(*host).load--    _ = l.heap.DecreaseKeyValue(h)}

func (h *HTTPProxy) healthCheck(host string, interval uint) {ticker := time.NewTicker(time.Duration(interval) * time.Second)  /*  当然这里不需要写这个，但是养成良好习惯，及时回收资源，防止泄露  defer func(){    ticker.Stop()    }()  */    //定时执行健康检查探活逻辑for range ticker.C {if !IsBackendAlive(host) && h.ReadAlive(host) {log.Printf("Site unreachable, remove %s from load balancer.", host)h.SetAlive(host, false)h.lb.Remove(host)} else if IsBackendAlive(host) && !h.ReadAlive(host) {log.Printf("Site reachable, add %s to load balancer.", host)h.SetAlive(host, true)h.lb.Add(host)}}}

// IsBackendAlive Attempt to establish a tcp connection to determine whether the site is alivefunc IsBackendAlive(host string) bool {addr, err := net.ResolveTCPAddr("tcp", host)if err != nil {return false}resolveAddr := fmt.Sprintf("%s:%d", addr.IP, addr.Port)conn, err := net.DialTimeout("tcp", resolveAddr, ConnectionTimeout)if err != nil {return false}_ = conn.Close()return true}

//kubernetes tcp端口探活package probeimport ("net""syscall")// ProbeDialer returns a dialer optimized for probes to avoid lingering sockets on TIME-WAIT state.// The dialer reduces the TIME-WAIT period to 1 seconds instead of the OS default of 60 seconds.// Using 1 second instead of 0 because SO_LINGER socket option to 0 causes pending data to be// discarded and the connection to be aborted with an RST rather than for the pending data to be// transmitted and the connection closed cleanly with a FIN.// Ref: https://issues.k8s.io/89898func ProbeDialer() *net.Dialer {dialer := &net.Dialer{Control: func(network, address string, c syscall.RawConn) error {return c.Control(func(fd uintptr) {syscall.SetsockoptLinger(int(fd), syscall.SOL_SOCKET, syscall.SO_LINGER, &syscall.Linger{Onoff: 1, Linger: 1})})},}return dialer}

package maintype Handler func()var handler Handler = func() {println("ok")}type Middleware func(Handler) Handlerfunc Chain(m ...Middleware) Middleware {return func(next Handler) Handler {for i := len(m) - 1; i >= 0; i-- {next = m[i](next)}return next}}func middleware1(next Handler) Handler {return func() {println("middleware1")defer func() {println("middleware1f")}()next()}}func middleware2(next Handler) Handler {return func() {println("middleware2")defer func() {println("middleware2f")}()next()}}func middleware3(next Handler) Handler {return func() {println("middleware3")defer func() {println("middleware3f")}()next()}}func main() {ms := []Middleware{middleware1, middleware2, middleware3}Chain(ms...)(handler)()}/*输出Chain(ms...)(handler)() 其实对应的形式就是 ms[0](ms[1](ms[2](handler)))() 这样是不是更好理解了middleware1middleware2middleware3okmiddleware3fmiddleware2fmiddleware1f*/

package middlewareimport ("context")// Handler defines the handler invoked by Middleware.type Handler func(ctx context.Context, req interface{}) (interface{}, error)// Middleware is HTTP/gRPC transport middleware.type Middleware func(Handler) Handler// Chain returns a Middleware that specifies the chained handler for endpoint.func Chain(m ...Middleware) Middleware {return func(next Handler) Handler {for i := len(m) - 1; i >= 0; i-- {next = m[i](next)}return next}

func (client *Client) invoke(ctx context.Context, req *http.Request, args interface{}, reply interface{}, c callInfo, opts ...CallOption) error {  //kratos 定义好的调用业务逻辑的handlerh := func(ctx context.Context, in interface{}) (interface{}, error) {res, err := client.do(req.WithContext(ctx))if res != nil {cs := csAttempt{res: res}for _, o := range opts {o.after(&c, &cs)}}if err != nil {return nil, err}defer res.Body.Close()if err := client.opts.decoder(ctx, res, reply); err != nil {return nil, err}return reply, nil}var p selector.Peerctx = selector.NewPeerContext(ctx, &p)if len(client.opts.middleware) > 0 {    // kratos 定义好的 调用业务逻辑的handler 传入，迭代调用 后的middlewareh = middleware.Chain(client.opts.middleware...)(h)}  // 真实调用 包含了kratos定义好的调用业务逻辑的handler 迭代封装后的 middleware_, err := h(ctx, args)return err}

import (    "context"    "github.com/go-kratos/kratos/v2/middleware"    "github.com/go-kratos/kratos/v2/transport")func Middleware1() middleware.Middleware {    return func(handler middleware.Handler) middleware.Handler {        return func(ctx context.Context, req interface{}) (reply interface{}, err error) {            if tr, ok := transport.FromServerContext(ctx); ok {                // Do something on entering                defer func() {                // Do something on exiting                 }()            }            // 在最后需要手动调用 传入的 handler 形成链式调用            return handler(ctx, req)        }    }}

package mainimport ("flag""fmt""os""github.com/fatih/color")var settings Settingsfunc main() {  //解析命令行参数，并校验参数//启动服务if err := startListener(); err != nil {fmt.Fprintln(os.Stderr, color.HiRedString("[x] Failed to start listener: %v", err))os.Exit(1)}}

var ( //定义 flag 变量)//当输入flag数量不正确时将默认的启动参数与用法进行打印输出，直接返回，提醒用户缺少参数输入if len(os.Args) < 1 {  flag.Usage()  return}flag.Parse()if len(settings.Remote) == 0 {  fmt.Fprintln(os.Stderr, color.HiRedString("[x] Remote target required"))  //在出错的时候将默认的启动参数与用法进行打印输出，并错误退出，提示用户虽然提供了参数，但是内容不符合要求  flag.PrintDefaults()  os.Exit(1)}

func startListener() error {  //创建并启动tcp连接计数器stat = NewStater(NewConnCounter(), NewStatPrinter(statInterval))go stat.Start()  conn, err := net.Listen("tcp", fmt.Sprintf("%s:%d", settings.LocalHost, settings.LocalPort))if err != nil {return fmt.Errorf("failed to start listener: %w", err)}//defer 紧跟在conn成功创建之后，很好的习惯defer conn.Close()display.PrintfWithTime("Listening on %s...\n", conn.Addr().String())var connIndex intfor {    // accept 客户端连接cliConn, err := conn.Accept()if err != nil {return fmt.Errorf("server: accept: %w", err)}connIndex++display.PrintlnWithTime(color.HiGreenString("[%d] Accepted from: %s",connIndex, cliConn.RemoteAddr()))    //创建连接对，并使用协程处理连接数据    pconn := NewPairedConnection(connIndex, cliConn)go pconn.process()}}

go func() {//设置接收系统 signal Ctrl+C / kill -15 信号c := make(chan os.Signal, 1)signal.Notify(c, os.Interrupt, syscall.SIGTERM)        // 使用 range chan 阻塞等待 信号进入 ，个人感觉 直接 sig <- c 可能更好for sig := range c {            // 停止接收 signal 信号signal.Stop(c)                      //执行程序停止前的处理stat.Stop()            //找到当前进程p, err := os.FindProcess(syscall.Getpid())if err != nil {fmt.Println(err)os.Exit(0)}          //将signal信号 重新发送给当前进程 用以关闭当前程序，不用担心 再次接收到 signal信号，毕竟已经使用 signal.Stop(c) 停止接收signal信号了if err := p.Signal(sig); err != nil {fmt.Println(err)}}}()

type PairedConnection struct {     //connection id      id int      // 下游服务连接      cliConn net.Conn      // 上游服务连接      svrConn net.Conn      once    sync.Once      //关闭 chan      stopChan chan struct{}  }

// NewPairedConnection 生成 , 设置 客户端连接 ID，客户端连接，还有 停止通道 func NewPairedConnection(id int, cliConn net.Conn) *PairedConnection {      return &PairedConnection{          id:       id,          cliConn:  cliConn,          stopChan: make(chan struct{}),      } }  func (c *PairedConnection) process() {      defer c.stop()      // 连接远端服务      conn, err := net.Dial("tcp", settings.Remote)      if err != nil {          display.PrintlnWithTime(color.HiRedString("[x][%d] Couldn't connect to server: %v", c.id, err))          return      }      display.PrintlnWithTime(color.HiGreenString("[%d] Connected to server: %s", c.id, conn.RemoteAddr()))     //调用统计 新增连接方法      stat.AddConn(strconv.Itoa(c.id), conn.(*net.TCPConn))          // 保存 服务端 连接      c.svrConn = conn      // 处理 服务端 数据      go c.handleServerMessage()      // 处理 客户端 数据      c.handleClientMessage()  }

func (c *PairedConnection) handleServerMessage() {     // server closed also trigger client close.     defer c.stop()    //建立内存读写通道     r, w := io.Pipe()    //构造 客户端连接 与 内存通道 的 多写对象     tee := io.MultiWriter(newDelayedWriter(c.cliConn, settings.Delay, c.stopChan), w)    //根据设置的数据协议，使用对应协议解析 内存读通道中 服务端写入的响应数据     go protocol.CreateInterop(settings.Protocol).Dump(r, protocol.ServerSide, c.id, settings.Quiet)    // 将 服务端上游 返回数据 输出到 多写对象     c.copyDataWithRateLimit(tee, c.svrConn, protocol.ServerSide, settings.DownLimit) }

func (c *PairedConnection) handleClientMessage() {// client closed also trigger server close.defer c.stop()r, w := io.Pipe()tee := io.MultiWriter(c.svrConn, w)  //根据设置的数据协议，使用对应协议解析 内存读通道中 客户端写入的请求数据go protocol.CreateInterop(settings.Protocol).Dump(r, protocol.ClientSide, c.id, settings.Quiet)c.copyDataWithRateLimit(tee, c.cliConn, protocol.ClientSide, settings.UpLimit)}

func (c *PairedConnection) stop() {    // 使用 once 保证 stop 资源回收只会执行一次    c.once.Do(func() {        close(c.stopChan)        stat.DelConn(strconv.Itoa(c.id))        if c.cliConn != nil {            display.PrintlnWithTime(color.HiBlueString("[%d] Client connection closed", c.id))            c.cliConn.Close()        }        if c.svrConn != nil {            display.PrintlnWithTime(color.HiBlueString("[%d] Server connection closed", c.id))            c.svrConn.Close()        }    })}

  func (c *PairedConnection) copyData(dst io.Writer, src io.Reader, tag string) {      _, e := io.Copy(dst, src)      //但是此处的判断 e != io.EOF 个人感觉是不需要的，因为 io.Copy 函数明确说明不会返回io.EOF 的错误，在判断 错误类型是非为 net操作类错误，如非 net 操作类错误，不做处理（这个合理吗）我去每个没吃透的点都是以后埋的坑，此处对 io.Copy 中如 io.Writer 或 io.Reader 被手动或其他原因意外关闭，则进行忽略，结束当前 Copy 即可    //https://golang-nuts.narkive.com/ae58tX8v/use-of-closed-network-connection-error-from-tcpconn-read    // useOfClosedConn 代表了 当前操作的 io.Writer 或 io.Reader 被关闭      if e != nil && e != io.EOF {          netOpError, ok := e.(*net.OpError)          if ok && netOpError.Err.Error() != useOfClosedConn {            //error 库的 使用 ?              reason := netOpError.Unwrap().Error()              display.PrintlnWithTime(color.HiRedString("[%d] %s error, %s", c.id, tag, reason))          }      }  }//ErrFileClosing is returned when a file descriptor is used after it has been closed.// go io.Copy的api说明// Copy copies from src to dst until either EOF is reached// on src or an error occurs. It returns the number of bytes// copied and the first error encountered while copying, if any.//// A successful Copy returns err == nil, not err == EOF.// Because Copy is defined to read from src until EOF, it does// not treat an EOF from Read as an error to be reported.//// If src implements [WriterTo],// the copy is implemented by calling src.WriteTo(dst).// Otherwise, if dst implements [ReaderFrom],// the copy is implemented by calling dst.ReadFrom(src).func Copy(dst Writer, src Reader) (written int64, err error) {    return copyBuffer(dst, src, nil)