Go - correct usage of multipart Part.Read

I've been trying to use multipart.Part to help read very large file uploads (>20GB) from HTTP - so I've written the below code which seems to work nicely:

func ReceiveMultipartRoute(w http.ResponseWriter, r *http.Request) {
	mediatype, p, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
	if err != nil {
	   //...
	}
	if mediatype != "multipart/form-data" {
		//...
	}
	boundary := p["boundary"]
	reader := multipart.NewReader(r.Body, boundary)
	buffer := make([]byte, 8192)
	for {
		part, err := reader.NextPart()
		if err != nil {
			// ... 
		}
	
		f, err := os.CreateTemp("", part.FileName())
		if err != nil {
			// ...
		}
	
		for {
			numBytesRead, err := part.Read(buffer)
			// People say not to read if there's an err, but then I miss the last chunk?
			f.Write(buffer[:numBytesRead])
			if err != nil {
				if err == io.EOF {
					break
				} else {
					// error, abort ...
					return
				}
			}
		}
	}
}

However, in the innermost for loop, I found out that I have to read from part.Read before even checking for EOF, as I notice that I will miss the last chunk if I do so beforehand and break. However, I notice on many other articles/posts where people check for errors/EOF, and break-ing if there is without using the last read. Am I using multipart.Part.Read() wrongly/safely?

You use multipart.Part in a proper way.

multipart.Part is a particular implementation of io.Reader. Accordingly, you should be guided by the conventions and follow the recommendations for io.Reader. Quote from the documentation:

>Callers should always process the n > 0 bytes returned before considering the error err. Doing so correctly handles I/O errors that happen after reading some bytes and also both of the allowed EOF behaviors.

Also note that in the example you are copying data from io.Reader to os.File. os.File implements io.ReaderFrom interface, so you can use File.ReadFrom() method to copy the data.

_, err := file.ReadFrom(part)
// non io.EOF
if err != nil {
    return fmt.Errorf("copy data: %w", err)
}

If you need to use a buffer, you can use io.CopyBuffer() function. But note that you need to hide io.ReaderFrom implementation, otherwise the buffer will not be used to perform the copy. See examples: 1, 2, 3.

_, err := io.CopyBuffer(writeFunc(file.Write), part, buffer)
// non io.EOF
if err != nil {
    return fmt.Errorf("copy data: %w", err)
}

type writeFunc func([]byte) (int, error)

func (write writeFunc) Write(data []byte) (int, error) {
        return write(data)
}