forked from GoAdminGroup/go-admin
-
Notifications
You must be signed in to change notification settings - Fork 0
/
file.go
139 lines (114 loc) · 2.93 KB
/
file.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
// Copyright 2019 GoAdmin Core Team. All rights reserved.
// Use of this source code is governed by a Apache-2.0 style
// license that can be found in the LICENSE file.
package file
import (
"io"
"mime/multipart"
"os"
"path"
"sync"
"github.com/marerm27/go-admin/plugins/admin/modules"
)
// Uploader is a file uploader which contains the method Upload.
type Uploader interface {
Upload(*multipart.Form) error
}
// UploaderGenerator is a function return an Uploader.
type UploaderGenerator func() Uploader
var uploaderList = map[string]UploaderGenerator{
"local": GetLocalFileUploader,
}
var upMu sync.Mutex
// AddUploader makes a uploader generator available by the provided theme name.
// If Add is called twice with the same name or if uploader is nil,
// it panics.
func AddUploader(name string, up UploaderGenerator) {
upMu.Lock()
defer upMu.Unlock()
if up == nil {
panic("uploader generator is nil")
}
if _, dup := uploaderList[name]; dup {
panic("add uploader generator twice " + name)
}
uploaderList[name] = up
}
// GetFileEngine return the Uploader of given name.
func GetFileEngine(name string) Uploader {
if up, ok := uploaderList[name]; ok {
return up()
}
panic("wrong uploader name")
}
// UploadFun is a function to process the uploading logic.
type UploadFun func(*multipart.FileHeader, string) (string, error)
// Upload receive the return value of given UploadFun and put them into the form.
func Upload(c UploadFun, form *multipart.Form) error {
var (
suffix string
filename string
)
for k := range form.File {
for _, fileObj := range form.File[k] {
suffix = path.Ext(fileObj.Filename)
filename = modules.Uuid() + suffix
pathStr, err := c(fileObj, filename)
if err != nil {
return err
}
form.Value[k] = append(form.Value[k], pathStr)
}
}
return nil
}
// SaveMultipartFile used in a local Uploader which help to save file in the local path.
func SaveMultipartFile(fh *multipart.FileHeader, path string) error {
f, err := fh.Open()
if err != nil {
return err
}
if ff, ok := f.(*os.File); ok {
// Windows can't rename files that are opened.
if err := f.Close(); err != nil {
return err
}
// If renaming fails we try the normal copying method.
// Renaming could fail if the files are on different devices.
if os.Rename(ff.Name(), path) == nil {
return nil
}
// Reopen f for the code below.
f, err = fh.Open()
if err != nil {
return err
}
}
defer func() {
if err2 := f.Close(); err2 != nil {
err = err2
}
}()
ff, err := os.Create(path)
if err != nil {
return err
}
defer func() {
if err2 := ff.Close(); err2 != nil {
err = err2
}
}()
_, err = copyZeroAlloc(ff, f)
return err
}
func copyZeroAlloc(w io.Writer, r io.Reader) (int64, error) {
buf := copyBufPool.Get().([]byte)
n, err := io.CopyBuffer(w, r, buf)
copyBufPool.Put(buf)
return n, err
}
var copyBufPool = sync.Pool{
New: func() interface{} {
return make([]byte, 4096)
},
}