协议里写了，四、因使用本网站静态资源导致的任何损失，本网站概不负责。
那只能自认倒霉，毕竟默认你同意了他的协议。

简单，你用 aws s3 sdk ，然后配置里配置打印请求的信息，然后他会把 url 和 headers ，body 这些都打印出来，你直接照抄就行。

@bv https://github.com/open-telemetry/opentelemetry-go-contrib/issues/5946 提了之后发现已经是个历史遗留 bug 了，根本没人管。

@bv 因为 go 是通过 context 来带上下文，opentelemetry 也是通过这个 context 把链路跟踪信息注入进去的，但是又没有办法把改后的 ctx 传给原来的 Request ，所以只能通过 Request.WithContext(ctx)去新建个 Request ，保证自己注入的 context 能被后续调用访问到。之后例如数据库操作就可以通过 context 把链路链起来了

@eudore 稳定可以复现的
```golang
package main

import (
"context"
"net/http"

"github.com/gin-gonic/gin"
)

func main() {
router := gin.Default()
router.Use(func(c *gin.Context) {
ctx := c.Request.Context()
ctx = context.WithValue(ctx, "something", 1)
c.Request = c.Request.WithContext(ctx)
c.Next()
})
router.POST("/upload", func(c *gin.Context) {
file, err := c.FormFile("file")
if err != nil {
c.JSON( http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
c.SaveUploadedFile(file, "test.txt")
c.JSON( http.StatusOK, gin.H{"message": "File uploaded successfully"})
})
router.Run()
}
```
然后上传一个大于 32mb 的文件，你就能看到上传一次/tmp 下多一个文件 multipart-xxxxxxxx

@guanzhangzhang 前端的环境很多时候是访问不了 oss 的。尤其我们经常在不同云厂商迁移...

好像也不太对，因为只要 override 了 c.Request,那么再在 handler 里去解析 multipartForm ，net/server 持有的 request 还是以前的没有 multipartForm 的，所以最终还是应该要我自己去 RemoveAll

@bv 确实，我仔细看了，可能我要做的是把 c.Request = c.Request.WithContext(ctx)改成 c.Request = c.Request.Clone(ctx),这样应该就没问题了

@FrankAdler 再加一个 middleware 去最后调用 RemoveAll 好像也不是太稳妥，因为可能最后拿到的 Request 不是持有 MultipartForm 的 Request ，可能还是原地改 Request 的去调用比较好？

@FrankAdler 好像还真是这个，我为了加 opentelemetry 自己替换了一个 request. 所以我还是要自己主动在替换掉的地方处理一下？

@hingle 我在 debug/pprof 里面看链接都断开了呀，而且上传请求也都是正常的返回，难道有些 middleware 会改变一些默认行为？

@hingle 好像还真是，所以归根到底问题是 gin 框架的？他自己没有调用 RemoveAll?

@wunonglin 本来就是传给 s3 的，但是 golang 的 multipart-form 在文件大于一个值时默认行为就是往/tmp 目录下写文件。如果没主动去调用 RemeveAll 他居然就留着/tmp 下文件不管了...

买一个电蚊拍，然后每天回家拍蚊子，超级超级解压。

找一份相关的工作，为了赚钱学啥都快

我有点好奇你这种需求，老板舍得买 aws 的各种服务么，是不是去了数据库、redis 啥的都要自建呀。毕竟随便跑个 k8s,买个 mysql 高可用数据库一个月就得几万了。

@zihuyishi 额，不好意思说错了，是广搜，纯暴力跑。

我写了一个深搜，算的 13 步能跑完，不知道对不对
```golang
package main

import "fmt"

const N = 5

type Status [N][N]bool

func (s Status) Click(x, y int) Status {
s[x][y] = !s[x][y]
if x > 0 {
s[x-1][y] = !s[x-1][y]
}
if x < N-1 {
s[x+1][y] = !s[x+1][y]
}
if y > 0 {
s[x][y-1] = !s[x][y-1]
}
if y < N-1 {
s[x][y+1] = !s[x][y+1]
}
return s
}

func (s Status) IsAllOn() bool {
for i := 0; i < N; i++ {
for j := 0; j < N; j++ {
if !s[i][j] {
return false
}
}
}
return true
}

func (s Status) Hash() int64 {
h := int64(0)
for i := 0; i < N; i++ {
for j := 0; j < N; j++ {
h = h * 2
if s[i][j] {
h += 1
}
}
}
return h
}

type Node struct {
Status Status
Step int
}

func search(s Status) (int, bool) {
searched := make(map[int64]bool)
queue := make([]Node, 0)
queue = append(queue, Node{Status: s, Step: 0})
searched[s.Hash()] = true
for len(queue) > 0 {
cur := queue[0]
queue = queue[1:]
if cur.Status.IsAllOn() {
return cur.Step, true
}
for i := 0; i < N; i++ {
for j := 0; j < N; j++ {
next := cur.Status.Click(i, j)
if next.IsAllOn() {
return cur.Step + 1, true
}
if !searched[next.Hash()] {
queue = append(queue, Node{Status: next, Step: cur.Step + 1})
searched[next.Hash()] = true
}
}
}
}
return 0, false
}

func main() {
s := Status{
{false, true, false, false, false},
{true, true, true, false, false},
{false, true, false, true, false},
{false, false, true, true, true},
{false, false, false, true, false},
}
step, ok := search(s)
fmt.Println(step, ok)
}
```