我有一些客户端代码，基本上是试图使用HTTP PUT方法将tar.gz文件上传到服务器。但是服务器似乎不喜欢它，并且总是向我发送500错误响应。以下是代码。我不知道怎么了。
func upLoadFileToServer (uploadFileName string) {
tr := &http.Transport{
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
ExpectContinueTimeout : 30 * time.Second,
}
client := &http.Client{ Transport:tr,
Timeout: 20 * time.Second}
timeCurrent = time.Now()
fileContents, err := ioutil.ReadFile(uploadFileName)
if err != nil {
log.Println("Failed to Read the File", uploadFileName, err)
}
PutReq, _ := http.NewRequest("PUT", "https://www.example.com/upload", strings.NewReader(string(fileContents)))
PutReq.Header.Set("Content-Type", "application/zip")
PutReq.ContentLength = int64(len(string(fileContents)))
PutReq.Header.Set("Expect", "100-continue")
PutReq.Header.Set("Accept", "*/*")
PutReq.Header.Set("Date", timeCurrent.Format(time.RFC1123))
PutResp, err := client.Do(inventoryPutReq)
}
有时我会注意到PEER错误导致的“连接重置”。但大多数情况下是500。我尝试使用POSTMAN尝试完全相同的请求，并且看起来工作正常。
答案 0 :(得分：0)
这是一个可行的示例。
最有可能的原因是服务器有点简单，并且从字面上获取文件名。并且由于您没有在filepath.Base上使用uploadFileName，因此它上可能包含路径元素。只需在文件名上使用它即可进行测试。
重置可能是由于超时造成的。
package main
import (
"bytes"
"flag"
"fmt"
"io"
"log"
"mime/multipart"
"net"
"net/http"
"os"
"path/filepath"
"sync"
)
var (
targetPath string
filename string
port int
handlerLog *log.Logger
mainLog *log.Logger
)
// This is automatically called after vars have been initialized and before main
func init() {
flag.StringVar(&targetPath, "target", "./tmp", "target directory for uploads")
flag.StringVar(&filename, "file", "", "file to upload")
flag.IntVar(&port, "port", 0, "port to listen on. When 0, a random port is assigned")
handlerLog = log.New(os.Stdout, "[handler] ", log.LstdFlags)
mainLog = log.New(os.Stdout, "[main ] ", log.LstdFlags)
}
// By returning a handler, we have an elegant way of initializing path.
func uploadHandler(path string) http.Handler {
// We make sure path is an existing directory when the handler takes over
if s, err := os.Stat(path); err != nil {
if os.IsNotExist(err) {
handlerLog.Printf("Target '%s' does not exist. Creating it...", path)
if cerr := os.MkdirAll(path, 0755); cerr != nil {
handlerLog.Fatalf("Creating target: %s", err)
}
} else {
handlerLog.Fatalf("Error accessing '%s': %s", path, err)
}
} else if !s.IsDir() {
handlerLog.Fatalf("Target '%s' is not a directory", path)
}
// Do NOT use this handler in production!!!
// It is lacking all sorts of safety measures.
// However, it is enough to demonstrate.
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
handlerLog.Println("Handling file upload...")
handlerLog.Println("Parsing form...")
if err := r.ParseMultipartForm(32 << 20); err != nil {
handlerLog.Fatalf("Parsing form: %s", err)
}
f, h, err := r.FormFile("file")
if err != nil {
handlerLog.Printf("Error accessing file: %s", err)
http.Error(w, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
defer f.Close()
handlerLog.Println("Opening output file...")
t, err := os.OpenFile(filepath.Join(path, filepath.Base(h.Filename)), os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0644)
if err != nil {
handlerLog.Printf("Opening output file: %s", err)
http.Error(w, http.StatusText(http.StatusInternalServerError)+": "+err.Error(), http.StatusInternalServerError)
return
}
defer t.Close()
handlerLog.Println("Copying to output file...")
if _, err = io.Copy(t, f); err != nil {
handlerLog.Printf("Copying to output file: %s", err)
http.Error(w, http.StatusText(http.StatusInternalServerError)+": "+err.Error(), http.StatusInternalServerError)
return
}
handlerLog.Println("Finished handler!")
})
}
func main() {
flag.Parse()
// Check input
if filename == "" {
mainLog.Fatal("No filename given. Exiting...")
}
mainLog.Println("Setting up upload handler...")
http.Handle("/upload", uploadHandler(targetPath))
wg := sync.WaitGroup{}
wg.Add(1)
// We want to finish the program after upload, as we only want to demonstrate
go func() {
mainLog.Println("Setting up listener...")
listener, err := net.Listen("tcp", fmt.Sprintf("127.0.0.1:%d", port))
if err != nil {
mainLog.Fatalf("%s", err)
}
defer listener.Close()
port = listener.Addr().(*net.TCPAddr).Port
mainLog.Printf("Listening to port %d on localhost", port)
wg.Done()
http.Serve(listener, nil)
}()
buf := bytes.NewBuffer(nil)
bodyWriter := multipart.NewWriter(buf)
// We need to truncate the input filename, as the server might be stupid and take the input
// filename verbatim. Then, he will have directory parts which do not exist on the server.
fileWriter, err := bodyWriter.CreateFormFile("file", filepath.Base(filename))
if err != nil {
mainLog.Fatalf("Creating fileWriter: %s", err)
}
file, err := os.Open(filename)
if err != nil {
mainLog.Fatalf("Opening file: %s", err)
}
defer file.Close()
if _, err := io.Copy(fileWriter, file); err != nil {
mainLog.Fatalf("Buffering file: %s", err)
}
// We have all the data written to the bodyWriter.
// Now we can infer the content type
contentType := bodyWriter.FormDataContentType()
// This is mandatory as it flushes the buffer.
bodyWriter.Close()
// As we wait for the server to spin up, we need to wait here.
mainLog.Println("Waiting for the listener to be set up...")
wg.Wait()
req, err := http.NewRequest(http.MethodPut, fmt.Sprintf("http://127.0.0.1:%d/upload", port), buf)
if err != nil {
mainLog.Fatalf("Creating request: %s", err)
}
req.Header.Set("Content-Type", contentType)
client := http.Client{}
mainLog.Println("Sending file")
res, err := client.Do(req)
if err != nil {
mainLog.Fatalf("Sending file: %s", err)
}
mainLog.Printf("Received %s from server. Exiting...", res.Status)
}