283 lines
11 KiB
Go
283 lines
11 KiB
Go
package router
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"path/filepath"
|
|
|
|
"github.com/debridmediamanager/zurg/internal/config"
|
|
"github.com/debridmediamanager/zurg/internal/dav"
|
|
intHttp "github.com/debridmediamanager/zurg/internal/http"
|
|
"github.com/debridmediamanager/zurg/internal/torrent"
|
|
"github.com/debridmediamanager/zurg/internal/universal"
|
|
"github.com/debridmediamanager/zurg/pkg/logutil"
|
|
"github.com/debridmediamanager/zurg/pkg/realdebrid"
|
|
"github.com/julienschmidt/httprouter"
|
|
)
|
|
|
|
type ZurgRouter struct {
|
|
getfile *universal.GetFile
|
|
torMgr *torrent.TorrentManager
|
|
cfg config.ConfigInterface
|
|
api *realdebrid.RealDebrid
|
|
log *logutil.Logger
|
|
}
|
|
|
|
func ApplyRouteTable(router *httprouter.Router, getfile *universal.GetFile, torMgr *torrent.TorrentManager, cfg config.ConfigInterface, api *realdebrid.RealDebrid, log *logutil.Logger) {
|
|
zr := &ZurgRouter{
|
|
getfile: getfile,
|
|
torMgr: torMgr,
|
|
cfg: cfg,
|
|
api: api,
|
|
log: log,
|
|
}
|
|
|
|
// file download handler
|
|
router.GET("/http/:directory/:torrent/:file", zr.universalDownloadFileHandler)
|
|
router.GET("/dav/:directory/:torrent/:file", zr.universalDownloadFileHandler)
|
|
router.GET("/infuse/:directory/:torrent/:file", zr.universalDownloadFileHandler)
|
|
// HEAD route
|
|
router.HEAD("/http/:directory/:torrent/:file", zr.httpHeadHandler)
|
|
|
|
// HTTP router
|
|
router.GET("/http/", zr.httpRootHandler)
|
|
router.GET("/http/:directory/", zr.httpTorrentsListHandler)
|
|
router.GET("/http/:directory/:torrent/", zr.httpFilesListHandler)
|
|
|
|
// INFUSE DAV routes
|
|
router.Handle("PROPFIND", "/infuse/", zr.infuseDavRootHandler)
|
|
router.Handle("PROPFIND", "/infuse/:directory/", zr.infuseDavTorrentsListHandler)
|
|
router.Handle("PROPFIND", "/infuse/:directory/:torrent/", zr.infuseDavFilesListHandler)
|
|
|
|
// WEBDAV router
|
|
router.Handle("PROPFIND", "/dav/", zr.davRootHandler)
|
|
router.Handle("PROPFIND", "/dav/:directory/", zr.davTorrentsListHandler)
|
|
router.Handle("PROPFIND", "/dav/:directory/:torrent/", zr.davFilesListHandler)
|
|
// EXTRA: for browser handling
|
|
router.GET("/dav/", zr.davRootHandler)
|
|
router.GET("/dav/:directory/", zr.davTorrentsListHandler)
|
|
router.GET("/dav/:directory/:torrent/", zr.davFilesListHandler)
|
|
// EXTRA: for browser handling of infuse
|
|
router.GET("/infuse/", zr.infuseDavRootHandler)
|
|
router.GET("/infuse/:directory/", zr.infuseDavTorrentsListHandler)
|
|
router.GET("/infuse/:directory/:torrent/", zr.infuseDavFilesListHandler)
|
|
// DELETE routes
|
|
router.DELETE("/dav/:directory/:torrent/", zr.deleteTorrentHandler)
|
|
router.DELETE("/dav/:directory/:torrent/:file", zr.deleteFileHandler)
|
|
// RENAME sequence
|
|
router.Handle("PROPFIND", "/dav/:directory/:torrent/:file", zr.davCheckSingleFileHandler)
|
|
router.Handle("MKCOL", "/dav/:directory/:torrent/", zr.mkcolTorrentHandler)
|
|
router.Handle("MOVE", "/dav/:directory/:torrent/:file", zr.moveFileHandler)
|
|
router.Handle("MOVE", "/dav/:directory/:torrent/", zr.moveTorrentHandler)
|
|
|
|
// Global OPTIONS route
|
|
router.GlobalOPTIONS = http.HandlerFunc(zr.globalOptionsHandler)
|
|
|
|
// root route
|
|
router.GET("/", zr.rootHandler)
|
|
|
|
// logs route
|
|
router.GET("/logs", zr.logsHandler)
|
|
router.GET("/logs/", zr.logsHandler)
|
|
|
|
router.MethodNotAllowed = http.HandlerFunc(func(resp http.ResponseWriter, req *http.Request) {
|
|
zr.log.Debugf("Method not allowed: %s %s %v", req.Method, req.URL, req.Header)
|
|
http.Error(resp, "Method not allowed", http.StatusMethodNotAllowed)
|
|
})
|
|
}
|
|
|
|
func (zr *ZurgRouter) handleRootRequest(resp http.ResponseWriter, req *http.Request, params httprouter.Params, handleFunc func(*torrent.TorrentManager) ([]byte, error), contentType string) {
|
|
out, err := handleFunc(zr.torMgr)
|
|
if err != nil {
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
resp.Header().Set("Content-Type", contentType)
|
|
resp.WriteHeader(http.StatusOK)
|
|
resp.Write(out)
|
|
}
|
|
|
|
func (zr *ZurgRouter) httpRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
zr.handleRootRequest(resp, req, params, intHttp.ServeRootDirectory, "text/html; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) davRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
zr.handleRootRequest(resp, req, params, dav.ServeRootDirectory, "text/xml; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) infuseDavRootHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
zr.handleRootRequest(resp, req, params, dav.ServeRootDirectoryForInfuse, "text/xml; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) handleTorrentsListRequest(resp http.ResponseWriter, req *http.Request, params httprouter.Params, handleFunc func(string, *torrent.TorrentManager) ([]byte, error), contentType string) {
|
|
directory := params.ByName("directory")
|
|
out, err := handleFunc(directory, zr.torMgr)
|
|
if err != nil {
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
resp.Header().Set("Content-Type", contentType)
|
|
resp.WriteHeader(http.StatusOK)
|
|
resp.Write(out)
|
|
}
|
|
|
|
func (zr *ZurgRouter) httpTorrentsListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
handlerFunc := intHttp.ServeTorrentsList
|
|
if directory == config.DOWNLOADS {
|
|
handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
|
|
return intHttp.ServeDownloadsList(torMgr)
|
|
}
|
|
}
|
|
zr.handleTorrentsListRequest(resp, req, params, handlerFunc, "text/html; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) davTorrentsListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
handlerFunc := dav.ServeTorrentsList
|
|
if directory == config.DOWNLOADS {
|
|
handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
|
|
return dav.ServeDownloadsList(torMgr)
|
|
}
|
|
}
|
|
zr.handleTorrentsListRequest(resp, req, params, handlerFunc, "text/xml; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) infuseDavTorrentsListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
handlerFunc := dav.ServeTorrentsListForInfuse
|
|
if directory == config.DOWNLOADS {
|
|
handlerFunc = func(_ string, torMgr *torrent.TorrentManager) ([]byte, error) {
|
|
return dav.ServeDownloadsListForInfuse(torMgr)
|
|
}
|
|
}
|
|
zr.handleTorrentsListRequest(resp, req, params, handlerFunc, "text/xml; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) handleFilesListRequest(resp http.ResponseWriter, req *http.Request, params httprouter.Params, handleFunc func(string, string, *torrent.TorrentManager) ([]byte, error), contentType string) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
out, err := handleFunc(directory, torrentName, zr.torMgr)
|
|
if err != nil {
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
resp.Header().Set("Content-Type", contentType)
|
|
resp.WriteHeader(http.StatusOK)
|
|
resp.Write(out)
|
|
}
|
|
|
|
func (zr *ZurgRouter) httpFilesListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
zr.handleFilesListRequest(resp, req, params, intHttp.ServeFilesList, "text/html; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) davFilesListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
zr.handleFilesListRequest(resp, req, params, dav.ServeFilesList, "text/xml; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) infuseDavFilesListHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
fmt.Println(">>>>>>>>>>>>>>>>>>> infuseDavFilesListHandler", params.ByName("directory"), params.ByName("torrent"))
|
|
zr.handleFilesListRequest(resp, req, params, dav.ServeFilesListForInfuse, "text/xml; charset=\"utf-8\"")
|
|
}
|
|
|
|
func (zr *ZurgRouter) deleteFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
fileName := params.ByName("file")
|
|
if dav.HandleDeleteFile(directory, torrentName, fileName, zr.torMgr) != nil {
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
resp.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (zr *ZurgRouter) deleteTorrentHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
if dav.HandleDeleteTorrent(directory, torrentName, zr.torMgr) != nil {
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
resp.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (zr *ZurgRouter) davCheckSingleFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
fileName := params.ByName("file")
|
|
out, err := dav.HandleSingleFile(directory, torrentName, fileName, zr.torMgr)
|
|
if err != nil {
|
|
fmt.Println(">>>>>>>>>>>>>>>>>>>. not found", err)
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
fmt.Println(">>>>>>>>>>>>>>>>>>>. found yey")
|
|
resp.Header().Set("Content-Type", "text/xml; charset=\"utf-8\"")
|
|
resp.WriteHeader(http.StatusOK)
|
|
resp.Write(out)
|
|
}
|
|
|
|
func (zr *ZurgRouter) mkcolTorrentHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
fmt.Println(">>>>>>>>>>>>>>>>>>> mkcolTorrentHandler")
|
|
resp.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (zr *ZurgRouter) moveFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
fileName := params.ByName("file")
|
|
newName := req.Header.Get("Destination")
|
|
newName = filepath.Base(newName)
|
|
fmt.Println(">>>>>>>>>>>>>>>>>>> moveFileHandler", fileName, ">>>>>>>>", newName)
|
|
if dav.HandleRenameFile(directory, torrentName, fileName, newName, zr.torMgr) != nil {
|
|
fmt.Println(">>>>>>>>>>>>>>>>>>> moveFileHandler not found")
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
fmt.Println(">>>>>>>>>>>>>>>>>>> moveFileHandler yay")
|
|
resp.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (zr *ZurgRouter) moveTorrentHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
newName := req.Header.Get("Destination")
|
|
newName = filepath.Base(newName)
|
|
if dav.HandleRenameTorrent(directory, torrentName, newName, zr.torMgr) != nil {
|
|
http.Error(resp, "Not Found", http.StatusNotFound)
|
|
return
|
|
}
|
|
resp.WriteHeader(http.StatusNoContent)
|
|
}
|
|
|
|
func (zr *ZurgRouter) globalOptionsHandler(resp http.ResponseWriter, req *http.Request) {
|
|
resp.WriteHeader(http.StatusOK)
|
|
}
|
|
|
|
func (zr *ZurgRouter) universalDownloadFileHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
fileName := params.ByName("file")
|
|
zr.getfile.ServeFile(directory, torrentName, fileName, resp, req, zr.torMgr, zr.cfg, zr.log)
|
|
}
|
|
|
|
func (zr *ZurgRouter) httpHeadHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
directory := params.ByName("directory")
|
|
torrentName := params.ByName("torrent")
|
|
fileName := params.ByName("file")
|
|
universal.HandleHeadRequest(directory, torrentName, fileName, resp, req, zr.torMgr, zr.log)
|
|
}
|
|
|
|
func (zr *ZurgRouter) logsHandler(resp http.ResponseWriter, req *http.Request, params httprouter.Params) {
|
|
logs, err := zr.log.GetLogsFromFile()
|
|
if err != nil {
|
|
http.Error(resp, err.Error(), http.StatusInternalServerError)
|
|
return
|
|
}
|
|
fmt.Fprint(resp, logs)
|
|
}
|
|
|
|
func bToMb(b uint64) uint64 {
|
|
return b / 1024 / 1024
|
|
}
|