fileUpload.go

package main

import (
	"bufio"
	"errors"
	"fmt"
	"log"
	"mime/multipart"
	"net/http"
	"os"
	"path"

	"github.com/gorilla/mux"
)

const FILE_DIRECTORY_LOCATION = "./files"

var lineSplitter = func(data []byte, atEOF bool) (advance int, token []byte, err error) {
	//read last bit of data!!
	if atEOF && len(data) > 0 {
		return len(data), data, nil
	}

	//means reading in data is complete!
	if atEOF && len(data) == 0 {
		return 0, nil, bufio.ErrFinalToken
	}

	//just read wanted amount set in buffer
	return len(data), data, nil
}

type FileUploadRoute struct {
}

func (t *FileUploadRoute) ServeHTTP(w http.ResponseWriter, r *http.Request) {

	err := r.ParseMultipartForm(r.ContentLength)

	if err != nil {

		w.WriteHeader(http.StatusBadGateway)
		w.Write([]byte("error parsing form"))
		return
	}

	formFiles := r.MultipartForm.File["file"]

	if len(formFiles) == 0 {

		w.WriteHeader(http.StatusBadRequest)
		w.Write([]byte("no files sent!!"))
		return
	}

	errChan := make(chan error)
	defer close(errChan)

	for _, fileHeader := range formFiles {

		file, errFileOpen := fileHeader.Open()

		if errFileOpen != nil {

			w.WriteHeader(http.StatusInternalServerError)
			w.Write([]byte("err saving files"))
			return
		}

		defer file.Close()
		go saveFile(file, fileHeader, errChan)
	}

	select {
	case <-errChan:
		w.WriteHeader(http.StatusInternalServerError)
		w.Write([]byte("err saving files"))
		return
	default:
		fmt.Println("no message recieved")
	}
}

func createScanner(file multipart.File, tokenSize int) bufio.Scanner {

	reader := bufio.NewReader(file)
	scanner := *bufio.NewScanner(reader)
	scanner.Buffer(make([]byte, tokenSize), int(tokenSize))
	scanner.Split(lineSplitter)

	return scanner
}

func persistLocalData(fileName string, scanner bufio.Scanner, c chan error) {

	saveFile, createError := os.Create(fileName)

	if createError != nil {
		c <- createError
	}

	defer saveFile.Close()

	for scanner.Scan() {

		if scanErr := scanner.Err(); scanErr != nil {
			c <- scanErr
		}

		bytes := scanner.Bytes()
		saveFile.Write(bytes)
	}
}

func getSaveFileDirLocation(fileName string) string {

	return path.Join(FILE_DIRECTORY_LOCATION, fileName)
}

func fileExist(filePath string) bool {

	_, fileError := os.Stat(filePath)
	return !errors.Is(fileError, os.ErrNotExist)
}

func saveFile(file multipart.File, fileHeader *multipart.FileHeader, c chan error) {

	fileNameStr := getSaveFileDirLocation(fileHeader.Filename)
	os.MkdirAll(FILE_DIRECTORY_LOCATION, os.ModeDir)

	if fileExist(fileNameStr) {

		c <- errors.New("file already exists!")
	} else {

		persistLocalData(fileNameStr, createScanner(file, int(fileHeader.Size/20)), c)
	}
}

func main() {
	router := mux.NewRouter()
	router.Handle("/uploadFile", &FileUploadRoute{}).Methods(http.MethodPost)
	log.Fatal(http.ListenAndServe(":8000", router))
}

parse multipart file uploads with the key "file". persist to local "files" directory.