537 lines
11 KiB
Go
537 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/h2non/filetype"
|
|
"github.com/labstack/echo/v4"
|
|
"github.com/labstack/echo/v4/middleware"
|
|
"github.com/urfave/cli/v2"
|
|
|
|
netUrl "net/url"
|
|
)
|
|
|
|
var (
|
|
Commands = []*cli.Command{}
|
|
version = "dev"
|
|
defaultListen = "127.0.0.1"
|
|
defaultPort = "4000"
|
|
defaultApiUrl = "http://127.0.0.1:4000"
|
|
defaultServerDirectory = "."
|
|
defaultDownloadDirectory = "."
|
|
defaultName = ""
|
|
defaultOrder = "date"
|
|
)
|
|
|
|
var (
|
|
flagListen = "listen"
|
|
flagPort = "port"
|
|
flagApiUrl = "api-url"
|
|
flagDirectory = "directory"
|
|
flagDebug = "debug"
|
|
flagName = "name"
|
|
flagOrder = "order"
|
|
)
|
|
|
|
func main() {
|
|
app := &cli.App{
|
|
Commands: []*cli.Command{
|
|
{
|
|
Name: "serve",
|
|
Aliases: []string{"s"},
|
|
Flags: []cli.Flag{
|
|
&cli.StringFlag{
|
|
Name: flagListen,
|
|
Aliases: []string{"l"},
|
|
Value: defaultListen,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagPort,
|
|
Aliases: []string{"p"},
|
|
Value: defaultPort,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagApiUrl,
|
|
Aliases: []string{"u"},
|
|
Value: defaultApiUrl,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagDirectory,
|
|
Aliases: []string{"d"},
|
|
Value: defaultServerDirectory,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagDebug,
|
|
},
|
|
},
|
|
Usage: "run http server to serve api and files",
|
|
Action: func(ctx *cli.Context) error {
|
|
listen := ctx.String("listen")
|
|
port := ctx.Int64("port")
|
|
directory := strings.TrimSuffix(ctx.String(flagDirectory), "/")
|
|
url := strings.TrimSuffix(ctx.String(flagApiUrl), "/")
|
|
|
|
e := echo.New()
|
|
|
|
if ctx.Bool(flagDebug) {
|
|
e.Use(middleware.Logger())
|
|
e.Use(middleware.Recover())
|
|
}
|
|
|
|
e.GET("/api/list", func(ctx echo.Context) error {
|
|
return apiList(ctx, directory, url)
|
|
})
|
|
|
|
e.GET("/api/stream", func(ctx echo.Context) error {
|
|
return apiStream(ctx, directory, url)
|
|
})
|
|
|
|
e.Logger.Fatal(e.Start(fmt.Sprintf("%s:%d", listen, port)))
|
|
|
|
return nil
|
|
},
|
|
},
|
|
{
|
|
Name: "play",
|
|
Usage: "run player",
|
|
Aliases: []string{"p"},
|
|
Flags: []cli.Flag{
|
|
&cli.StringFlag{
|
|
Name: flagApiUrl,
|
|
Aliases: []string{"u"},
|
|
Value: defaultApiUrl,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagName,
|
|
Aliases: []string{"n"},
|
|
Value: defaultName,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagOrder,
|
|
Aliases: []string{"o"},
|
|
Value: defaultOrder,
|
|
},
|
|
},
|
|
Action: func(ctx *cli.Context) error {
|
|
return runShell(ctx, "play")
|
|
},
|
|
},
|
|
{
|
|
Name: "download",
|
|
Usage: "run downloder",
|
|
Aliases: []string{"d"},
|
|
Flags: []cli.Flag{
|
|
&cli.StringFlag{
|
|
Name: flagApiUrl,
|
|
Aliases: []string{"u"},
|
|
Value: defaultApiUrl,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagDirectory,
|
|
Aliases: []string{"d"},
|
|
Value: defaultDownloadDirectory,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagName,
|
|
Aliases: []string{"n"},
|
|
Value: defaultName,
|
|
},
|
|
&cli.StringFlag{
|
|
Name: flagOrder,
|
|
Aliases: []string{"o"},
|
|
Value: defaultOrder,
|
|
},
|
|
},
|
|
Action: func(ctx *cli.Context) error {
|
|
return runShell(ctx, "download")
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
if err := app.Run(os.Args); err != nil {
|
|
fmt.Println(err)
|
|
}
|
|
}
|
|
|
|
type File struct {
|
|
Name string `json:"name"`
|
|
Url string `json:"url"`
|
|
Path string `json:"-"`
|
|
RelativePath string `json:"-"`
|
|
Head []byte `json:"-"`
|
|
ContentType string `json:"-"`
|
|
Date int64 `json:"-"`
|
|
}
|
|
|
|
func (f *File) GenerateHeadAndContentType() {
|
|
fo, _ := os.Open(f.Path)
|
|
head := make([]byte, 261)
|
|
fo.Read(head)
|
|
|
|
f.Head = head
|
|
f.ContentType = http.DetectContentType(head)
|
|
|
|
fo.Close()
|
|
}
|
|
|
|
func (f File) IsSupported() bool {
|
|
return filetype.IsVideo(f.Head)
|
|
}
|
|
|
|
type ApiError struct {
|
|
Error string `json:"error"`
|
|
}
|
|
|
|
func getFiles(directory, url string) ([]File, error) {
|
|
files := []File{}
|
|
absoluteRootPath, err := filepath.Abs(directory)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = filepath.Walk(directory, func(path string, info os.FileInfo, err error) error {
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if info.IsDir() {
|
|
return nil
|
|
}
|
|
|
|
basename := string(info.Name())
|
|
relativePath := strings.Replace(path, absoluteRootPath, "", 1)
|
|
|
|
file := File{
|
|
Name: basename,
|
|
Path: path,
|
|
RelativePath: relativePath,
|
|
Date: info.ModTime().Unix(),
|
|
Url: fmt.Sprintf("%s/api/stream?path=%s", url, netUrl.QueryEscape(relativePath)),
|
|
}
|
|
|
|
file.GenerateHeadAndContentType()
|
|
|
|
if file.IsSupported() {
|
|
files = append(files, file)
|
|
}
|
|
|
|
return nil
|
|
})
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return files, nil
|
|
}
|
|
|
|
func apiStream(e echo.Context, directory, url string) error {
|
|
files, err := getFiles(directory, url)
|
|
path := e.QueryParam("path")
|
|
|
|
if err != nil {
|
|
return e.JSON(http.StatusInternalServerError, ApiError{Error: fmt.Sprintf("%s", err)})
|
|
}
|
|
|
|
if path == "" {
|
|
return e.JSON(http.StatusBadRequest, ApiError{Error: "\"path\" query param is missing"})
|
|
}
|
|
|
|
for _, file := range files {
|
|
if file.RelativePath == path {
|
|
e.Response().Header().Del("Content-Length")
|
|
http.ServeFile(e.Response(), e.Request(), file.Path)
|
|
}
|
|
}
|
|
|
|
return e.JSON(http.StatusNotFound, ApiError{Error: "file not found"})
|
|
}
|
|
|
|
func apiList(e echo.Context, directory, url string) error {
|
|
files, err := getFiles(directory, url)
|
|
if err != nil {
|
|
return e.JSON(http.StatusInternalServerError, ApiError{Error: fmt.Sprintf("%s", err)})
|
|
}
|
|
|
|
name := e.QueryParam("name")
|
|
order := e.QueryParam("order")
|
|
|
|
if name != "" {
|
|
name = strings.ToLower(name)
|
|
var newFiles []File
|
|
|
|
for _, file := range files {
|
|
isMatchingName, _ := regexp.MatchString(name, strings.ToLower(file.Name))
|
|
|
|
if isMatchingName {
|
|
newFiles = append(newFiles, file)
|
|
}
|
|
}
|
|
|
|
files = newFiles
|
|
}
|
|
|
|
sort.SliceStable(files, func(i, j int) bool {
|
|
if order == "date" {
|
|
return files[i].Date < files[j].Date
|
|
} else if order == "name" {
|
|
return files[i].Name < files[j].Name
|
|
}
|
|
|
|
return false
|
|
})
|
|
|
|
return e.JSONPretty(http.StatusOK, files, " ")
|
|
}
|
|
|
|
func showFiles(files []File) {
|
|
size := len(files)
|
|
|
|
for key, file := range files {
|
|
fmt.Printf("[%3d] %s\n", size-key, file.Name)
|
|
}
|
|
}
|
|
|
|
func promptInput(defaultValue string) string {
|
|
reader := bufio.NewReader(os.Stdin)
|
|
|
|
fmt.Printf("> [%s] ", defaultValue)
|
|
input, _ := reader.ReadString('\n')
|
|
input = strings.Replace(input, "\n", "", -1)
|
|
|
|
if input == "" {
|
|
input = defaultValue
|
|
}
|
|
|
|
return input
|
|
}
|
|
|
|
func getFilesByWildcard(files, result []File) []File {
|
|
for i := len(files) - 1; i >= 0; i-- {
|
|
result = append(result, files[i])
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func getFilesByRange1(files, result []File, a, b int) []File {
|
|
size := len(files)
|
|
|
|
if a > b {
|
|
fmt.Printf("%+v\n", a)
|
|
fmt.Printf("%+v\n", b)
|
|
for i := a; i >= b; i-- {
|
|
result = append(result, files[size-i])
|
|
}
|
|
|
|
fmt.Printf("%+v\n", result)
|
|
} else {
|
|
for i := a; i <= b; i++ {
|
|
result = append(result, files[size-i])
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func getFilesByRange2(files, result []File, a int) []File {
|
|
size := len(files)
|
|
|
|
for i := a; i >= 1; i-- {
|
|
result = append(result, files[size-i])
|
|
fmt.Println(i)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func getFilesByRange3(files, result []File, a int) []File {
|
|
size := len(files)
|
|
|
|
for i := a; i <= size; i++ {
|
|
result = append(result, files[size-i])
|
|
fmt.Println(i)
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func getFilesByWordSplit(files, result []File, words []string) []File {
|
|
size := len(files)
|
|
|
|
for _, word := range words {
|
|
isInt, _ := regexp.MatchString("^[0-9]+$", word)
|
|
|
|
if isInt {
|
|
value, _ := strconv.Atoi(word)
|
|
result = append(result, files[size-value])
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func requestFileList(url, name, order string) []File {
|
|
response, err := http.Get(fmt.Sprintf("%s/api/list?name=%s&order=%s", url, name, order))
|
|
if err != nil {
|
|
fmt.Println(err)
|
|
|
|
return nil
|
|
}
|
|
|
|
body, err := ioutil.ReadAll(response.Body)
|
|
|
|
var files []File
|
|
|
|
json.Unmarshal([]byte(body), &files)
|
|
|
|
return files
|
|
}
|
|
|
|
func generatePlayerCmd(files []File) *exec.Cmd {
|
|
cmd := exec.Command("mpv", "-fs")
|
|
|
|
for _, f := range files {
|
|
cmd.Args = append(cmd.Args, f.Url)
|
|
}
|
|
|
|
return cmd
|
|
}
|
|
|
|
func generateDownloadCmds(files []File, directory string) []*exec.Cmd {
|
|
var cmds []*exec.Cmd
|
|
|
|
for _, f := range files {
|
|
output := fmt.Sprintf("%s/%s", directory, f.Name)
|
|
cmd := exec.Command("wget", "-o", "/dev/stdout", "-c", "--show-progress", "-O", output, f.Url)
|
|
cmds = append(cmds, cmd)
|
|
}
|
|
|
|
return cmds
|
|
}
|
|
|
|
func selectFiles(files []File, input string) []File {
|
|
var result []File
|
|
|
|
range1Regex := "^([0-9]+)-([0-9]+)$"
|
|
range2Regex := "^([0-9]+)-$"
|
|
range3Regex := "^([0-9]+)\\+$"
|
|
|
|
isRange1, _ := regexp.MatchString(range1Regex, input)
|
|
isRange2, _ := regexp.MatchString(range2Regex, input)
|
|
isRange3, _ := regexp.MatchString(range3Regex, input)
|
|
|
|
if input == "*" || input == "*+" {
|
|
result = getFilesByWildcard(files, result)
|
|
} else if input == "*-" {
|
|
result = files
|
|
} else if isRange1 { // a-b
|
|
regex, _ := regexp.Compile(range1Regex)
|
|
data := regex.FindStringSubmatch(input)
|
|
|
|
a, _ := strconv.Atoi(data[1])
|
|
b, _ := strconv.Atoi(data[2])
|
|
|
|
result = getFilesByRange1(files, result, a, b)
|
|
} else if isRange2 { // a-
|
|
regex, _ := regexp.Compile(range2Regex)
|
|
data := regex.FindStringSubmatch(input)
|
|
|
|
a, _ := strconv.Atoi(data[1])
|
|
|
|
result = getFilesByRange2(files, result, a)
|
|
} else if isRange3 { // a+
|
|
regex, _ := regexp.Compile(range3Regex)
|
|
data := regex.FindStringSubmatch(input)
|
|
|
|
a, _ := strconv.Atoi(data[1])
|
|
|
|
result = getFilesByRange3(files, result, a)
|
|
} else {
|
|
result = getFilesByWordSplit(files, result, strings.Fields(input))
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
func runCmds(cmds []*exec.Cmd) {
|
|
for _, cmd := range cmds {
|
|
fmt.Printf("<----->\nCommand: %s\n<----->\n", cmd)
|
|
|
|
stdout, _ := cmd.StdoutPipe()
|
|
scanner := bufio.NewScanner(stdout)
|
|
|
|
err := cmd.Start()
|
|
if err != nil {
|
|
fmt.Printf("%+v\n", err)
|
|
}
|
|
|
|
for scanner.Scan() {
|
|
out := fmt.Sprintf("%q", scanner.Text())
|
|
out = strings.Trim(out, "\"")
|
|
out = strings.ReplaceAll(out, `\u00a0`, " ")
|
|
|
|
if out != "" {
|
|
fmt.Print("\r")
|
|
fmt.Print(out)
|
|
} else {
|
|
fmt.Print("\n")
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, cmd := range cmds {
|
|
cmd.Wait()
|
|
}
|
|
}
|
|
|
|
func runShell(ctx *cli.Context, action string) error {
|
|
directory := strings.TrimSuffix(ctx.String(flagDirectory), "/")
|
|
name := ctx.String(flagName)
|
|
order := ctx.String(flagOrder)
|
|
files := requestFileList(strings.TrimSuffix(ctx.String(flagApiUrl), "/"), name, order)
|
|
input := strings.Trim(ctx.Args().Get(0), " ")
|
|
|
|
if input == "" {
|
|
showFiles(files)
|
|
input = promptInput("1")
|
|
}
|
|
|
|
if input == "q" {
|
|
return nil
|
|
}
|
|
|
|
result := selectFiles(files, input)
|
|
|
|
if len(result) == 0 {
|
|
fmt.Println("Empty list, aborded!")
|
|
|
|
return nil
|
|
}
|
|
|
|
var cmds []*exec.Cmd
|
|
|
|
if action == "play" {
|
|
cmd := generatePlayerCmd(result)
|
|
cmds = append(cmds, cmd)
|
|
} else {
|
|
cmds = generateDownloadCmds(result, directory)
|
|
}
|
|
|
|
runCmds(cmds)
|
|
|
|
return nil
|
|
}
|