Je joue avec Mux et net/http
. Dernièrement, j'essaie d'obtenir un serveur simple avec un point de terminaison pour accepter le téléchargement d'un fichier.
Voici le code que j'ai jusqu'à présent:
server.go
package main
import (
"fmt"
"github.com/gorilla/mux"
"log"
"net/http"
)
func main() {
router := mux.NewRouter()
router.
Path("/upload").
Methods("POST").
HandlerFunc(UploadCsv)
fmt.Println("Starting")
log.Fatal(http.ListenAndServe(":8080", router))
}
endpoint.go
package main
import (
"fmt"
"net/http"
)
func UploadFile(w http.ResponseWriter, r *http.Request) {
err := r.ParseMultipartForm(5 * 1024 * 1024)
if err != nil {
panic(err)
}
fmt.Println(r.FormValue("fileupload"))
}
Je pense avoir réduit le problème à la récupération du corps de la requête dans UploadFile
. Quand j'exécute cette commande cURL:
curl http://localhost:8080/upload -F "[email protected]" -vvv
Je reçois une réponse vide (comme prévu; je n'imprime pas sur le ResponseWriter
), mais je reçois simplement une nouvelle ligne (vide) imprimée à l'invite où je suis en train d'exécuter le serveur, au lieu de la demande. corps.
Je vous envoie le fichier en plusieurs parties (autant que je sache, implicite en utilisant -F
plutôt que -d
dans cURL), et la sortie commentée de cURL montre 502 octets envoyés:
$ curl http://localhost:8080/upload -F "[email protected]" -vvv
* Trying ::1...
* TCP_NODELAY set
* Connected to localhost (::1) port 8080 (#0)
> POST /upload HTTP/1.1
> Host: localhost:8080
> User-Agent: curl/7.51.0
> Accept: */*
> Content-Length: 520
> Expect: 100-continue
> Content-Type: multipart/form-data; boundary=------------------------b578878d86779dc5
>
< HTTP/1.1 100 Continue
< HTTP/1.1 200 OK
< Date: Fri, 18 Nov 2016 19:01:50 GMT
< Content-Length: 0
< Content-Type: text/plain; charset=utf-8
<
* Curl_http_done: called premature == 0
* Connection #0 to Host localhost left intact
Quelle est la manière appropriée de recevoir des fichiers téléchargés sous forme de données de formulaire multipart à l'aide d'un fichier net/http
serveur dans Go?
Voici un exemple rapide
func ReceiveFile(w http.ResponseWriter, r *http.Request) {
var Buf bytes.Buffer
// in your case file would be fileupload
file, header, err := r.FormFile("file")
if err != nil {
panic(err)
}
defer file.Close()
name := strings.Split(header.Filename, ".")
fmt.Printf("File name %s\n", name[0])
// Copy the file data to my buffer
io.Copy(&Buf, file)
// do something with the contents...
// I normally have a struct defined and unmarshal into a struct, but this will
// work as an example
contents := Buf.String()
fmt.Println(contents)
// I reset the buffer in case I want to use it again
// reduces memory allocations in more intense projects
Buf.Reset()
// do something else
// etc write header
return
}
Vous devriez utiliser FormFile
au lieu de FormValue
:
file, handler, err := r.FormFile("fileupload")
defer file.Close()
// copy example
f, err := os.OpenFile("./downloaded", os.O_WRONLY|os.O_CREATE, 0666)
defer f.Close()
io.Copy(f, file)
Voici une fonction que j'ai écrite pour m'aider à télécharger mes fichiers. Vous pouvez vérifier la version complète ici. Comment télécharger des fichiers dans golang
package helpers
import (
"net/http"
"os"
"io"
)
func FileUpload(r *http.Request) (string, error) {
//this function returns the filename(to save in database) of the saved file or an error if it occurs
r.ParseMultipartForm(32 << 20)
//ParseMultipartForm parses a request body as multipart/form-data
var file_name string
var errors error
file, handler, err := r.FormFile("file")//retrieve the file from form data
defer file.Close() //close the file when we finish
if err != nil {
errors = err
}
//this is path which we want to store the file
f, err := os.OpenFile("./images/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0666)
if err != nil {
errors = err
}
file_name = handler.Filename
defer f.Close()
io.Copy(f, file)
//here we save our file to our path
return file_name, errors
}