2. Zinx-V0.2 Simple Connection Encapsulation and Binding with Business

//zinx/ziface/iconnection.go
package ziface

import "net"

// Define the connection interface
type IConnection interface {
    // Start the connection, making the current connection work
    Start()
    // Stop the connection, ending the current connection state
    Stop()
    // Get the raw socket TCPConn from the current connection
    GetTCPConnection() *net.TCPConn
    // Get the current connection ID
    GetConnID() uint32
    // Get the remote client's address information
    RemoteAddr() net.Addr
}

// Define an interface for handling connection business uniformly
type HandFunc func(*net.TCPConn, []byte, int) error

type HandFunc func(*net.TCPConn, []byte, int) error

//zinx/znet/connection.go
package znet

import (
    "fmt"
    "net"
    "zinx/ziface"
)

type Connection struct {
    // Current connection's socket TCP socket
    Conn *net.TCPConn
    // Current connection's ID, also known as SessionID, ID is 
    globally unique
    ConnID uint32
    // Current connection's close status
    isClosed bool

    // The handle function of this connection's api
    handleAPI ziface.HandFunc

    // Channel to inform that the connection has exited/stopped
    ExitBuffChan chan bool
}

//zinx/znet/connection.go

func NewConntion(conn *net.TCPConn, connID uint32, callback_api ziface.HandFunc) *Connection{
    c := &Connection{
        Conn:     conn,
        ConnID:   connID,
        isClosed: false,
        handleAPI: callback_api,
        ExitBuffChan: make(chan bool, 1),
    }

    return c
}

//zinx/znet/connection.go

/* Goroutine to handle reading data from the connection */
func (c *Connection) StartReader() {
    fmt.Println("Reader Goroutine is running")
    defer fmt.Println(c.RemoteAddr().String(), " conn reader exit!")
    defer c.Stop()

    for  {
        // Read the largest amount of data to buf
        buf := make([]byte, 512)
        cnt, err := c.Conn.Read(buf)
        if err != nil {
             fmt.Println("recv buf err ", err)
             c.ExitBuffChan <- true
             continue
        }
        // Call the handle function registered by the developer for this connection to handle the business logic
        if err := c.handleAPI(c.Conn, buf, cnt); err !=nil {
             fmt.Println("connID ", c.ConnID, " handle is error")
             c.ExitBuffChan <- true
             return
        }
    }
}

//zinx/znet/connection.go

func (c *Connection) Start() {

    go c.StartReader()

    for {
        select {
        case <- c.ExitBuffChan:
            return
        }
    }
}

//zinx/znet/connection.go

// Stop the connection and end the current connection state.
func (c *Connection) Stop() {
    //1. If the current connection is already closed
    if c.isClosed == true {
        return
    }
    c.isClosed = true

    // TODO Connection Stop() If the user has registered the close callback business of the connection, it should be called explicitly at this moment.

    // Close the socket connection
    c.Conn.Close()

    // Notify the business that reads data from the buffer queue that the connection has been closed
    c.ExitBuffChan <- true

    // Close all channels for this connection
    close(c.ExitBuffChan)
}

//zinx/znet/connection.go

// Get the original socket TCPConn from the current connection
func (c *Connection) GetTCPConnection() *net.TCPConn {
    return c.Conn
}

// Get the current connection ID
func (c *Connection) GetConnID() uint32{
    return c.ConnID
}

// Get the remote client address information
func (c *Connection) RemoteAddr() net.Addr {
    return c.Conn.RemoteAddr()
}

//zinx/znet/server.go
package znet

import (
    "errors"
    "fmt"
    "net"
    "time"
    "zinx/ziface"
)

// iServer implementation, defines a Server service class
type Server struct {
    // the name of the server
    Name string
    // tcp4 or other
    IPVersion string
    // the IP address that the server is bound to
    IP string
    // the port that the server is bound to
    Port int
}

//============== Define the handle API for the current client connection ===========
func CallBackToClient(conn *net.TCPConn, data []byte, cnt int) error {
    // echo business
    fmt.Println("[Conn Handle] CallBackToClient ... ")
    if _, err := conn.Write(data[:cnt]); err !=nil {
        fmt.Println("write back buf err ", err)
        return errors.New("CallBackToClient error")
    }
    return nil
}

//============== Implement all interface methods in ziface.IServer ========

// start the network service
func (s *Server) Start() {
    fmt.Printf("[START] Server listenner at IP: %s, Port %d, is starting\n", s.IP, s.Port)

// start a go routine to do the server listener business
    go func() {
        // 1. get a TCP address
        addr, err := net.ResolveTCPAddr(s.IPVersion, fmt.Sprintf("%s:%d", s.IP, s.Port))
        if err != nil {
            fmt.Println("resolve tcp addr err: ", err)
            return
        }

        // 2. listen to the server address
        listenner, err:= net.ListenTCP(s.IPVersion, addr)
        if err != nil {
            fmt.Println("listen", s.IPVersion, "err", err)
            return
        }

        // the listener has started successfully
        fmt.Println("start Zinx server  ", s.Name, " succ, now listenning...")

        // TODO server.go should have a method to generate ID automatically
        var cid uint32
        cid = 0

        // 3. start the server network connection business
        for {
            // 3.1. block and wait for the client to establish a connection request
            conn, err := listenner.AcceptTCP()
            if err != nil {
                fmt.Println("Accept err ", err)
                continue
            }

            // 3.2. TODO Server.Start() set the maximum connection control of the server. If the maximum connection is exceeded, then close this new connection

            // 3.3. handle the new connection request business, where handler and conn are bound
            dealConn := NewConntion(conn, cid, CallBackToClient)
            cid ++

            // 3.4. start the handling business of the current connection
            go dealConn.Start()
        }
    }()
}

// ... ...

    //…

    //3.3 处理该新连接请求的 业务 方法， 此时应该有 handler 和 conn是绑定的
    dealConn := NewConntion(conn, cid, CallBackToClient)
    cid ++

    //3.4 启动当前链接的处理业务
    go dealConn.Start()

    //…

//Server.go
package main

import (
    "zinx/znet"
)

//Test function for Server module
func main() {

    //1 create a server handle s
    s := znet.NewServer("[zinx V0.1]")

    //2 start the service
    s.Serve()
}

go run Server.go

//Client.go
package main

import (
    "fmt"
    "net"
    "time"
)

func main() {

    fmt.Println("Client Test ... start")
    //Wait for 3 seconds before making a test request to give the server a chance to start up
    time.Sleep(3 * time.Second)

    conn,err := net.Dial("tcp", "127.0.0.1:7777")
    if err != nil {
        fmt.Println("client start err, exit!")
        return
    }

    for {
        _, err := conn.Write([]byte("hahaha"))
        if err !=nil {
            fmt.Println("write error err ", err)
            return
        }

        buf :=make([]byte, 512)
        cnt, err := conn.Read(buf)
        if err != nil {
            fmt.Println("read buf error ")
            return
        }

        fmt.Printf(" server call back : %s, cnt = %d\n", buf,  cnt)

        time.Sleep(1*time.Second)
    }
}

go run Client.go

[START] Server listenner at IP: 0.0.0.0, Port 7777, is starting
Client Test ... start
listen tcp4 err listen tcp4 0.0.0.0:7777: bind: address already in use
server call back : hello ZINX, cnt = 6
server call back : hello ZINX, cnt = 6
server call back : hello ZINX, cnt = 6
server call back : hello ZINX, cnt = 6