Golang实现echo server和rate limit client

TCP Server

package main

import (
    "errors"
    "flag"
    "fmt"
    "io"
    "net"
)

func main() {
    port := flag.Int("port", 1323, "tcp server port")
    flag.Parse()

    l, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        return
    }
    defer l.Close()

    fmt.Println("Listening on:", *port)
    for {
        conn, err := l.Accept()
        if errors.Is(err, net.ErrClosed) {
           fmt.Println("Error accepting:", err.Error())
           return
        }
        if err != nil {
           fmt.Println(err)
           continue
        }
        defer conn.Close()
        go io.Copy(conn, conn)
    }
}

TCP Client

package main

import (
    "flag"
    "fmt"
    "io"
    "net"
    "time"
    "math/rand"

    "github.com/juju/ratelimit"
)

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func randSeq() []byte {
    b := make([]rune, 1024)
    for i := range b {
        b[i] = letters[rand.Intn(len(letters))]
    }
    return []byte(string(b))
}

func main() {
    addr := flag.String("addr", "127.0.0.1", "tcp server addr")
    port := flag.Int("port", 1323, "tcp server port")
    rate := flag.Int("rate", 1024, "send data rate per second")
    printResp := flag.Bool("print", false, "whether print server response")
    flag.Parse()

    server := fmt.Sprintf("%s:%d", *addr, *port)
    bucket := ratelimit.NewBucketWithQuantum(time.Second, int64(*rate), int64(*rate))

    t := time.NewTicker(time.Duration(100) * time.Microsecond)
    defer t.Stop()
    for range t.C {
        rand.Seed(time.Now().UnixNano())
        data := randSeq()

        //tcpServer, err := net.ResolveTCPAddr("tcp", server)
        conn, err := net.Dial("tcp", server)
        if err != nil {
            fmt.Println(err)
            continue
        }
        defer conn.Close()

        go func(conn net.Conn) {
            buf := make([]byte, 1024)
            for {
                _, err := io.ReadFull(conn, buf)
                if err != nil {
                    fmt.Println("ReadFull err:", err)
                    break
                }
                if *printResp {
                    fmt.Println("received:", string(buf))
                }
             }
        }(conn)

        for {
            bucket.Wait(1)
            _, err := conn.Write(data)
            if err != nil {
                fmt.Println("Write err:", err)
                break
            }
        }
    }
}

UDP Server

package main

import (
    "fmt"
    "net"
)

func main() {
    addr := ":2022"

    s, err := net.ResolveUDPAddr("udp4", addr)
    if err != nil {
        fmt.Println(err)
        return
    }

    conn, err := net.ListenUDP("udp4", s)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer conn.Close()
    fmt.Println("Server listening on UDP port:", addr)

    buffer := make([]byte, 1024)
    for {
        _, addr, err := conn.ReadFromUDP(buffer)
        if err != nil {
            fmt.Println(err)
            continue
        }

        _, err = conn.WriteToUDP(buffer, addr)
        if err != nil {
            fmt.Println(err)
            continue
        }
    }
}

UDP Client

package main

import (
    "flag"
    "fmt"
    "net"
    "time"
    "math/rand"

    "github.com/juju/ratelimit"
)

var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")

func randSeq() []byte {
    b := make([]rune, 1024)
    for i := range b {
        b[i] = letters[rand.Intn(len(letters))]
    }
    return []byte(string(b))
}

func main() {
    server := flag.String("server", "127.0.0.1", "udp server host")
    rate := flag.Int("rate", 1024, "send data per second")
    printResp := flag.Bool("print", false, "whether print response data")
    flag.Parse()

    udpServer := fmt.Sprintf("%s:2022", *server)
    bucket := ratelimit.NewBucketWithQuantum(time.Second, int64(*rate), int64(*rate))

    t := time.NewTicker(time.Duration(1000) * time.Microsecond)
    defer t.Stop()
    for range t.C {
        rand.Seed(time.Now().UnixNano())
        data := randSeq()

        conn, err := net.Dial("udp4", udpServer)
        if err != nil {
            fmt.Println(err)
            continue
        }
        defer conn.Close()

        go func(conn net.Conn) {
            buf := make([]byte, 1024)
            for {
                _, err := conn.Read(buf)
                if err != nil {
                    fmt.Println("ReadFromUDP err:", err)
                    break
                }
                if *printResp {
                    fmt.Println("Reply:", string(buf))
                }
            }
        }(conn)

        for {
            bucket.Wait(1)
            _, err = conn.Write([]byte(data))
            if err != nil {
                fmt.Println("Write err:", err)
                break
            }
        }
    }
}

---

original refer