golang文件上传服务器

最新推荐文章于 2024-03-12 17:22:56 发布
最新推荐文章于 2024-03-12 17:22:56 发布
阅读量956 收藏 4
点赞数
分类专栏： 运维人生 编程人生
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jailman/article/details/108466781
版权

适合在工作中临时需要对外传输文件却被防火墙限制的情况

单文件，直接build

package main

import (
	"encoding/json"
	"flag"
	"net/http"
	"os"
	"crypto/rand"
	"github.com/sirupsen/logrus"
	"crypto/sha1"
	"errors"
	"fmt"
	"io"
	"io/ioutil"
	"path"
	"regexp"
	"strings"
)

var logger *logrus.Logger

var (
	rePathUpload = regexp.MustCompile(`^/upload$`)
	rePathFiles  = regexp.MustCompile(`^/files/([^/]+)$`)

	errTokenMismatch = errors.New("token mismatched")
	errMissingToken  = errors.New("missing token")

	protectedMethods = []string{http.MethodGet, http.MethodHead, http.MethodPost, http.MethodPut}
)

type response struct {
	OK bool `json:"ok"`
}

type uploadedResponse struct {
	response
	Path string `json:"path"`
}

func newUploadedResponse(path string) uploadedResponse {
	return uploadedResponse{response: response{OK: true}, Path: path}
}

type errorResponse struct {
	response
	Message string `json:"error"`
}

func newErrorResponse(err error) errorResponse {
	return errorResponse{response: response{OK: false}, Message: err.Error()}
}

func writeError(w http.ResponseWriter, err error) (int, error) {
	body := newErrorResponse(err)
	b, e := json.Marshal(body)
	// if an error is occured on marshaling, write empty value as response.
	if e != nil {
		return w.Write([]byte{})
	}
	return w.Write(b)
}

func writeSuccess(w http.ResponseWriter, path string) (int, error) {
	body := newUploadedResponse(path)
	b, e := json.Marshal(body)
	// if an error is occured on marshaling, write empty value as response.
	if e != nil {
		return w.Write([]byte{})
	}
	return w.Write(b)
}

func getSize(content io.Seeker) (int64, error) {
	size, err := content.Seek(0, os.SEEK_END)
	if err != nil {
		return 0, err
	}
	_, err = content.Seek(0, io.SeekStart)
	if err != nil {
		return 0, err
	}
	return size, nil
}


// Server represents a simple-upload server.
type Server struct {
	DocumentRoot string
	// MaxUploadSize limits the size of the uploaded content, specified with "byte".
	MaxUploadSize int64
	SecureToken   string
	EnableCORS    bool
}

// NewServer creates a new simple-upload server.
func NewServer(documentRoot string, maxUploadSize int64, token string, enableCORS bool) Server {
	return Server{
		DocumentRoot:  documentRoot,
		MaxUploadSize: maxUploadSize,
		SecureToken:   token,
		EnableCORS:    enableCORS,
	}
}

func (s Server) handleGet(w http.ResponseWriter, r *http.Request) {
	if !rePathFiles.MatchString(r.URL.Path) {
		w.WriteHeader(http.StatusNotFound)
		writeError(w, fmt.Errorf("\"%s\" is not found", r.URL.Path))
		return
	}
	if s.EnableCORS {
		w.Header().Set("Access-Control-Allow-Origin", "*")
	}
	http.StripPrefix("/files/", http.FileServer(http.Dir(s.DocumentRoot))).ServeHTTP(w, r)
}

func (s Server) handlePost(w http.ResponseWriter, r *http.Request) {
	srcFile, info, err := r.FormFile("file")
	if err != nil {
		logger.WithError(err).Error("failed to acquire the uploaded content")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	defer srcFile.Close()
	logger.Debug(info)
	size, err := getSize(srcFile)
	if err != nil {
		logger.WithError(err).Error("failed to get the size of the uploaded content")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	if size > s.MaxUploadSize {
		logger.WithField("size", size).Info("file size exceeded")
		w.WriteHeader(http.StatusRequestEntityTooLarge)
		writeError(w, errors.New("uploaded file size exceeds the limit"))
		return
	}

	body, err := ioutil.ReadAll(srcFile)
	if err != nil {
		logger.WithError(err).Error("failed to read the uploaded content")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	filename := info.Filename
	if filename == "" {
		filename = fmt.Sprintf("%x", sha1.Sum(body))
	}

	dstPath := path.Join(s.DocumentRoot, filename)
	dstFile, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
	if err != nil {
		logger.WithError(err).WithField("path", dstPath).Error("failed to open the file")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	defer dstFile.Close()
	if written, err := dstFile.Write(body); err != nil {
		logger.WithError(err).WithField("path", dstPath).Error("failed to write the content")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	} else if int64(written) != size {
		logger.WithFields(logrus.Fields{
			"size":    size,
			"written": written,
		}).Error("uploaded file size and written size differ")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, fmt.Errorf("the size of uploaded content is %d, but %d bytes written", size, written))
	}
	uploadedURL := strings.TrimPrefix(dstPath, s.DocumentRoot)
	if !strings.HasPrefix(uploadedURL, "/") {
		uploadedURL = "/" + uploadedURL
	}
	uploadedURL = "/files" + uploadedURL
	logger.WithFields(logrus.Fields{
		"path": dstPath,
		"url":  uploadedURL,
		"size": size,
	}).Info("file uploaded by POST")
	if s.EnableCORS {
		w.Header().Set("Access-Control-Allow-Origin", "*")
	}
	w.WriteHeader(http.StatusOK)
	writeSuccess(w, uploadedURL)
}

func (s Server) handlePut(w http.ResponseWriter, r *http.Request) {
	matches := rePathFiles.FindStringSubmatch(r.URL.Path)
	if matches == nil {
		logger.WithField("path", r.URL.Path).Info("invalid path")
		w.WriteHeader(http.StatusNotFound)
		writeError(w, fmt.Errorf("\"%s\" is not found", r.URL.Path))
		return
	}
	targetPath := path.Join(s.DocumentRoot, matches[1])

	// We have to create a new temporary file in the same device to avoid "invalid cross-device link" on renaming.
	// Here is the easiest solution: create it in the same directory.
	tempFile, err := ioutil.TempFile(s.DocumentRoot, "upload_")
	if err != nil {
		logger.WithError(err).Error("failed to create a temporary file")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	defer r.Body.Close()
	srcFile, info, err := r.FormFile("file")
	if err != nil {
		logger.WithError(err).WithField("path", targetPath).Error("failed to acquire the uploaded content")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	defer srcFile.Close()
	// dump headers for the file
	logger.Debug(info.Header)

	size, err := getSize(srcFile)
	if err != nil {
		logger.WithError(err).WithField("path", targetPath).Error("failed to get the size of the uploaded content")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	if size > s.MaxUploadSize {
		logger.WithFields(logrus.Fields{
			"path": targetPath,
			"size": size,
		}).Info("file size exceeded")
		w.WriteHeader(http.StatusRequestEntityTooLarge)
		writeError(w, errors.New("uploaded file size exceeds the limit"))
		return
	}

	n, err := io.Copy(tempFile, srcFile)
	if err != nil {
		logger.WithError(err).WithField("path", tempFile.Name()).Error("failed to write body to the file")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}
	// excplicitly close file to flush, then rename from temp name to actual name in atomic file
	// operation if on linux or other unix-like OS (windows hosts should look into https://github.com/natefinch/atomic
	// package for atomic file write operations)
	tempFile.Close()
	if err := os.Rename(tempFile.Name(), targetPath); err != nil {
		os.Remove(tempFile.Name())
		logger.WithError(err).WithField("path", targetPath).Error("failed to rename temp file to final filename for upload")
		w.WriteHeader(http.StatusInternalServerError)
		writeError(w, err)
		return
	}

	logger.WithFields(logrus.Fields{
		"path": r.URL.Path,
		"size": n,
	}).Info("file uploaded by PUT")
	if s.EnableCORS {
		w.Header().Set("Access-Control-Allow-Origin", "*")
	}
	w.WriteHeader(http.StatusOK)
	writeSuccess(w, r.URL.Path)
}

func (s Server) handleOptions(w http.ResponseWriter, r *http.Request) {
	var allowedMethods []string
	if rePathFiles.MatchString(r.URL.Path) {
		allowedMethods = []string{http.MethodPut, http.MethodGet, http.MethodHead}
	} else if rePathUpload.MatchString(r.URL.Path) {
		allowedMethods = []string{http.MethodPost}
	} else {
		w.WriteHeader(http.StatusNotFound)
		writeError(w, errors.New("not found"))
		return
	}
	w.Header().Set("Access-Control-Allow-Origin", "*")
	w.Header().Set("Access-Control-Allow-Methods", strings.Join(allowedMethods, ","))
	w.WriteHeader(http.StatusNoContent)
}

func (s Server) checkToken(r *http.Request) error {
	// first, try to get the token from the query strings
	token := r.URL.Query().Get("token")
	// if token is not found, check the form parameter.
	if token == "" {
		token = r.FormValue("token")
	}
	if token == "" {
		return errMissingToken
	}
	if token != s.SecureToken {
		return errTokenMismatch
	}
	return nil
}

func isAuthenticationRequired(r *http.Request) bool {
	for _, m := range protectedMethods {
		if m == r.Method {
			return true
		}
	}
	return false
}

func (s Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	if err := s.checkToken(r); isAuthenticationRequired(r) && err != nil {
		w.WriteHeader(http.StatusUnauthorized)
		writeError(w, err)
		return
	}

	switch r.Method {
	case http.MethodGet, http.MethodHead:
		s.handleGet(w, r)
	case http.MethodPost:
		s.handlePost(w, r)
	case http.MethodPut:
		s.handlePut(w, r)
	case http.MethodOptions:
		s.handleOptions(w, r)
	default:
		w.Header().Add("Allow", "GET,HEAD,POST,PUT")
		w.WriteHeader(http.StatusMethodNotAllowed)
		writeError(w, fmt.Errorf("method \"%s\" is not allowed", r.Method))
	}
}


func run(args []string) int {
	bindAddress := flag.String("ip", "0.0.0.0", "IP address to bind")
	listenPort := flag.Int("port", 8001, "port number to listen on")
	tlsListenPort := flag.Int("tlsport", 25443, "port number to listen on with TLS")
	// 5,242,880 bytes == 5 MiB
	maxUploadSize := flag.Int64("upload_limit", 5242880, "max size of uploaded file (byte)")
	tokenFlag := flag.String("token", "", "specify the security token (it is automatically generated if empty)")
	logLevelFlag := flag.String("loglevel", "info", "logging level")
	certFile := flag.String("cert", "", "path to certificate file")
	keyFile := flag.String("key", "", "path to key file")
	corsEnabled := flag.Bool("cors", false, "if true, add ACAO header to support CORS")
	flag.Parse()
	serverRoot := flag.Arg(0)
	if len(serverRoot) == 0 {
		flag.Usage()
		return 2
	}
	if logLevel, err := logrus.ParseLevel(*logLevelFlag); err != nil {
		logrus.WithError(err).Error("failed to parse logging level, so set to default")
	} else {
		logger.Level = logLevel
	}
	token := *tokenFlag
	if token == "" {
		count := 10
		b := make([]byte, count)
		if _, err := rand.Read(b); err != nil {
			logger.WithError(err).Fatal("could not generate token")
			return 1
		}
		token = fmt.Sprintf("%x", b)
		logger.WithField("token", token).Warn("token generated")
	}
	tlsEnabled := *certFile != "" && *keyFile != ""
	server := NewServer(serverRoot, *maxUploadSize, token, *corsEnabled)
	http.Handle("/upload", server)
	http.Handle("/files/", server)

	errors := make(chan error)

	go func() {
		logger.WithFields(logrus.Fields{
			"ip":           *bindAddress,
			"port":         *listenPort,
			"token":        token,
			"upload_limit": *maxUploadSize,
			"root":         serverRoot,
			"cors":         *corsEnabled,
		}).Info("start listening")

		if err := http.ListenAndServe(fmt.Sprintf("%s:%d", *bindAddress, *listenPort), nil); err != nil {
			errors <- err
		}
	}()

	if tlsEnabled {
		go func() {
			logger.WithFields(logrus.Fields{
				"cert": *certFile,
				"key":  *keyFile,
				"port": *tlsListenPort,
			}).Info("start listening TLS")

			if err := http.ListenAndServeTLS(fmt.Sprintf("%s:%d", *bindAddress, *tlsListenPort), *certFile, *keyFile, nil); err != nil {
				errors <- err
			}
		}()
	}

	err := <-errors
	logger.WithError(err).Info("closing server")

	return 0
}

func main() {
	logger = logrus.New()
	logger.Info("starting up simple-upload-server")

	result := run(os.Args)
	os.Exit(result)
}

监听端口8001
上传方法：

./simple_upload_server -token f9403fc5f537b4ab332d /tmp
echo 'Hello, world!' > sample.txt
curl -Ffile=@sample.txt 'http://localhost:8001/upload?token=f9403fc5f537b4ab332d'
{"ok":true,"path":"/files/sample.txt"}

使用put上传

curl -X PUT -Ffile=@sample.txt "http://localhost:8001/files/another_sample.txt?token=f9403fc5f537b4ab332d"
{"ok":true,"path":"/files/another_sample.txt"}

下载

curl 'http://localhost:8001/files/sample.txt?token=f9403fc5f537b4ab332d'
hello, world!

TLS

./simple_upload_server -cert ./cert.pem -key ./key.pem root/

查看文件

$ curl -I 'http://localhost:8001/files/foobar.txt?token=f9403fc5f537b4ab332d'
HTTP/1.1 200 OK
Accept-Ranges: bytes
Content-Length: 9
Content-Type: text/plain; charset=utf-8
Last-Modified: Sun, 09 Oct 2016 14:35:39 GMT
Date: Sun, 09 Oct 2016 14:35:43 GMT

$ curl 'http://localhost:8001/files/foobar.txt?token=f9403fc5f537b4ab332d'
hello!!!

$ curl -I 'http://localhost:8001/files/unknown?token=f9403fc5f537b4ab332d'
HTTP/1.1 404 Not Found
Content-Type: text/plain; charset=utf-8
X-Content-Type-Options: nosniff
Date: Sun, 09 Oct 2016 14:37:48 GMT
Content-Length: 19

参考：
https://github.com/mayth/go-simple-upload-server

思路扩展：
使用rsync和netcat得方法也是可以的，最终目标就是在不改动软硬件防火墙的情况下将文件上传到指定服务器，方法很多，只要利用机器现有工具达成目标即可。

大囚长
关注
专栏目录
从Java到Go：使用Go语言构建文件上传和下载服务器
sybh的博客
06-07 332
在本篇博客中，我们学习了如何使用Go语言构建一个文件上传和下载服务器，并探讨了从Java到Go的过渡。我们了解了Go和Java的基本语法差异，并通过实际示例展示了如何在Go中实现HTTP服务器以及文件上传和下载功能。最后，我们讨论了如何优化和扩展该服务器以满足实际需求。希望本文能帮助你更好地理解Go语言，并为你在实际项目中应用Go提供一些启示。祝你学习Go愉快！
golang文件上传服务器,golang-文件上传
weixin_39851974的博客
08-12 1131
package handlerimport ("encoding/json""io""io/ioutil""log""net/http""os")// UploadHandler 上传接口func UploadHandler(w http.ResponseWriter, r *http.Request) {if r.Method == "GET" {// 返回上传html页面data, err :...
golang文件上传到服务器,golang文件传输服务
weixin_42523985的博客
08-05 1459
续上篇，本篇介绍一个完整的golang文件传输服务器。完整的代码可以看服务器,客户端网络使用的框架如上篇介绍，这里就不再复述.首先定义3个命令码：const (request_file= 1file_size= 2transfering= 3)request_file用于请求文件传输，附带的命令参数是文件key.file_size用于通告客户端文件的大小.transfering用于传输文件内容，附...
golang文件上传到服务器,golang做上传文件服务器文件处理问题
weixin_35934012的博客
08-05 1073
1.使用golang 做web服务器2.客户端使用http put的形式，上传文件到此web服务器3.假如上传的文件很大，服务器可否支持，比如上传到服务器100k大小后就，存一个chunk文件，然后释放那部分内存，以此类推(觉得类似于管道)4.目前我知道 http.Request.Body 可以获取上传之后的文件具体内容，并且它是一个 io.ReadCloser类型5.再问一下http.Reque...
Go 文件服务器
jeikerxiao
11-03 545
Go 文件服务器 package main import "net/http" func main() { h := http.FileServer(http.Dir(".")) http.ListenAndServe(":8001", h) } 访问地址： http://localhost:8001
vuejs学习之路 vue上传文件控件往golang服务器上传文件
01-20
在本文中，我们将探讨如何使用Vue.js前端框架与Golang后端服务器进行文件上传的实现。首先，让我们深入了解Vue.js中的文件上传组件以及Golang处理文件上传的代码。 Vue.js是一个流行的JavaScript框架，用于构建用户...
golang简单获取上传文件大小的实现代码
09-21
在Go语言（Golang）中，处理文件上传是一项常见的任务，尤其是在Web开发领域。对于开发者来说，能够轻松地获取上传文件的大小是非常重要的，这不仅有助于优化服务器资源的使用，还可以提高用户体验。本文将详细介绍...
golang大文件上传
12-20
总的来说，`golang大文件上传`涉及到使用Golang标准库处理HTTP请求，特别是`multipart/form-data`的解析，以及在服务器端高效安全地存储上传的文件。理解并实现这些知识点对于任何Golang Web开发者来说都是至关重要...
golang语言实现的文件上传与文件下载功能示例
01-20
本文实例讲述了golang实现的文件上传与文件下载功能。分享给大家供大家参考，具体如下： upload.go 复制代码 代码如下:package common import (  “io/ioutil”  “os”  “path”  “github.com/gin-gonic/gin...
文件服务器go
09-19
简单的go文件服务器，方便移动端与pc端的交互操作，便于开发等。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
Go-godfs是一个用go实现的轻量快速简单易用的分布式文件存储服务器
08-13
godfs 是一个用go实现的轻量，快速，简单易用的分布式文件存储服务器
Go-Quickshare一个小而美的文件共享服务器
08-14
特点 在浏览器中上传下载, 无需安装任何客户端 在桌面电脑和移动设备件间共享文件 绿色软件 支持添加本地文件 支持添加文件下载次数上限 支持断点续传
使用go搭建一个简单的web服务器（6）处理文件上传
09-23 226
1.前端页面 <html> <head> 上传文件 </head> <body> <form enctype="multipart/form-data" action="http://127.0.0.1:9090/upload" method="post"> <input type="file" name...
go 上传文件到服务器,用go gin server来做文件上传服务
weixin_39805087的博客
07-31 364
之前已经go get安装了gin, 现在来玩下用go gin server作图片上传服务， 代码目录如下：taoge:~/test_gin$ tree.|-- public|-- template| `-- select_file.html`-- test_gin_server.go2 directories, 2 filestaoge:~/test_gin$test_gin_server.go...
golang分布式文件服务器,分享一个用go实现的分布式文件系统：godfs
weixin_39530838的博客
08-09 870
godfsgodfs 是一个用go实现的轻量，快速，简单易用的分布式文件存储服务器。godfs 开箱即用，并对docker支持友好。特性快速, 轻量, 开箱即用, 友好的API易于扩展，运行稳定非常低的资源开销提供原生的客户端和Java客户端(还未开始)提供HTTP方式的下载和上传API清晰的日志帮助排查运行异常支持不同平台下的编译运行: Linux, Windows, Mac更好地支持docke...
go 分布式 文件服务器,一个极简的分布式文件系统-Go语言中文社区
weixin_39875503的博客
08-10 641
前言开源的分布式存储系统比较多，比较有名的有：Ceph、GlusterFS、HDFS、TFS等。这些系统都比较复杂，代码动则几十上百万行，这些系统对初学者来说门槛比较高，特别是对于从事非分布式存储行业，但又想跨行学习分布式的同学来说，往往有这想法，但是不知道怎么入手。本文介绍之前实现的一个C++极简版的分布式文件系统对于嵌入式，或者主要是从事单机开发的程序员来说，没接触分布式之前，都会感觉很神秘，...
go之搭建一个文件服务器
萧海的博客
10-02 294
【代码】go之搭建一个文件服务器。
GO语言编写简易文件服务器
Fly_鹏程万里
03-04 1465
程序源码 package main import ( "net/http" ) func main() { http.Handle("/", http.FileServer(http.Dir("."))) http.ListenAndServe(":8080", nil) } 运行测试 运行httpFileServer.go 之后在浏览器中访问即可： 这有什...
go语言tcp协议实现文件上传
最新发布
m0_37570494的博客
03-12 368
【代码】go语言tcp协议实现文件上传。
golang文件服务器
08-13
所以，如果你想实现一个golang文件服务器，你可以参考这个示例代码。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *3* [golang 文件服务器]...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值