extern/rclone
1
0
Fork 0
mirror of https://github.com/rclone/rclone.git synced 2024-11-26 18:34:41 +01:00
Code Issues Packages Projects Releases Wiki Activity
be54fd8f70
rclone/cmd/serve/http/http.go

260 lines
6.3 KiB
Go
Raw Normal View History

serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
package http
import (
"fmt"
"html/template"
"net/http"
vfs: make specialized file Open functions private
2017-12-06 17:38:19 +01:00
"os"
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
"path"
"strconv"
"strings"
"github.com/ncw/rclone/cmd"
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
"github.com/ncw/rclone/cmd/serve/httplib"
serve http/webdav: support SSL/TLS
2018-02-15 16:01:19 +01:00
"github.com/ncw/rclone/cmd/serve/httplib/httpflags"
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
"github.com/ncw/rclone/fs"
Break the fs package up into smaller parts. The purpose of this is to make it easier to maintain and eventually to allow the rclone backends to be re-used in other projects without having to use the rclone configuration system. The new code layout is documented in CONTRIBUTING.
2018-01-12 17:30:54 +01:00
"github.com/ncw/rclone/fs/accounting"
Move dircache, oauthutil, rest and pacer modules into lib
2018-01-11 17:29:20 +01:00
"github.com/ncw/rclone/lib/rest"
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
"github.com/ncw/rclone/vfs"
"github.com/ncw/rclone/vfs/vfsflags"
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
"github.com/spf13/cobra"
)
func init() {
serve http/webdav: support SSL/TLS
2018-02-15 16:01:19 +01:00
httpflags.AddFlags(Command.Flags())
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
vfsflags.AddFlags(Command.Flags())
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
}
// Command definition for cobra
var Command = &cobra.Command{
Use: "http remote:path",
Short: `Serve the remote over HTTP.`,
Long: `rclone serve http implements a basic web server to serve the remote
over HTTP. This can be viewed in a web browser or you can make a
remote of type http read from it.
You can use the filter flags (eg --include, --exclude) to control what
is served.
The server will log errors. Use -v to see access logs.
--bwlimit will be respected for file transfers. Use --stats to
control the stats printing.
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
` + httplib.Help + vfs.Help,
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
Run: func(command *cobra.Command, args []string) {
cmd.CheckArgs(1, 1, command, args)
f := cmd.NewFsSrc(args)
cmd.Run(false, true, command, func() error {
serve http/webdav: support SSL/TLS
2018-02-15 16:01:19 +01:00
s := newServer(f, &httpflags.Opt)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
s.serve()
return nil
})
},
}
// server contains everything to run the server
type server struct {
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
f fs.Fs
vfs *vfs.VFS
srv *httplib.Server
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
}
serve http/webdav: support SSL/TLS
2018-02-15 16:01:19 +01:00
func newServer(f fs.Fs, opt *httplib.Options) *server {
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
mux := http.NewServeMux()
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
s := &server{
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
f: f,
vfs: vfs.New(f, &vfsflags.Opt),
serve http/webdav: support SSL/TLS
2018-02-15 16:01:19 +01:00
srv: httplib.NewServer(mux, opt),
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
}
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
mux.HandleFunc("/", s.handler)
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
return s
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
}
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
// serve runs the http server - doesn't return
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
func (s *server) serve() {
serve restic: Print actual listener address
2018-04-04 15:56:26 +02:00
err := s.srv.Serve()
if err != nil {
fs.Errorf(s.f, "Opening listener: %v", err)
}
serve http/webdav: factor common http server creation to httplib
2018-02-14 21:39:11 +01:00
fs.Logf(s.f, "Serving on %s", s.srv.URL())
serve restic: Print actual listener address
2018-04-04 15:56:26 +02:00
s.srv.Wait()
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
}
// handler reads incoming requests and dispatches them
func (s *server) handler(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" && r.Method != "HEAD" {
http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
return
}
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
w.Header().Set("Accept-Ranges", "bytes")
serve http: error if Range supplied (not supported yet) Also add Server header
2017-10-25 00:17:04 +02:00
w.Header().Set("Server", "rclone/"+fs.Version)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
urlPath := r.URL.Path
isDir := strings.HasSuffix(urlPath, "/")
remote := strings.Trim(urlPath, "/")
if isDir {
s.serveDir(w, r, remote)
} else {
s.serveFile(w, r, remote)
}
}
// entry is a directory entry
type entry struct {
remote string
URL string
Leaf string
}
// entries represents a directory
type entries []entry
serve/http: fix serving files with : in - fixes #1939
2018-01-05 17:47:00 +01:00
// addEntry adds an entry to that directory
func (es *entries) addEntry(node interface {
Path() string
Name() string
IsDir() bool
}) {
remote := node.Path()
leaf := node.Name()
urlRemote := leaf
if node.IsDir() {
leaf += "/"
urlRemote += "/"
}
*es = append(*es, entry{remote: remote, URL: rest.URLPathEscape(urlRemote), Leaf: leaf})
}
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
// indexPage is a directory listing template
var indexPage = `<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>{{ .Title }}</title>
</head>
<body>
<h1>{{ .Title }}</h1>
{{ range $i := .Entries }}<a href="{{ $i.URL }}">{{ $i.Leaf }}</a><br />
{{ end }}</body>
</html>
`
// indexTemplate is the instantiated indexPage
var indexTemplate = template.Must(template.New("index").Parse(indexPage))
// indexData is used to fill in the indexTemplate
type indexData struct {
Title string
Entries entries
}
// error returns an http.StatusInternalServerError and logs the error
func internalError(what interface{}, w http.ResponseWriter, text string, err error) {
Break the fs package up into smaller parts. The purpose of this is to make it easier to maintain and eventually to allow the rclone backends to be re-used in other projects without having to use the rclone configuration system. The new code layout is documented in CONTRIBUTING.
2018-01-12 17:30:54 +01:00
fs.CountError(err)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
fs.Errorf(what, "%s: %v", text, err)
http.Error(w, text+".", http.StatusInternalServerError)
}
// serveDir serves a directory index at dirRemote
func (s *server) serveDir(w http.ResponseWriter, r *http.Request, dirRemote string) {
// List the directory
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
node, err := s.vfs.Stat(dirRemote)
if err == vfs.ENOENT {
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
http.Error(w, "Directory not found", http.StatusNotFound)
return
} else if err != nil {
internalError(dirRemote, w, "Failed to list directory", err)
return
}
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
if !node.IsDir() {
http.Error(w, "Not a directory", http.StatusNotFound)
return
}
dir := node.(*vfs.Dir)
dirEntries, err := dir.ReadDirAll()
if err != nil {
internalError(dirRemote, w, "Failed to list directory", err)
return
}
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
var out entries
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
for _, node := range dirEntries {
serve/http: fix serving files with : in - fixes #1939
2018-01-05 17:47:00 +01:00
out.addEntry(node)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
}
// Account the transfer
Break the fs package up into smaller parts. The purpose of this is to make it easier to maintain and eventually to allow the rclone backends to be re-used in other projects without having to use the rclone configuration system. The new code layout is documented in CONTRIBUTING.
2018-01-12 17:30:54 +01:00
accounting.Stats.Transferring(dirRemote)
defer accounting.Stats.DoneTransferring(dirRemote, true)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
fs.Infof(dirRemote, "%s: Serving directory", r.RemoteAddr)
err = indexTemplate.Execute(w, indexData{
Entries: out,
Title: fmt.Sprintf("Directory listing of /%s", dirRemote),
})
if err != nil {
internalError(dirRemote, w, "Failed to render template", err)
return
}
}
// serveFile serves a file object at remote
func (s *server) serveFile(w http.ResponseWriter, r *http.Request, remote string) {
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
node, err := s.vfs.Stat(remote)
if err == vfs.ENOENT {
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
fs.Infof(remote, "%s: File not found", r.RemoteAddr)
http.Error(w, "File not found", http.StatusNotFound)
return
} else if err != nil {
internalError(remote, w, "Failed to find file", err)
return
}
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
if !node.IsFile() {
http.Error(w, "Not a file", http.StatusNotFound)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
return
}
vfs: add Path method to Node and use it to stop reading nil DirEntry All DirEntry calls now have been checked for nil or converted to use Path.
2017-11-18 12:47:21 +01:00
entry := node.DirEntry()
if entry == nil {
http.Error(w, "Can't open file being written", http.StatusNotFound)
return
}
obj := entry.(fs.Object)
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
file := node.(*vfs.File)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
// Set content length since we know how long the object is
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
w.Header().Set("Content-Length", strconv.FormatInt(node.Size(), 10))
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
// Set content type
mimeType := fs.MimeType(obj)
if mimeType == "application/octet-stream" && path.Ext(remote) == "" {
// Leave header blank so http server guesses
} else {
w.Header().Set("Content-Type", mimeType)
}
// If HEAD no need to read the object since we have set the headers
if r.Method == "HEAD" {
return
}
// open the object
vfs: make specialized file Open functions private
2017-12-06 17:38:19 +01:00
in, err := file.Open(os.O_RDONLY)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
if err != nil {
internalError(remote, w, "Failed to open file", err)
return
}
defer func() {
err := in.Close()
if err != nil {
fs.Errorf(remote, "Failed to close file: %v", err)
}
}()
// Account the transfer
Break the fs package up into smaller parts. The purpose of this is to make it easier to maintain and eventually to allow the rclone backends to be re-used in other projects without having to use the rclone configuration system. The new code layout is documented in CONTRIBUTING.
2018-01-12 17:30:54 +01:00
accounting.Stats.Transferring(remote)
defer accounting.Stats.DoneTransferring(remote, true)
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
// FIXME in = fs.NewAccount(in, obj).WithBuffer() // account the transfer
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
serve http: use vfs to cache the directories and support Range header
2017-10-27 21:56:31 +02:00
// Serve the file
http.ServeContent(w, r, remote, node.ModTime(), in)
serve http command to serve a remote over HTTP This implements a basic webserver to serve an rclone remote over HTTP. It also sets up the framework for adding more types of server later.
2016-12-06 19:00:24 +01:00
}
Reference in New Issue Copy Permalink