TrueCloudLab/rclone
16
0
Fork 2
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions 1
rclone/cmd/serve/http/http.go

255 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 18:00:24 +00:00
package http
import (
"fmt"
"html/template"
"log"
"net/http"
"path"
"strconv"
"strings"
"github.com/ncw/rclone/cmd"
"github.com/ncw/rclone/fs"
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00: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 18:00:24 +00:00
"github.com/spf13/cobra"
)
// Globals
var (
bindAddress = "localhost:8080"
)
func init() {
Command.Flags().StringVarP(&bindAddress, "addr", "", bindAddress, "IPaddress:Port to bind server to.")
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00: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 18:00:24 +00: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.
Use --addr to specify which IP address and port the server should
listen on, eg --addr 1.2.3.4:8000 or --addr :8080 to listen to all
IPs. By default it only listens on localhost.
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.
vfs,mount,cmount,serve: Add documentation for vfs caching modes
2017-11-13 17:54:21 +00:00
` + 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 18:00:24 +00: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: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00:00
s := newServer(f, bindAddress)
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 18:00:24 +00:00
s.serve()
return nil
})
},
}
// server contains everything to run the server
type server struct {
f fs.Fs
bindAddress string
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00:00
vfs *vfs.VFS
}
func newServer(f fs.Fs, bindAddress string) *server {
s := &server{
f: f,
bindAddress: bindAddress,
vfs: vfs.New(f, &vfsflags.Opt),
}
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 18:00:24 +00:00
}
// serve creates the http server
func (s *server) serve() {
mux := http.NewServeMux()
mux.HandleFunc("/", s.handler)
// FIXME make a transport?
httpServer := &http.Server{
serve http: make it compile on go1.6 and go1.7
2017-10-26 20:52:29 +00:00
Addr: s.bindAddress,
Handler: mux,
MaxHeaderBytes: 1 << 20,
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 18:00:24 +00:00
}
serve http: make it compile on go1.6 and go1.7
2017-10-26 20:52:29 +00:00
initServer(httpServer)
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 18:00:24 +00:00
fs.Logf(s.f, "Serving on http://%s/", bindAddress)
log.Fatal(httpServer.ListenAndServe())
}
// 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 19:56:31 +00:00
w.Header().Set("Accept-Ranges", "bytes")
serve http: error if Range supplied (not supported yet) Also add Server header
2017-10-24 22:17:04 +00: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 18:00:24 +00: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
// 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) {
rclone: implement exit codes - #1136
2017-11-15 05:32:00 +00:00
fs.Stats.Error(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 18:00:24 +00: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 19:56:31 +00: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 18:00:24 +00: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 19:56:31 +00: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 18:00:24 +00:00
var out entries
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00:00
for _, node := range dirEntries {
obj := node.DirEntry()
remote := strings.Trim(obj.Remote(), "/")
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 18:00:24 +00:00
leaf := path.Base(remote)
urlRemote := leaf
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00:00
if node.IsDir() {
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 18:00:24 +00:00
leaf += "/"
urlRemote += "/"
}
out = append(out, entry{remote: remote, URL: urlRemote, Leaf: leaf})
}
// Account the transfer
fs.Stats.Transferring(dirRemote)
defer fs.Stats.DoneTransferring(dirRemote, true)
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 19:56:31 +00: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 18:00:24 +00: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 19:56:31 +00: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 18:00:24 +00:00
return
}
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00:00
obj := node.DirEntry().(fs.Object)
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 18:00:24 +00: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 19:56:31 +00: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 18:00:24 +00: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
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00:00
in, err := file.OpenRead()
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 18:00:24 +00: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
fs.Stats.Transferring(remote)
defer fs.Stats.DoneTransferring(remote, true)
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00: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 18:00:24 +00:00
serve http: use vfs to cache the directories and support Range header
2017-10-27 19:56:31 +00: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 18:00:24 +00:00
}
Reference in a new issue Copy permalink