Golang Large File Transfer Guide

In Golang, you can use the HTTP protocol to achieve large file transfer and resume interrupted transfers. Below is a simple example code:

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"strconv"
)

func handler(w http.ResponseWriter, r *http.Request) {
	file, err := os.Open("large_file.txt")
	if err != nil {
		fmt.Println("Error opening file: ", err)
		return
	}
	defer file.Close()

	fileInfo, err := file.Stat()
	if err != nil {
		fmt.Println("Error getting file info: ", err)
		return
	}

	w.Header().Set("Content-Disposition", "attachment; filename=large_file.txt")
	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Content-Length", strconv.FormatInt(fileInfo.Size(), 10))

	http.ServeContent(w, r, "large_file.txt", fileInfo.ModTime(), file)
}

func main() {
	http.HandleFunc("/", handler)
	http.ListenAndServe(":8080", nil)
}

In the example above, we started by opening a large file named large_file.txt, set the HTTP response headers, and then used the http.ServeContent function to send the file content to the client. The client can download this large file by accessing http://localhost:8080.

To achieve the functionality of resuming downloads, you can determine where to start the transfer by checking the Range header of the HTTP request. Below is a modified example code:

func handler(w http.ResponseWriter, r *http.Request) {
	file, err := os.Open("large_file.txt")
	if err != nil {
		fmt.Println("Error opening file: ", err)
		return
	}
	defer file.Close()

	fileInfo, err := file.Stat()
	if err != nil {
		fmt.Println("Error getting file info: ", err)
		return
	}

	w.Header().Set("Content-Disposition", "attachment; filename=large_file.txt")
	w.Header().Set("Content-Type", "application/octet-stream")
	w.Header().Set("Content-Length", strconv.FormatInt(fileInfo.Size(), 10))

	rangeHeader := r.Header.Get("Range")
	if rangeHeader != "" {
		startRange, endRange, err := parseRangeHeader(rangeHeader, fileInfo.Size())
		if err != nil {
			fmt.Println("Error parsing range header: ", err)
			return
		}
		w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", startRange, endRange, fileInfo.Size()))
		http.ServeContent(w, r, "large_file.txt", fileInfo.ModTime(), io.NewSectionReader(file, startRange, endRange-startRange+1))
	} else {
		http.ServeContent(w, r, "large_file.txt", fileInfo.ModTime(), file)
	}
}

func parseRangeHeader(rangeHeader string, fileSize int64) (int64, int64, error) {
	prefix := "bytes="
	if len(rangeHeader) < len(prefix) || rangeHeader[:len(prefix)] != prefix {
		return 0, 0, fmt.Errorf("Invalid range header format")
	}
	rangeStr := rangeHeader[len(prefix):]

	dashIndex := strings.IndexByte(rangeStr, '-')
	if dashIndex == -1 {
		return 0, 0, fmt.Errorf("Invalid range header format")
	}

	startRange, err := strconv.ParseInt(rangeStr[:dashIndex], 10, 64)
	if err != nil {
		return 0, 0, err
	}

	endRangeStr := rangeStr[dashIndex+1:]
	var endRange int64
	if endRangeStr == "" {
		endRange = fileSize - 1
	} else {
		endRange, err = strconv.ParseInt(endRangeStr, 10, 64)
		if err != nil {
			return 0, 0, err
		}
	}

	return startRange, endRange, nil
}

In the modified example code above, we first parse the Range header of the HTTP request, then read the file content based on the requested range, and set the Content-Range header to inform the client of the range of content being transferred.

Through this method, we can achieve the capability of transferring large files and resuming uploads from where they left off. In practice, the code can be further optimized and expanded based on requirements.