Клиент застрял при попытке чтения с io.CopyN () в golang - PullRequest
Новая
       16

Клиент застрял при попытке чтения с io.CopyN () в golang

0 голосов
/ 08 сентября 2018

Я пытаюсь сделать TCP-сервер для передачи файлов. Я подаю в суд на io.CopyN за чтение и письмо. Со стороны сервера я отправляю файлы клиенту, поэтому со стороны сервера он отлично отправляет все байты, но сторона клиента после чтения пары 1000000 байтов застряла. иногда это работает хорошо, а иногда застревает. Я использую 300 МБ PDF для тестирования. Любая помощь, код и вывод приведены ниже.

Сервер 

    package main

    import (
        "fmt"
        "io"
        "log"
        "net"
        "os"
        "strconv"
        "strings"
    )

    func main() {

        ls, err := net.Listen("tcp", ":1234")

        errFunc(err)

        defer ls.Close()

        conn, _ := ls.Accept()

        defer conn.Close()

        for {

            file, err := os.Open(strings.TrimSpace("./" + "Mag" + ".pdf"))

            errFunc(err)

            defer file.Close()

            fileInfo, err := file.Stat()

            errFunc(err)

            size := fileInfo.Size()

            numberOfTime := size / 1000000

            leftByte := size - numberOfTime*1000000

            numberOfTimeString := strconv.Itoa(int(numberOfTime))
            leftByteString := strconv.Itoa(int(leftByte))

            fmt.Println("1000000 times : ", numberOfTimeString)

            fmt.Println("Left Bytes : ", leftByteString)

            _, err = fmt.Fprintf(conn, numberOfTimeString+"\n")

            errFunc(err)

            _, err = fmt.Fprintf(conn, leftByteString+"\n")

            errFunc(err)

            fileWriter := io.Writer(conn)

            for i := 0; i < int(numberOfTime); i++ {

                n, err := io.CopyN(conn, file, 1000000)

                if i >= 30 {
                    fmt.Println(err, n)
                }
            }

            n, err := io.CopyN(fileWriter, file, leftByte+1)

            if err == io.EOF {
                fmt.Println(err, n)
            }

            fmt.Printf("Succefully bytes sent : %v \n\n\n\n\n", n)

            file.Close()

        }

    }

    func errFunc(err error) {

        if err != nil {
            log.Fatal(err)
        }

    }

клиент 

    package main

    import (
        "bufio"
        "fmt"
        "io"
        "net"
        "os"
        "os/signal"
        "strconv"
        "strings"
        "syscall"
    )

    func main() {

        c := make(chan os.Signal, 15)
        signal.Notify(c, syscall.SIGINT)

        go func() {

            for {
                s := <-c

                switch s {

                case syscall.SIGINT:
                    os.Exit(1)
                }

            }

        }()

        conn, _ := net.Dial("tcp", ":1234")

        defer conn.Close()

        connReadWrite := bufio.NewReader(io.Reader(conn))

        var i int
        var filename string

        for {

            i++

            nu := strconv.Itoa(i)

            filename = "image" + nu + ".pdf"

            file, err := os.Create(filename)

            defer file.Close()

            numberOfTimeString, err := connReadWrite.ReadString('\n')

            if err != nil {

                fmt.Println(err)
            }

            println("1000000 times :", numberOfTimeString)

            numberOfTimeString = strings.TrimSuffix(numberOfTimeString, "\n")

            numberOfTime, err := strconv.Atoi(numberOfTimeString)

            if err != nil {

                fmt.Println(err)
            }

            leftByteString, err := connReadWrite.ReadString('\n')

            if err != nil {

                println(err)
            }

            println("Left Bytes :", leftByteString)

            leftByteString = strings.TrimSuffix(leftByteString, "\n")

            leftByte, err := strconv.Atoi(leftByteString)

            if err != nil {

                panic(err)
            }

            fmt.Println("After convert in Num :", numberOfTime, leftByte)

            newFileWriter := io.Writer(file)
            newFileReader := io.Reader(conn)

            for i := 0; i < numberOfTime; i++ {

                n, err := io.CopyN(newFileWriter, newFileReader, 1000000)

                if i >= 30 {
                    errFun(err, n)
                }
            }

            n, err := io.CopyN(newFileWriter, newFileReader, int64(leftByte))

            errFun(err, n)

            fmt.Printf("sucessfully Transfered ---> \n\n\n\n\n\n")

        }

    }

    func errFun(err error, n int64) {

        if err == io.EOF {

            fmt.Println("End of file : ", n)
            return

        } else if n == 0 {

            fmt.Println("n is : ", n)
            return

        } else if err != nil {
            fmt.Println(err)
            return

        }

        fmt.Println(err, " : ", n)
    }

вход / выход

сначала со стороны сервера мы отправляем количество байтов, которое необходимо прочитать, а затем со стороны клиента получаем число байтов, которое необходимо прочитать, а затем я отправляю файл, а затем он читает. На рисунке я смог отправить один раз второй раз, когда он застрял, иногда он завис тоже , он читает что-то "% PDF ..." и даже не печатает "100000 раз:" правильно печатает "% ??? 00 раз:" Я просто не понимаю этого

введите описание изображения здесь

1 Ответ

0 голосов
/ 09 сентября 2018

Я считаю, что проблема в том, что вы используете bytes.Buffer в клиенте: 

connReadWrite := bufio.NewReader(io.Reader(conn))

Но вы не используете его позже с CopyN: 

newFileWriter := io.Writer(file)
newFileReader := io.Reader(conn)
for i := 0; i < numberOfTime; i++ {
    _, err := io.CopyN(newFileWriter, newFileReader, 1000000)
    if err != nil {
        log.Fatalln(err)
    }
}

Использование: 

newFileWriter := io.Writer(file)

for i := 0; i < numberOfTime; i++ {
    _, err := io.CopyN(file, connReadWrite, 1000000)
    if err != nil {
        log.Fatalln(err)
    }
}

Может это исправить.

Если у вас есть контроль над протоколом, который вы используете для отправки файла, я рекомендую сделать что-нибудь попроще. Например, используя префикс длины big-endian int64.

Отправить: 

func sendFile(name string, conn net.Conn) error {
    f, err := os.Open(name)
    if err != nil {
        return err
    }
    defer f.Close()

    fi, err := f.Stat()
    if err != nil {
        return err
    }
    sz := fi.Size()

    buf := bufio.NewWriter(conn)

    err = binary.Write(buf, binary.BigEndian, sz)
    if err != nil {
        return err
    }

    _, err = io.CopyN(buf, f, sz)
    if err != nil {
        return err
    }

    return buf.Flush()
}

Прием: 

func recvFile(name string, conn net.Conn) error {
    f, err := os.Create(name)
    if err != nil {
        return err
    }
    defer f.Close()

    buf := bufio.NewReader(conn)
    var sz int64
    err = binary.Read(buf, binary.BigEndian, &sz)
    if err != nil {
        return err
    }

    _, err = io.CopyN(f, buf, sz)
    if err != nil {
        return err
    }

    return nil
}
...