SeanOMik
/
roulette
mirror of https://git.seedno.de/seednode/roulette.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: SeanOMik:3ea2227a9fa3fdb6d007cf2248f1dcaa85c8342c
Branches Tags
SeanOMik:master
...
compare: SeanOMik:d2d9418b8b7b8e9821ce911cc0d1d826b6d728d7
Branches Tags
SeanOMik:master

4 Commits
3ea2227a9f ... d2d9418b8b

Author SHA1 Message Date
Seednode d2d9418b8b Replace user.Home() with os.HomeDir() to remove CGo dependency (hopefully) 2023-09-13 12:46:14 -05:00
Seednode 65b77f33cc Attempt to rework stats handling, add support for '~' in paths 2023-09-13 12:30:24 -05:00
Seednode 61f10a6f3c Split http handler registration into source files 2023-09-13 12:00:24 -05:00
Seednode 64639a87a3 Changed all variables to non-exported by default 2023-09-13 09:26:15 -05:00
17 changed files with 450 additions and 399 deletions
Show Stats Expand all files Collapse all files

95
cmd/cache.go
View File

@ -15,24 +15,24 @@ import (
"seedno.de/seednode/roulette/types" "seedno.de/seednode/roulette/types"
) )
type FileIndex struct { type fileCache struct {
mutex sync.RWMutex mutex sync.RWMutex
list []string list []string
} }
func (i *FileIndex) Index() []string { func (cache *fileCache) List() []string {
i.mutex.RLock() cache.mutex.RLock()
val := i.list val := cache.list
i.mutex.RUnlock() cache.mutex.RUnlock()
return val return val
} }
func (i *FileIndex) Remove(path string) { func (cache *fileCache) remove(path string) {
i.mutex.RLock() cache.mutex.RLock()
tempIndex := make([]string, len(i.list)) tempIndex := make([]string, len(cache.list))
copy(tempIndex, i.list) copy(tempIndex, cache.list)
i.mutex.RUnlock() cache.mutex.RUnlock()
var position int var position int
@ -46,39 +46,39 @@ func (i *FileIndex) Remove(path string) {
tempIndex[position] = tempIndex[len(tempIndex)-1] tempIndex[position] = tempIndex[len(tempIndex)-1]
i.mutex.Lock() cache.mutex.Lock()
i.list = make([]string, len(tempIndex)-1) cache.list = make([]string, len(tempIndex)-1)
copy(i.list, tempIndex[:len(tempIndex)-1]) copy(cache.list, tempIndex[:len(tempIndex)-1])
i.mutex.Unlock() cache.mutex.Unlock()
} }
func (i *FileIndex) setIndex(val []string) { func (cache *fileCache) set(val []string) {
i.mutex.Lock() cache.mutex.Lock()
i.list = val cache.list = val
i.mutex.Unlock() cache.mutex.Unlock()
} }
func (i *FileIndex) generateCache(args []string, formats *types.Types) { func (cache *fileCache) generate(args []string, formats *types.Types) {
i.mutex.Lock() cache.mutex.Lock()
i.list = []string{} cache.list = []string{}
i.mutex.Unlock() cache.mutex.Unlock()
fileList(args, &Filters{}, "", i, formats) fileList(args, &filters{}, "", cache, formats)
if Cache && CacheFile != "" { if Cache && CacheFile != "" {
i.Export(CacheFile) cache.Export(CacheFile)
} }
} }
func (i *FileIndex) IsEmpty() bool { func (cache *fileCache) isEmpty() bool {
i.mutex.RLock() cache.mutex.RLock()
length := len(i.list) length := len(cache.list)
i.mutex.RUnlock() cache.mutex.RUnlock()
return length == 0 return length == 0
} }
func (i *FileIndex) Export(path string) error { func (cache *fileCache) Export(path string) error {
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil { if err != nil {
return err return err
@ -93,16 +93,14 @@ func (i *FileIndex) Export(path string) error {
enc := gob.NewEncoder(z) enc := gob.NewEncoder(z)
i.mutex.RLock() cache.mutex.RLock()
enc.Encode(&cache.list)
enc.Encode(&i.list) cache.mutex.RUnlock()
i.mutex.RUnlock()
return nil return nil
} }
func (i *FileIndex) Import(path string) error { func (cache *fileCache) Import(path string) error {
file, err := os.OpenFile(path, os.O_RDONLY, 0600) file, err := os.OpenFile(path, os.O_RDONLY, 0600)
if err != nil { if err != nil {
return err return err
@ -117,11 +115,11 @@ func (i *FileIndex) Import(path string) error {
dec := gob.NewDecoder(z) dec := gob.NewDecoder(z)
i.mutex.Lock() cache.mutex.Lock()
err = dec.Decode(&i.list) err = dec.Decode(&cache.list)
i.mutex.Unlock() cache.mutex.Unlock()
if err != nil { if err != nil {
return err return err
@ -130,12 +128,29 @@ func (i *FileIndex) Import(path string) error {
return nil return nil
} }
func serveCacheClear(args []string, index *FileIndex, formats *types.Types) httprouter.Handle { func serveCacheClear(args []string, cache *fileCache, formats *types.Types) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) { return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
index.generateCache(args, formats) cache.generate(args, formats)
w.Header().Set("Content-Type", "text/plain") w.Header().Set("Content-Type", "text/plain")
w.Write([]byte("Ok")) w.Write([]byte("Ok"))
} }
} }
func registerCacheHandlers(mux *httprouter.Router, args []string, cache *fileCache, formats *types.Types) {
skipIndex := false
if CacheFile != "" {
err := cache.Import(CacheFile)
if err == nil {
skipIndex = true
}
}
if !skipIndex {
cache.generate(args, formats)
}
mux.GET("/clear_cache", serveCacheClear(args, cache, formats))
}

10
cmd/errors.go
View File

@ -24,7 +24,7 @@ func newErrorPage(title, body string) string {
var htmlBody strings.Builder var htmlBody strings.Builder
htmlBody.WriteString(`<!DOCTYPE html><html lang="en"><head>`) htmlBody.WriteString(`<!DOCTYPE html><html lang="en"><head>`)
htmlBody.WriteString(FaviconHtml) htmlBody.WriteString(faviconHtml)
htmlBody.WriteString(`<style>a{display:block;height:100%;width:100%;text-decoration:none;color:inherit;cursor:auto;}</style>`) htmlBody.WriteString(`<style>a{display:block;height:100%;width:100%;text-decoration:none;color:inherit;cursor:auto;}</style>`)
htmlBody.WriteString(fmt.Sprintf("<title>%s</title></head>", title)) htmlBody.WriteString(fmt.Sprintf("<title>%s</title></head>", title))
htmlBody.WriteString(fmt.Sprintf("<body><a href=\"/\">%s</a></body></html>", body)) htmlBody.WriteString(fmt.Sprintf("<body><a href=\"/\">%s</a></body></html>", body))
@ -32,13 +32,13 @@ func newErrorPage(title, body string) string {
return htmlBody.String() return htmlBody.String()
} }
func notFound(w http.ResponseWriter, r *http.Request, filePath string) error { func notFound(w http.ResponseWriter, r *http.Request, path string) error {
startTime := time.Now() startTime := time.Now()
if Verbose { if Verbose {
fmt.Printf("%s | Unavailable file %s requested by %s\n", fmt.Printf("%s | Unavailable file %s requested by %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
filePath, path,
r.RemoteAddr, r.RemoteAddr,
) )
} }
@ -59,7 +59,7 @@ func serverError(w http.ResponseWriter, r *http.Request, i interface{}) {
if Verbose { if Verbose {
fmt.Printf("%s | Invalid request for %s from %s\n", fmt.Printf("%s | Invalid request for %s from %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
r.URL.Path, r.URL.Path,
r.RemoteAddr, r.RemoteAddr,
) )

2
cmd/favicons.go
View File

@ -18,7 +18,7 @@ import (
var favicons embed.FS var favicons embed.FS
const ( const (
FaviconHtml string = `<link rel="apple-touch-icon" sizes="180x180" href="/favicons/apple-touch-icon.png"> faviconHtml string = `<link rel="apple-touch-icon" sizes="180x180" href="/favicons/apple-touch-icon.png">
<link rel="icon" type="image/png" sizes="32x32" href="/favicons/favicon-32x32.png"> <link rel="icon" type="image/png" sizes="32x32" href="/favicons/favicon-32x32.png">
<link rel="icon" type="image/png" sizes="16x16" href="/favicons/favicon-16x16.png"> <link rel="icon" type="image/png" sizes="16x16" href="/favicons/favicon-16x16.png">
<link rel="manifest" href="/favicons/site.webmanifest"> <link rel="manifest" href="/favicons/site.webmanifest">

155
cmd/files.go
View File

@ -31,51 +31,51 @@ const (
maxFileScans maxConcurrency = 256 maxFileScans maxConcurrency = 256
) )
type Regexes struct { type regexes struct {
alphanumeric *regexp.Regexp alphanumeric *regexp.Regexp
filename *regexp.Regexp filename *regexp.Regexp
} }
type Concurrency struct { type concurrency struct {
directoryScans chan int directoryScans chan int
fileScans chan int fileScans chan int
} }
type Files struct { type files struct {
mutex sync.RWMutex mutex sync.RWMutex
list map[string][]string list map[string][]string
} }
func (f *Files) Append(directory, path string) { func (f *files) append(directory, path string) {
f.mutex.Lock() f.mutex.Lock()
f.list[directory] = append(f.list[directory], path) f.list[directory] = append(f.list[directory], path)
f.mutex.Unlock() f.mutex.Unlock()
} }
type ScanStats struct { type scanStats struct {
filesMatched atomic.Uint32 filesMatched atomic.Uint32
filesSkipped atomic.Uint32 filesSkipped atomic.Uint32
directoriesMatched atomic.Uint32 directoriesMatched atomic.Uint32
directoriesSkipped atomic.Uint32 directoriesSkipped atomic.Uint32
} }
type Path struct { type splitPath struct {
base string base string
number int number int
extension string extension string
} }
func (p *Path) increment() { func (splitPath *splitPath) increment() {
p.number = p.number + 1 splitPath.number = splitPath.number + 1
} }
func (p *Path) decrement() { func (splitPath *splitPath) decrement() {
p.number = p.number - 1 splitPath.number = splitPath.number - 1
} }
func contains(s []string, e string) bool { func contains(slice []string, value string) bool {
for _, a := range s { for _, v := range slice {
if a == e { if v == value {
return true return true
} }
} }
@ -102,15 +102,15 @@ func humanReadableSize(bytes int) string {
func preparePath(path string) string { func preparePath(path string) string {
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
return fmt.Sprintf("%s/%s", MediaPrefix, filepath.ToSlash(path)) return fmt.Sprintf("%s/%s", mediaPrefix, filepath.ToSlash(path))
} }
return MediaPrefix + path return mediaPrefix + path
} }
func appendPath(directory, path string, files *Files, stats *ScanStats, formats *types.Types, shouldCache bool) error { func appendPath(directory, path string, files *files, stats *scanStats, formats *types.Types, shouldCache bool) error {
if shouldCache { if shouldCache {
registered, _, _, err := types.FileType(path, formats) registered, _, _, err := formats.FileType(path)
if err != nil { if err != nil {
return err return err
} }
@ -120,15 +120,15 @@ func appendPath(directory, path string, files *Files, stats *ScanStats, formats
} }
} }
files.Append(directory, path) files.append(directory, path)
stats.filesMatched.Add(1) stats.filesMatched.Add(1)
return nil return nil
} }
func appendPaths(path string, files *Files, filters *Filters, stats *ScanStats, formats *types.Types) error { func appendPaths(path string, files *files, filters *filters, stats *scanStats, formats *types.Types) error {
shouldCache := Cache && filters.IsEmpty() shouldCache := Cache && filters.isEmpty()
absolutePath, err := filepath.Abs(path) absolutePath, err := filepath.Abs(path)
if err != nil { if err != nil {
@ -139,11 +139,11 @@ func appendPaths(path string, files *Files, filters *Filters, stats *ScanStats,
filename = strings.ToLower(filename) filename = strings.ToLower(filename)
if filters.HasExcludes() { if filters.hasExcludes() {
for i := 0; i < len(filters.excludes); i++ { for i := 0; i < len(filters.excluded); i++ {
if strings.Contains( if strings.Contains(
filename, filename,
filters.excludes[i], filters.excluded[i],
) { ) {
stats.filesSkipped.Add(1) stats.filesSkipped.Add(1)
@ -152,11 +152,11 @@ func appendPaths(path string, files *Files, filters *Filters, stats *ScanStats,
} }
} }
if filters.HasIncludes() { if filters.hasIncludes() {
for i := 0; i < len(filters.includes); i++ { for i := 0; i < len(filters.included); i++ {
if strings.Contains( if strings.Contains(
filename, filename,
filters.includes[i], filters.included[i],
) { ) {
err := appendPath(directory, path, files, stats, formats, shouldCache) err := appendPath(directory, path, files, stats, formats, shouldCache)
if err != nil { if err != nil {
@ -180,38 +180,38 @@ func appendPaths(path string, files *Files, filters *Filters, stats *ScanStats,
return nil return nil
} }
func newFile(paths []string, filters *Filters, sortOrder string, Regexes *Regexes, index *FileIndex, formats *types.Types) (string, error) { func newFile(paths []string, filters *filters, sortOrder string, regexes *regexes, index *fileCache, formats *types.Types) (string, error) {
filePath, err := pickFile(paths, filters, sortOrder, index, formats) path, err := pickFile(paths, filters, sortOrder, index, formats)
if err != nil { if err != nil {
return "", nil return "", nil
} }
path, err := splitPath(filePath, Regexes) splitPath, err := split(path, regexes)
if err != nil { if err != nil {
return "", err return "", err
} }
path.number = 1 splitPath.number = 1
switch { switch {
case sortOrder == "asc": case sortOrder == "asc":
filePath, err = tryExtensions(path, formats) path, err = tryExtensions(splitPath, formats)
if err != nil { if err != nil {
return "", err return "", err
} }
case sortOrder == "desc": case sortOrder == "desc":
for { for {
path.increment() splitPath.increment()
filePath, err = tryExtensions(path, formats) path, err = tryExtensions(splitPath, formats)
if err != nil { if err != nil {
return "", err return "", err
} }
if filePath == "" { if path == "" {
path.decrement() splitPath.decrement()
filePath, err = tryExtensions(path, formats) path, err = tryExtensions(splitPath, formats)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -221,25 +221,25 @@ func newFile(paths []string, filters *Filters, sortOrder string, Regexes *Regexe
} }
} }
return filePath, nil return path, nil
} }
func nextFile(filePath, sortOrder string, Regexes *Regexes, formats *types.Types) (string, error) { func nextFile(path, sortOrder string, regexes *regexes, formats *types.Types) (string, error) {
path, err := splitPath(filePath, Regexes) splitPath, err := split(path, regexes)
if err != nil { if err != nil {
return "", err return "", err
} }
switch { switch {
case sortOrder == "asc": case sortOrder == "asc":
path.increment() splitPath.increment()
case sortOrder == "desc": case sortOrder == "desc":
path.decrement() splitPath.decrement()
default: default:
return "", nil return "", nil
} }
fileName, err := tryExtensions(path, formats) fileName, err := tryExtensions(splitPath, formats)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -247,21 +247,21 @@ func nextFile(filePath, sortOrder string, Regexes *Regexes, formats *types.Types
return fileName, err return fileName, err
} }
func splitPath(path string, Regexes *Regexes) (*Path, error) { func split(path string, regexes *regexes) (*splitPath, error) {
p := Path{} p := splitPath{}
var err error var err error
split := Regexes.filename.FindAllStringSubmatch(path, -1) split := regexes.filename.FindAllStringSubmatch(path, -1)
if len(split) < 1 || len(split[0]) < 3 { if len(split) < 1 || len(split[0]) < 3 {
return &Path{}, nil return &splitPath{}, nil
} }
p.base = split[0][1] p.base = split[0][1]
p.number, err = strconv.Atoi(split[0][2]) p.number, err = strconv.Atoi(split[0][2])
if err != nil { if err != nil {
return &Path{}, err return &splitPath{}, err
} }
p.extension = split[0][3] p.extension = split[0][3]
@ -269,11 +269,11 @@ func splitPath(path string, Regexes *Regexes) (*Path, error) {
return &p, nil return &p, nil
} }
func tryExtensions(p *Path, formats *types.Types) (string, error) { func tryExtensions(splitPath *splitPath, formats *types.Types) (string, error) {
var fileName string var fileName string
for extension := range formats.Extensions { for extension := range formats.Extensions {
fileName = fmt.Sprintf("%s%.3d%s", p.base, p.number, extension) fileName = fmt.Sprintf("%s%.3d%s", splitPath.base, splitPath.number, extension)
exists, err := fileExists(fileName) exists, err := fileExists(fileName)
if err != nil { if err != nil {
@ -300,11 +300,11 @@ func fileExists(path string) (bool, error) {
} }
} }
func pathIsValid(filePath string, paths []string) bool { func pathIsValid(path string, paths []string) bool {
var matchesPrefix = false var matchesPrefix = false
for i := 0; i < len(paths); i++ { for i := 0; i < len(paths); i++ {
if strings.HasPrefix(filePath, paths[i]) { if strings.HasPrefix(path, paths[i]) {
matchesPrefix = true matchesPrefix = true
} }
} }
@ -312,8 +312,8 @@ func pathIsValid(filePath string, paths []string) bool {
switch { switch {
case Verbose && !matchesPrefix: case Verbose && !matchesPrefix:
fmt.Printf("%s | Error: Failed to serve file outside specified path(s): %s\n", fmt.Printf("%s | Error: Failed to serve file outside specified path(s): %s\n",
time.Now().Format(LogDate), time.Now().Format(logDate),
filePath, path,
) )
return false return false
@ -336,7 +336,7 @@ func pathHasSupportedFiles(path string, formats *types.Types) (bool, error) {
case !Recursive && info.IsDir() && p != path: case !Recursive && info.IsDir() && p != path:
return filepath.SkipDir return filepath.SkipDir
case !info.IsDir(): case !info.IsDir():
registered, _, _, err := types.FileType(p, formats) registered, _, _, err := formats.FileType(p)
if err != nil { if err != nil {
return err return err
} }
@ -381,7 +381,7 @@ func pathCount(path string) (uint32, uint32, error) {
return files, directories, nil return files, directories, nil
} }
func scanPath(path string, files *Files, filters *Filters, stats *ScanStats, concurrency *Concurrency, formats *types.Types) error { func scanPath(path string, files *files, filters *filters, stats *scanStats, concurrency *concurrency, formats *types.Types) error {
var wg sync.WaitGroup var wg sync.WaitGroup
err := filepath.WalkDir(path, func(p string, info os.DirEntry, err error) error { err := filepath.WalkDir(path, func(p string, info os.DirEntry, err error) error {
@ -442,26 +442,26 @@ func scanPath(path string, files *Files, filters *Filters, stats *ScanStats, con
return nil return nil
} }
func fileList(paths []string, filters *Filters, sort string, index *FileIndex, formats *types.Types) ([]string, bool) { func fileList(paths []string, filters *filters, sort string, cache *fileCache, formats *types.Types) ([]string, bool) {
if Cache && filters.IsEmpty() && !index.IsEmpty() { if Cache && filters.isEmpty() && !cache.isEmpty() {
return index.Index(), true return cache.List(), true
} }
var fileList []string var fileList []string
files := &Files{ files := &files{
mutex: sync.RWMutex{}, mutex: sync.RWMutex{},
list: make(map[string][]string), list: make(map[string][]string),
} }
stats := &ScanStats{ stats := &scanStats{
filesMatched: atomic.Uint32{}, filesMatched: atomic.Uint32{},
filesSkipped: atomic.Uint32{}, filesSkipped: atomic.Uint32{},
directoriesMatched: atomic.Uint32{}, directoriesMatched: atomic.Uint32{},
directoriesSkipped: atomic.Uint32{}, directoriesSkipped: atomic.Uint32{},
} }
concurrency := &Concurrency{ concurrency := &concurrency{
directoryScans: make(chan int, maxDirectoryScans), directoryScans: make(chan int, maxDirectoryScans),
fileScans: make(chan int, maxFileScans), fileScans: make(chan int, maxFileScans),
} }
@ -498,7 +498,7 @@ func fileList(paths []string, filters *Filters, sort string, index *FileIndex, f
if Verbose { if Verbose {
fmt.Printf("%s | Indexed %d/%d files across %d/%d directories in %s\n", fmt.Printf("%s | Indexed %d/%d files across %d/%d directories in %s\n",
time.Now().Format(LogDate), time.Now().Format(logDate),
stats.filesMatched.Load(), stats.filesMatched.Load(),
stats.filesMatched.Load()+stats.filesSkipped.Load(), stats.filesMatched.Load()+stats.filesSkipped.Load(),
stats.directoriesMatched.Load(), stats.directoriesMatched.Load(),
@ -507,8 +507,8 @@ func fileList(paths []string, filters *Filters, sort string, index *FileIndex, f
) )
} }
if Cache && filters.IsEmpty() { if Cache && filters.isEmpty() {
index.setIndex(fileList) cache.set(fileList)
} }
return fileList, false return fileList, false
@ -532,7 +532,7 @@ func prepareDirectory(directory []string) []string {
} }
} }
func prepareDirectories(files *Files, sort string) []string { func prepareDirectories(files *files, sort string) []string {
directories := []string{} directories := []string{}
keys := make([]string, len(files.list)) keys := make([]string, len(files.list))
@ -556,8 +556,8 @@ func prepareDirectories(files *Files, sort string) []string {
return directories return directories
} }
func pickFile(args []string, filters *Filters, sort string, index *FileIndex, formats *types.Types) (string, error) { func pickFile(args []string, filters *filters, sort string, cache *fileCache, formats *types.Types) (string, error) {
fileList, fromCache := fileList(args, filters, sort, index, formats) fileList, fromCache := fileList(args, filters, sort, cache, formats)
fileCount := len(fileList) fileCount := len(fileList)
if fileCount < 1 { if fileCount < 1 {
@ -581,29 +581,40 @@ func pickFile(args []string, filters *Filters, sort string, index *FileIndex, fo
val++ val++
} }
filePath := fileList[val] path := fileList[val]
if !fromCache { if !fromCache {
registered, _, _, err := types.FileType(filePath, formats) registered, _, _, err := formats.FileType(path)
if err != nil { if err != nil {
return "", err return "", err
} }
if registered { if registered {
return filePath, nil return path, nil
} }
continue continue
} }
return filePath, nil return path, nil
} }
return "", ErrNoMediaFound return "", ErrNoMediaFound
} }
func normalizePath(path string) (string, error) { func normalizePath(path string) (string, error) {
path, err := filepath.EvalSymlinks(path) homeDir, err := os.UserHomeDir()
if err != nil {
return "", err
}
if path == "~" {
path = homeDir
} else if strings.HasPrefix(path, "~/") {
path = filepath.Join(homeDir, path[2:])
}
path, err = filepath.EvalSymlinks(path)
if err != nil { if err != nil {
return "", err return "", err
} }

26
cmd/filters.go
View File

@ -6,27 +6,27 @@ package cmd
import "strings" import "strings"
type Filters struct { type filters struct {
includes []string included []string
excludes []string excluded []string
} }
func (f *Filters) IsEmpty() bool { func (filters *filters) isEmpty() bool {
return !(f.HasIncludes() || f.HasExcludes()) return !(filters.hasIncludes() || filters.hasExcludes())
} }
func (f *Filters) HasIncludes() bool { func (filters *filters) hasIncludes() bool {
return len(f.includes) != 0 return len(filters.included) != 0
} }
func (f *Filters) Includes() string { func (filters *filters) includes() string {
return strings.Join(f.includes, ",") return strings.Join(filters.included, ",")
} }
func (f *Filters) HasExcludes() bool { func (filters *filters) hasExcludes() bool {
return len(f.excludes) != 0 return len(filters.excluded) != 0
} }
func (f *Filters) Excludes() string { func (filters *filters) excludes() string {
return strings.Join(f.excludes, ",") return strings.Join(filters.excluded, ",")
} }

53
cmd/info.go
View File

@ -19,13 +19,13 @@ import (
"seedno.de/seednode/roulette/types" "seedno.de/seednode/roulette/types"
) )
func serveIndexHtml(args []string, index *FileIndex, paginate bool) httprouter.Handle { func serveIndexHtml(args []string, cache *fileCache, paginate bool) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) { return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
w.Header().Set("Content-Type", "text/html") w.Header().Set("Content-Type", "text/html")
startTime := time.Now() startTime := time.Now()
indexDump := index.Index() indexDump := cache.List()
fileCount := len(indexDump) fileCount := len(indexDump)
@ -54,7 +54,7 @@ func serveIndexHtml(args []string, index *FileIndex, paginate bool) httprouter.H
var htmlBody strings.Builder var htmlBody strings.Builder
htmlBody.WriteString(`<!DOCTYPE html><html lang="en"><head>`) htmlBody.WriteString(`<!DOCTYPE html><html lang="en"><head>`)
htmlBody.WriteString(FaviconHtml) htmlBody.WriteString(faviconHtml)
htmlBody.WriteString(`<style>a{text-decoration:none;height:100%;width:100%;color:inherit;cursor:pointer}`) htmlBody.WriteString(`<style>a{text-decoration:none;height:100%;width:100%;color:inherit;cursor:pointer}`)
htmlBody.WriteString(`table,td,tr{border:1px solid black;border-collapse:collapse}td{white-space:nowrap;padding:.5em}</style>`) htmlBody.WriteString(`table,td,tr{border:1px solid black;border-collapse:collapse}td{white-space:nowrap;padding:.5em}</style>`)
htmlBody.WriteString(fmt.Sprintf("<title>Index contains %d files</title></head><body><table>", fileCount)) htmlBody.WriteString(fmt.Sprintf("<title>Index contains %d files</title></head><body><table>", fileCount))
@ -65,7 +65,7 @@ func serveIndexHtml(args []string, index *FileIndex, paginate bool) httprouter.H
if Sorting { if Sorting {
shouldSort = "?sort=asc" shouldSort = "?sort=asc"
} }
htmlBody.WriteString(fmt.Sprintf("<tr><td><a href=\"%s%s%s\">%s</a></td></tr>\n", MediaPrefix, v, shouldSort, v)) htmlBody.WriteString(fmt.Sprintf("<tr><td><a href=\"%s%s%s\">%s</a></td></tr>\n", mediaPrefix, v, shouldSort, v))
} }
} }
if PageLength != 0 { if PageLength != 0 {
@ -124,7 +124,7 @@ func serveIndexHtml(args []string, index *FileIndex, paginate bool) httprouter.H
if Verbose { if Verbose {
fmt.Printf("%s | Served HTML index page (%s) to %s in %s\n", fmt.Printf("%s | Served HTML index page (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
humanReadableSize(b), humanReadableSize(b),
realIP(r), realIP(r),
time.Since(startTime).Round(time.Microsecond), time.Since(startTime).Round(time.Microsecond),
@ -133,18 +133,18 @@ func serveIndexHtml(args []string, index *FileIndex, paginate bool) httprouter.H
} }
} }
func serveIndexJson(args []string, index *FileIndex) httprouter.Handle { func serveIndexJson(args []string, index *fileCache) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) { return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
w.Header().Set("Content-Type", "application/json") w.Header().Set("Content-Type", "application/json")
startTime := time.Now() startTime := time.Now()
indexDump := index.Index() cachedFiles := index.List()
fileCount := len(indexDump) fileCount := len(cachedFiles)
sort.SliceStable(indexDump, func(p, q int) bool { sort.SliceStable(cachedFiles, func(p, q int) bool {
return strings.ToLower(indexDump[p]) < strings.ToLower(indexDump[q]) return strings.ToLower(cachedFiles[p]) < strings.ToLower(cachedFiles[q])
}) })
var startIndex, stopIndex int var startIndex, stopIndex int
@ -159,14 +159,14 @@ func serveIndexJson(args []string, index *FileIndex) httprouter.Handle {
} }
if startIndex > (fileCount - 1) { if startIndex > (fileCount - 1) {
indexDump = []string{} cachedFiles = []string{}
} }
if stopIndex > fileCount { if stopIndex > fileCount {
stopIndex = fileCount stopIndex = fileCount
} }
response, err := json.MarshalIndent(indexDump[startIndex:stopIndex], "", " ") response, err := json.MarshalIndent(cachedFiles[startIndex:stopIndex], "", " ")
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -179,7 +179,7 @@ func serveIndexJson(args []string, index *FileIndex) httprouter.Handle {
if Verbose { if Verbose {
fmt.Printf("%s | Served JSON index page (%s) to %s in %s\n", fmt.Printf("%s | Served JSON index page (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
humanReadableSize(len(response)), humanReadableSize(len(response)),
realIP(r), realIP(r),
time.Since(startTime).Round(time.Microsecond), time.Since(startTime).Round(time.Microsecond),
@ -200,7 +200,7 @@ func serveAvailableExtensions() httprouter.Handle {
if Verbose { if Verbose {
fmt.Printf("%s | Served available extensions list (%s) to %s in %s\n", fmt.Printf("%s | Served available extensions list (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
humanReadableSize(len(response)), humanReadableSize(len(response)),
realIP(r), realIP(r),
time.Since(startTime).Round(time.Microsecond), time.Since(startTime).Round(time.Microsecond),
@ -221,7 +221,7 @@ func serveEnabledExtensions(formats *types.Types) httprouter.Handle {
if Verbose { if Verbose {
fmt.Printf("%s | Served registered extensions list (%s) to %s in %s\n", fmt.Printf("%s | Served registered extensions list (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
humanReadableSize(len(response)), humanReadableSize(len(response)),
realIP(r), realIP(r),
time.Since(startTime).Round(time.Microsecond), time.Since(startTime).Round(time.Microsecond),
@ -242,7 +242,7 @@ func serveAvailableMimeTypes() httprouter.Handle {
if Verbose { if Verbose {
fmt.Printf("%s | Served available MIME types list (%s) to %s in %s\n", fmt.Printf("%s | Served available MIME types list (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
humanReadableSize(len(response)), humanReadableSize(len(response)),
realIP(r), realIP(r),
time.Since(startTime).Round(time.Microsecond), time.Since(startTime).Round(time.Microsecond),
@ -263,7 +263,7 @@ func serveEnabledMimeTypes(formats *types.Types) httprouter.Handle {
if Verbose { if Verbose {
fmt.Printf("%s | Served registered MIME types list (%s) to %s in %s\n", fmt.Printf("%s | Served registered MIME types list (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
humanReadableSize(len(response)), humanReadableSize(len(response)),
realIP(r), realIP(r),
time.Since(startTime).Round(time.Microsecond), time.Since(startTime).Round(time.Microsecond),
@ -271,3 +271,22 @@ func serveEnabledMimeTypes(formats *types.Types) httprouter.Handle {
} }
} }
} }
func registerInfoHandlers(mux *httprouter.Router, args []string, cache *fileCache, formats *types.Types) {
if Cache {
mux.GET("/html/", serveIndexHtml(args, cache, false))
if PageLength != 0 {
mux.GET("/html/:page", serveIndexHtml(args, cache, true))
}
mux.GET("/json", serveIndexJson(args, cache))
if PageLength != 0 {
mux.GET("/json/:page", serveIndexJson(args, cache))
}
}
mux.GET("/available_extensions", serveAvailableExtensions())
mux.GET("/enabled_extensions", serveEnabledExtensions(formats))
mux.GET("/available_mime_types", serveAvailableMimeTypes())
mux.GET("/enabled_mime_types", serveEnabledMimeTypes(formats))
}

19
cmd/profile.go Normal file
View File

@ -0,0 +1,19 @@
/*
Copyright © 2023 Seednode <seednode@seedno.de>
*/
package cmd
import (
"net/http/pprof"
"github.com/julienschmidt/httprouter"
)
func registerProfileHandlers(mux *httprouter.Router) {
mux.HandlerFunc("GET", "/debug/pprof/", pprof.Index)
mux.HandlerFunc("GET", "/debug/pprof/cmdline", pprof.Cmdline)
mux.HandlerFunc("GET", "/debug/pprof/profile", pprof.Profile)
mux.HandlerFunc("GET", "/debug/pprof/symbol", pprof.Symbol)
mux.HandlerFunc("GET", "/debug/pprof/trace", pprof.Trace)
}

2
cmd/root.go
View File

@ -12,7 +12,7 @@ import (
) )
const ( const (
ReleaseVersion string = "0.76.0" ReleaseVersion string = "0.78.2"
) )
var ( var (

210
cmd/stats.go
View File

@ -20,7 +20,7 @@ import (
"github.com/klauspost/compress/zstd" "github.com/klauspost/compress/zstd"
) )
type ServeStats struct { type serveStats struct {
mutex sync.RWMutex mutex sync.RWMutex
list []string list []string
count map[string]uint32 count map[string]uint32
@ -28,123 +28,93 @@ type ServeStats struct {
times map[string][]string times map[string][]string
} }
type exportedServeStats struct { type publicServeStats struct {
List []string List []string
Count map[string]uint32 Count map[string]uint32
Size map[string]string Size map[string]string
Times map[string][]string Times map[string][]string
} }
func (s *ServeStats) incrementCounter(file string, timestamp time.Time, filesize string) { type timesServed struct {
s.mutex.Lock() File string
Served uint32
Size string
Times []string
}
s.count[file]++ func (stats *serveStats) incrementCounter(file string, timestamp time.Time, filesize string) {
stats.mutex.Lock()
s.times[file] = append(s.times[file], timestamp.Format(LogDate)) stats.count[file]++
_, exists := s.size[file] stats.times[file] = append(stats.times[file], timestamp.Format(logDate))
_, exists := stats.size[file]
if !exists { if !exists {
s.size[file] = filesize stats.size[file] = filesize
} }
if !contains(s.list, file) { if !contains(stats.list, file) {
s.list = append(s.list, file) stats.list = append(stats.list, file)
} }
s.mutex.Unlock() stats.mutex.Unlock()
} }
func (s *ServeStats) toExported() *exportedServeStats { func (stats *serveStats) Import(source *publicServeStats) {
stats := &exportedServeStats{ stats.mutex.Lock()
List: make([]string, len(s.list)),
Count: make(map[string]uint32), copy(stats.list, source.List)
Size: make(map[string]string),
Times: make(map[string][]string), for k, v := range source.Count {
fmt.Printf("Setting count[%s] to %d\n", k, v)
stats.count[k] = v
} }
s.mutex.RLock() for k, v := range source.Size {
fmt.Printf("Setting size[%s] to %v\n", k, v)
copy(stats.List, s.list) stats.size[k] = v
}
for k, v := range s.count { for k, v := range source.Times {
fmt.Printf("Setting times[%s] to %v\n", k, v)
stats.times[k] = v
}
stats.mutex.Unlock()
}
func (source *serveStats) Export() *publicServeStats {
source.mutex.RLock()
stats := &publicServeStats{
List: make([]string, len(source.list)),
Count: make(map[string]uint32, len(source.count)),
Size: make(map[string]string, len(source.size)),
Times: make(map[string][]string, len(source.times)),
}
copy(stats.List, source.list)
for k, v := range source.count {
stats.Count[k] = v stats.Count[k] = v
} }
for k, v := range s.size { for k, v := range source.size {
stats.Size[k] = v stats.Size[k] = v
} }
for k, v := range s.times { for k, v := range source.times {
stats.Times[k] = v stats.Times[k] = v
} }
s.mutex.RUnlock() source.mutex.RUnlock()
return stats return stats
} }
func (s *ServeStats) toImported(stats *exportedServeStats) { func (stats *serveStats) exportFile(path string) error {
s.mutex.Lock()
s.list = make([]string, len(stats.List))
copy(s.list, stats.List)
for k, v := range stats.Count {
s.count[k] = v
}
for k, v := range stats.Size {
s.size[k] = v
}
for k, v := range stats.Times {
s.times[k] = v
}
s.mutex.Unlock()
}
func (s *ServeStats) ListFiles(page int) ([]byte, error) {
stats := s.toExported()
sort.SliceStable(stats.List, func(p, q int) bool {
return strings.ToLower(stats.List[p]) < strings.ToLower(stats.List[q])
})
var startIndex, stopIndex int
if page == -1 {
startIndex = 0
stopIndex = len(stats.List) - 1
} else {
startIndex = ((page - 1) * int(PageLength))
stopIndex = (startIndex + int(PageLength))
}
if startIndex > len(stats.List)-1 {
return []byte("{}"), nil
}
if stopIndex > len(stats.List)-1 {
stopIndex = len(stats.List) - 1
}
a := make([]timesServed, stopIndex-startIndex)
for k, v := range stats.List[startIndex:stopIndex] {
a[k] = timesServed{v, stats.Count[v], stats.Size[v], stats.Times[v]}
}
r, err := json.MarshalIndent(a, "", " ")
if err != nil {
return []byte{}, err
}
return r, nil
}
func (s *ServeStats) Export(path string) error {
file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600) file, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
if err != nil { if err != nil {
return err return err
@ -159,9 +129,7 @@ func (s *ServeStats) Export(path string) error {
enc := gob.NewEncoder(z) enc := gob.NewEncoder(z)
stats := s.toExported() err = enc.Encode(stats.Export())
err = enc.Encode(&stats)
if err != nil { if err != nil {
return err return err
} }
@ -169,7 +137,7 @@ func (s *ServeStats) Export(path string) error {
return nil return nil
} }
func (s *ServeStats) Import(path string) error { func (stats *serveStats) importFile(path string) error {
file, err := os.OpenFile(path, os.O_RDONLY, 0600) file, err := os.OpenFile(path, os.O_RDONLY, 0600)
if err != nil { if err != nil {
return err return err
@ -184,33 +152,64 @@ func (s *ServeStats) Import(path string) error {
dec := gob.NewDecoder(z) dec := gob.NewDecoder(z)
stats := &exportedServeStats{ source := &publicServeStats{
List: []string{}, List: []string{},
Count: make(map[string]uint32), Count: make(map[string]uint32),
Size: make(map[string]string), Size: make(map[string]string),
Times: make(map[string][]string), Times: make(map[string][]string),
} }
err = dec.Decode(stats) err = dec.Decode(source)
if err != nil { if err != nil {
return err return err
} }
s.toImported(stats) stats.Import(source)
return nil return nil
} }
type timesServed struct { func (source *serveStats) listFiles(page int) ([]byte, error) {
File string stats := source.Export()
Served uint32
Size string sort.SliceStable(stats.List, func(p, q int) bool {
Times []string return strings.ToLower(stats.List[p]) < strings.ToLower(stats.List[q])
})
var startIndex, stopIndex int
if page == -1 {
startIndex = 0
stopIndex = len(stats.List)
} else {
startIndex = ((page - 1) * int(PageLength))
stopIndex = (startIndex + int(PageLength))
} }
func serveStats(args []string, stats *ServeStats) httprouter.Handle { if startIndex > len(stats.List)-1 {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) { return []byte("{}"), nil
}
if stopIndex > len(stats.List) {
stopIndex = len(stats.List)
}
a := make([]timesServed, (stopIndex - startIndex))
for k, v := range stats.List[startIndex:stopIndex] {
a[k] = timesServed{v, stats.Count[v], stats.Size[v], stats.Times[v]}
}
r, err := json.MarshalIndent(a, "", " ")
if err != nil {
return []byte{}, err
}
return r, nil
}
func serveStatsPage(args []string, stats *serveStats) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
startTime := time.Now() startTime := time.Now()
page, err := strconv.Atoi(p.ByName("page")) page, err := strconv.Atoi(p.ByName("page"))
@ -218,7 +217,7 @@ func serveStats(args []string, stats *ServeStats) httprouter.Handle {
page = -1 page = -1
} }
response, err := stats.ListFiles(page) response, err := stats.listFiles(page)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -233,7 +232,7 @@ func serveStats(args []string, stats *ServeStats) httprouter.Handle {
if Verbose { if Verbose {
fmt.Printf("%s | Served statistics page (%s) to %s in %s\n", fmt.Printf("%s | Served statistics page (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
humanReadableSize(len(response)), humanReadableSize(len(response)),
realIP(r), realIP(r),
time.Since(startTime).Round(time.Microsecond), time.Since(startTime).Round(time.Microsecond),
@ -241,7 +240,14 @@ func serveStats(args []string, stats *ServeStats) httprouter.Handle {
} }
if StatisticsFile != "" { if StatisticsFile != "" {
stats.Export(StatisticsFile) stats.exportFile(StatisticsFile)
} }
} }
} }
func registerStatsHandlers(mux *httprouter.Router, args []string, stats *serveStats) {
mux.GET("/stats", serveStatsPage(args, stats))
if PageLength != 0 {
mux.GET("/stats/:page", serveStatsPage(args, stats))
}
}

22
cmd/uri.go
View File

@ -34,7 +34,7 @@ func refreshInterval(r *http.Request) (int64, string) {
} }
} }
func SortOrder(r *http.Request) string { func sortOrder(r *http.Request) string {
sortOrder := r.URL.Query().Get("sort") sortOrder := r.URL.Query().Get("sort")
if sortOrder == "asc" || sortOrder == "desc" { if sortOrder == "asc" || sortOrder == "desc" {
return sortOrder return sortOrder
@ -43,7 +43,7 @@ func SortOrder(r *http.Request) string {
return "" return ""
} }
func splitQueryParams(query string, Regexes *Regexes) []string { func splitQueryParams(query string, regexes *regexes) []string {
results := []string{} results := []string{}
if query == "" { if query == "" {
@ -53,7 +53,7 @@ func splitQueryParams(query string, Regexes *Regexes) []string {
params := strings.Split(query, ",") params := strings.Split(query, ",")
for i := 0; i < len(params); i++ { for i := 0; i < len(params); i++ {
if Regexes.alphanumeric.MatchString(params[i]) { if regexes.alphanumeric.MatchString(params[i]) {
results = append(results, strings.ToLower(params[i])) results = append(results, strings.ToLower(params[i]))
} }
} }
@ -61,7 +61,7 @@ func splitQueryParams(query string, Regexes *Regexes) []string {
return results return results
} }
func generateQueryParams(filters *Filters, sortOrder, refreshInterval string) string { func generateQueryParams(filters *filters, sortOrder, refreshInterval string) string {
var hasParams bool var hasParams bool
var queryParams strings.Builder var queryParams strings.Builder
@ -70,13 +70,13 @@ func generateQueryParams(filters *Filters, sortOrder, refreshInterval string) st
if Filtering { if Filtering {
queryParams.WriteString("include=") queryParams.WriteString("include=")
if filters.HasIncludes() { if filters.hasIncludes() {
queryParams.WriteString(filters.Includes()) queryParams.WriteString(filters.includes())
} }
queryParams.WriteString("&exclude=") queryParams.WriteString("&exclude=")
if filters.HasExcludes() { if filters.hasExcludes() {
queryParams.WriteString(filters.Excludes()) queryParams.WriteString(filters.excludes())
} }
hasParams = true hasParams = true
@ -100,8 +100,8 @@ func generateQueryParams(filters *Filters, sortOrder, refreshInterval string) st
return queryParams.String() return queryParams.String()
} }
func stripQueryParams(u string) (string, error) { func stripQueryParams(request string) (string, error) {
uri, err := url.Parse(u) uri, err := url.Parse(request)
if err != nil { if err != nil {
return "", err return "", err
} }
@ -123,7 +123,7 @@ func stripQueryParams(u string) (string, error) {
func generateFileUri(path string) string { func generateFileUri(path string) string {
var uri strings.Builder var uri strings.Builder
uri.WriteString(SourcePrefix) uri.WriteString(sourcePrefix)
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
uri.WriteString(`/`) uri.WriteString(`/`)
} }

159
cmd/web.go
View File

@ -22,8 +22,6 @@ import (
"syscall" "syscall"
"time" "time"
"net/http/pprof"
"github.com/julienschmidt/httprouter" "github.com/julienschmidt/httprouter"
"github.com/yosssi/gohtml" "github.com/yosssi/gohtml"
"seedno.de/seednode/roulette/types" "seedno.de/seednode/roulette/types"
@ -35,16 +33,16 @@ import (
) )
const ( const (
LogDate string = `2006-01-02T15:04:05.000-07:00` logDate string = `2006-01-02T15:04:05.000-07:00`
SourcePrefix string = `/source` sourcePrefix string = `/source`
MediaPrefix string = `/view` mediaPrefix string = `/view`
RedirectStatusCode int = http.StatusSeeOther RedirectStatusCode int = http.StatusSeeOther
Timeout time.Duration = 10 * time.Second timeout time.Duration = 10 * time.Second
) )
func serveStaticFile(paths []string, stats *ServeStats, index *FileIndex) httprouter.Handle { func serveStaticFile(paths []string, stats *serveStats, cache *fileCache) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) { return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
path := strings.TrimPrefix(r.URL.Path, SourcePrefix) path := strings.TrimPrefix(r.URL.Path, sourcePrefix)
prefixedFilePath, err := stripQueryParams(path) prefixedFilePath, err := stripQueryParams(path)
if err != nil { if err != nil {
@ -55,7 +53,7 @@ func serveStaticFile(paths []string, stats *ServeStats, index *FileIndex) httpro
return return
} }
filePath, err := filepath.EvalSymlinks(strings.TrimPrefix(prefixedFilePath, SourcePrefix)) filePath, err := filepath.EvalSymlinks(strings.TrimPrefix(prefixedFilePath, sourcePrefix))
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -111,13 +109,13 @@ func serveStaticFile(paths []string, stats *ServeStats, index *FileIndex) httpro
} }
if Cache { if Cache {
index.Remove(filePath) cache.remove(filePath)
} }
} }
if Verbose { if Verbose {
fmt.Printf("%s | Served %s (%s) to %s in %s\n", fmt.Printf("%s | Served %s (%s) to %s in %s\n",
startTime.Format(LogDate), startTime.Format(logDate),
filePath, filePath,
fileSize, fileSize,
realIP(r), realIP(r),
@ -132,7 +130,7 @@ func serveStaticFile(paths []string, stats *ServeStats, index *FileIndex) httpro
} }
} }
func serveRoot(paths []string, Regexes *Regexes, index *FileIndex, formats *types.Types) httprouter.Handle { func serveRoot(paths []string, regexes *regexes, cache *fileCache, formats *types.Types) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) { return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
refererUri, err := stripQueryParams(refererToUri(r.Referer())) refererUri, err := stripQueryParams(refererToUri(r.Referer()))
if err != nil { if err != nil {
@ -143,21 +141,21 @@ func serveRoot(paths []string, Regexes *Regexes, index *FileIndex, formats *type
return return
} }
strippedRefererUri := strings.TrimPrefix(refererUri, MediaPrefix) strippedRefererUri := strings.TrimPrefix(refererUri, mediaPrefix)
filters := &Filters{ filters := &filters{
includes: splitQueryParams(r.URL.Query().Get("include"), Regexes), included: splitQueryParams(r.URL.Query().Get("include"), regexes),
excludes: splitQueryParams(r.URL.Query().Get("exclude"), Regexes), excluded: splitQueryParams(r.URL.Query().Get("exclude"), regexes),
} }
sortOrder := SortOrder(r) sortOrder := sortOrder(r)
_, refreshInterval := refreshInterval(r) _, refreshInterval := refreshInterval(r)
var filePath string var filePath string
if refererUri != "" { if refererUri != "" {
filePath, err = nextFile(strippedRefererUri, sortOrder, Regexes, formats) filePath, err = nextFile(strippedRefererUri, sortOrder, regexes, formats)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -168,7 +166,7 @@ func serveRoot(paths []string, Regexes *Regexes, index *FileIndex, formats *type
} }
loop: loop:
for timeout := time.After(Timeout); ; { for timeout := time.After(timeout); ; {
select { select {
case <-timeout: case <-timeout:
break loop break loop
@ -179,7 +177,7 @@ func serveRoot(paths []string, Regexes *Regexes, index *FileIndex, formats *type
break loop break loop
} }
filePath, err = newFile(paths, filters, sortOrder, Regexes, index, formats) filePath, err = newFile(paths, filters, sortOrder, regexes, cache, formats)
switch { switch {
case err != nil && err == ErrNoMediaFound: case err != nil && err == ErrNoMediaFound:
notFound(w, r, filePath) notFound(w, r, filePath)
@ -205,22 +203,22 @@ func serveRoot(paths []string, Regexes *Regexes, index *FileIndex, formats *type
} }
} }
func serveMedia(paths []string, Regexes *Regexes, index *FileIndex, formats *types.Types) httprouter.Handle { func serveMedia(paths []string, regexes *regexes, formats *types.Types) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) { return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
filters := &Filters{ filters := &filters{
includes: splitQueryParams(r.URL.Query().Get("include"), Regexes), included: splitQueryParams(r.URL.Query().Get("include"), regexes),
excludes: splitQueryParams(r.URL.Query().Get("exclude"), Regexes), excluded: splitQueryParams(r.URL.Query().Get("exclude"), regexes),
} }
sortOrder := SortOrder(r) sortOrder := sortOrder(r)
filePath := strings.TrimPrefix(r.URL.Path, MediaPrefix) path := strings.TrimPrefix(r.URL.Path, mediaPrefix)
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
filePath = strings.TrimPrefix(filePath, "/") path = strings.TrimPrefix(path, "/")
} }
exists, err := fileExists(filePath) exists, err := fileExists(path)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -229,12 +227,12 @@ func serveMedia(paths []string, Regexes *Regexes, index *FileIndex, formats *typ
return return
} }
if !exists { if !exists {
notFound(w, r, filePath) notFound(w, r, path)
return return
} }
registered, fileType, mimeType, err := types.FileType(filePath, formats) registered, fileType, mimeType, err := formats.FileType(path)
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
@ -244,14 +242,14 @@ func serveMedia(paths []string, Regexes *Regexes, index *FileIndex, formats *typ
} }
if !registered { if !registered {
notFound(w, r, filePath) notFound(w, r, path)
return return
} }
fileUri := generateFileUri(filePath) fileUri := generateFileUri(path)
fileName := filepath.Base(filePath) fileName := filepath.Base(path)
w.Header().Add("Content-Type", "text/html") w.Header().Add("Content-Type", "text/html")
@ -261,16 +259,16 @@ func serveMedia(paths []string, Regexes *Regexes, index *FileIndex, formats *typ
var htmlBody strings.Builder var htmlBody strings.Builder
htmlBody.WriteString(`<!DOCTYPE html><html lang="en"><head>`) htmlBody.WriteString(`<!DOCTYPE html><html lang="en"><head>`)
htmlBody.WriteString(FaviconHtml) htmlBody.WriteString(faviconHtml)
htmlBody.WriteString(fmt.Sprintf(`<style>%s</style>`, fileType.Css())) htmlBody.WriteString(fmt.Sprintf(`<style>%s</style>`, fileType.Css()))
htmlBody.WriteString((fileType.Title(queryParams, fileUri, filePath, fileName, mimeType))) htmlBody.WriteString((fileType.Title(queryParams, fileUri, path, fileName, mimeType)))
htmlBody.WriteString(`</head><body>`) htmlBody.WriteString(`</head><body>`)
if refreshInterval != "0ms" { if refreshInterval != "0ms" {
htmlBody.WriteString(fmt.Sprintf("<script>window.onload = function(){setInterval(function(){window.location.href = '/%s';}, %d);};</script>", htmlBody.WriteString(fmt.Sprintf("<script>window.onload = function(){setInterval(function(){window.location.href = '/%s';}, %d);};</script>",
queryParams, queryParams,
refreshTimer)) refreshTimer))
} }
htmlBody.WriteString((fileType.Body(queryParams, fileUri, filePath, fileName, mimeType))) htmlBody.WriteString((fileType.Body(queryParams, fileUri, path, fileName, mimeType)))
htmlBody.WriteString(`</body></html>`) htmlBody.WriteString(`</body></html>`)
_, err = io.WriteString(w, gohtml.Format(htmlBody.String())) _, err = io.WriteString(w, gohtml.Format(htmlBody.String()))
@ -314,33 +312,31 @@ func ServePage(args []string) error {
return errors.New("invalid bind address provided") return errors.New("invalid bind address provided")
} }
mux := httprouter.New()
formats := &types.Types{ formats := &types.Types{
Extensions: make(map[string]string), Extensions: make(map[string]string),
MimeTypes: make(map[string]types.Type), MimeTypes: make(map[string]types.Type),
} }
if Audio || All { if Audio || All {
formats.Add(audio.Format{}) formats.Add(audio.New())
} }
if Flash || All { if Flash || All {
formats.Add(flash.Format{}) formats.Add(flash.New())
} }
if Text || All { if Text || All {
formats.Add(text.Format{}) formats.Add(text.New())
} }
if Videos || All { if Videos || All {
formats.Add(video.Format{}) formats.Add(video.New())
} }
// enable image support if no other flags are passed, to retain backwards compatibility // enable image support if no other flags are passed, to retain backwards compatibility
// to be replaced with rootCmd.MarkFlagsOneRequired on next spf13/cobra update // to be replaced with rootCmd.MarkFlagsOneRequired on next spf13/cobra update
if Images || All || len(formats.Extensions) == 0 { if Images || All || len(formats.Extensions) == 0 {
formats.Add(images.Format{}) formats.Add(images.New())
} }
paths, err := normalizePaths(args, formats) paths, err := normalizePaths(args, formats)
@ -352,20 +348,18 @@ func ServePage(args []string) error {
return ErrNoMediaFound return ErrNoMediaFound
} }
if Russian { cache := &fileCache{
fmt.Printf("WARNING! Files *will* be deleted after serving!\n\n")
}
index := &FileIndex{
mutex: sync.RWMutex{}, mutex: sync.RWMutex{},
list: []string{}, list: []string{},
} }
regexes := &Regexes{ regexes := &regexes{
filename: regexp.MustCompile(`(.+)([0-9]{3})(\..+)`), filename: regexp.MustCompile(`(.+)([0-9]{3})(\..+)`),
alphanumeric: regexp.MustCompile(`^[A-z0-9]*$`), alphanumeric: regexp.MustCompile(`^[A-z0-9]*$`),
} }
mux := httprouter.New()
srv := &http.Server{ srv := &http.Server{
Addr: net.JoinHostPort(Bind, strconv.Itoa(int(Port))), Addr: net.JoinHostPort(Bind, strconv.Itoa(int(Port))),
Handler: mux, Handler: mux,
@ -374,7 +368,7 @@ func ServePage(args []string) error {
WriteTimeout: 5 * time.Minute, WriteTimeout: 5 * time.Minute,
} }
stats := &ServeStats{ stats := &serveStats{
mutex: sync.RWMutex{}, mutex: sync.RWMutex{},
list: []string{}, list: []string{},
count: make(map[string]uint32), count: make(map[string]uint32),
@ -384,65 +378,45 @@ func ServePage(args []string) error {
mux.PanicHandler = serverErrorHandler() mux.PanicHandler = serverErrorHandler()
mux.GET("/", serveRoot(paths, regexes, index, formats)) mux.GET("/", serveRoot(paths, regexes, cache, formats))
mux.GET("/favicons/*favicon", serveFavicons()) mux.GET("/favicons/*favicon", serveFavicons())
mux.GET("/favicon.ico", serveFavicons()) mux.GET("/favicon.ico", serveFavicons())
mux.GET(MediaPrefix+"/*media", serveMedia(paths, regexes, index, formats)) mux.GET(mediaPrefix+"/*media", serveMedia(paths, regexes, formats))
mux.GET(SourcePrefix+"/*static", serveStaticFile(paths, stats, index)) mux.GET(sourcePrefix+"/*static", serveStaticFile(paths, stats, cache))
mux.GET("/version", serveVersion()) mux.GET("/version", serveVersion())
if Cache { if Cache {
skipIndex := false registerCacheHandlers(mux, args, cache, formats)
if CacheFile != "" {
err := index.Import(CacheFile)
if err == nil {
skipIndex = true
}
}
if !skipIndex {
index.generateCache(args, formats)
}
mux.GET("/clear_cache", serveCacheClear(args, index, formats))
} }
if Info { if Info {
if Cache { registerInfoHandlers(mux, args, cache, formats)
mux.GET("/html/", serveIndexHtml(args, index, false))
if PageLength != 0 {
mux.GET("/html/:page", serveIndexHtml(args, index, true))
}
mux.GET("/json", serveIndexJson(args, index))
if PageLength != 0 {
mux.GET("/json/:page", serveIndexJson(args, index))
}
}
mux.GET("/available_extensions", serveAvailableExtensions())
mux.GET("/enabled_extensions", serveEnabledExtensions(formats))
mux.GET("/available_mime_types", serveAvailableMimeTypes())
mux.GET("/enabled_mime_types", serveEnabledMimeTypes(formats))
} }
if Profile { if Profile {
mux.HandlerFunc("GET", "/debug/pprof/", pprof.Index) registerProfileHandlers(mux)
mux.HandlerFunc("GET", "/debug/pprof/cmdline", pprof.Cmdline) }
mux.HandlerFunc("GET", "/debug/pprof/profile", pprof.Profile)
mux.HandlerFunc("GET", "/debug/pprof/symbol", pprof.Symbol) if Russian {
mux.HandlerFunc("GET", "/debug/pprof/trace", pprof.Trace) fmt.Printf("WARNING! Files *will* be deleted after serving!\n\n")
} }
if Statistics { if Statistics {
if StatisticsFile != "" { if StatisticsFile != "" {
stats.Import(StatisticsFile) StatisticsFile, err = normalizePath(StatisticsFile)
if err != nil {
return err
}
err := stats.importFile(StatisticsFile)
if err != nil {
return err
}
gracefulShutdown := make(chan os.Signal, 1) gracefulShutdown := make(chan os.Signal, 1)
signal.Notify(gracefulShutdown, syscall.SIGINT, syscall.SIGTERM) signal.Notify(gracefulShutdown, syscall.SIGINT, syscall.SIGTERM)
@ -450,16 +424,13 @@ func ServePage(args []string) error {
go func() { go func() {
<-gracefulShutdown <-gracefulShutdown
stats.Export(StatisticsFile) stats.exportFile(StatisticsFile)
os.Exit(0) os.Exit(0)
}() }()
} }
mux.GET("/stats", serveStats(args, stats)) registerStatsHandlers(mux, args, stats)
if PageLength != 0 {
mux.GET("/stats/:page", serveStats(args, stats))
}
} }
err = srv.ListenAndServe() err = srv.ListenAndServe()

10
types/audio/audio.go
View File

@ -57,8 +57,10 @@ func (t Format) Validate(filePath string) bool {
return true return true
} }
func init() { func New() Format {
format := Format{} return Format{}
}
types.Register(format)
func init() {
types.SupportedFormats.Register(New())
} }

10
types/flash/flash.go
View File

@ -51,8 +51,10 @@ func (t Format) Validate(filePath string) bool {
return true return true
} }
func init() { func New() Format {
format := Format{} return Format{}
}
types.Register(format)
func init() {
types.SupportedFormats.Register(New())
} }

10
types/images/images.go
View File

@ -123,8 +123,10 @@ func ImageDimensions(path string) (*dimensions, error) {
return &dimensions{width: decodedConfig.Width, height: decodedConfig.Height}, nil return &dimensions{width: decodedConfig.Width, height: decodedConfig.Height}, nil
} }
func init() { func New() Format {
format := Format{} return Format{}
}
types.Register(format)
func init() {
types.SupportedFormats.Register(New())
} }

10
types/text/text.go
View File

@ -85,8 +85,10 @@ func (t Format) Validate(filePath string) bool {
return utf8.Valid(head) return utf8.Valid(head)
} }
func init() { func New() Format {
format := Format{} return Format{}
}
types.Register(format)
func init() {
types.SupportedFormats.Register(New())
} }

30
types/types.go
View File

@ -32,23 +32,23 @@ type Types struct {
MimeTypes map[string]Type MimeTypes map[string]Type
} }
func (s *Types) Add(t Type) { func (t *Types) Add(format Type) {
for k, v := range t.Extensions() { for k, v := range format.Extensions() {
_, exists := s.Extensions[k] _, exists := t.Extensions[k]
if !exists { if !exists {
s.Extensions[k] = v t.Extensions[k] = v
} }
} }
for _, v := range t.MimeTypes() { for _, v := range format.MimeTypes() {
_, exists := s.Extensions[v] _, exists := t.Extensions[v]
if !exists { if !exists {
s.MimeTypes[v] = t t.MimeTypes[v] = format
} }
} }
} }
func FileType(path string, registeredFormats *Types) (bool, Type, string, error) { func (t *Types) FileType(path string) (bool, Type, string, error) {
file, err := os.Open(path) file, err := os.Open(path)
switch { switch {
case errors.Is(err, os.ErrNotExist): case errors.Is(err, os.ErrNotExist):
@ -64,15 +64,15 @@ func FileType(path string, registeredFormats *Types) (bool, Type, string, error)
mimeType := http.DetectContentType(head) mimeType := http.DetectContentType(head)
// try identifying files by mime types first // try identifying files by mime types first
fileType, exists := registeredFormats.MimeTypes[mimeType] fileType, exists := t.MimeTypes[mimeType]
if exists { if exists {
return fileType.Validate(path), fileType, mimeType, nil return fileType.Validate(path), fileType, mimeType, nil
} }
// if mime type detection fails, use the file extension // if mime type detection fails, use the file extension
mimeType, exists = registeredFormats.Extensions[filepath.Ext(path)] mimeType, exists = t.Extensions[filepath.Ext(path)]
if exists { if exists {
fileType, exists := registeredFormats.MimeTypes[mimeType] fileType, exists := t.MimeTypes[mimeType]
if exists { if exists {
return fileType.Validate(path), fileType, mimeType, nil return fileType.Validate(path), fileType, mimeType, nil
@ -82,11 +82,11 @@ func FileType(path string, registeredFormats *Types) (bool, Type, string, error)
return false, nil, "", nil return false, nil, "", nil
} }
func Register(t Type) { func (t *Types) Register(format Type) {
SupportedFormats.Add(t) t.Add(format)
} }
func (t Types) GetExtensions() string { func (t *Types) GetExtensions() string {
var output strings.Builder var output strings.Builder
extensions := make([]string, len(t.Extensions)) extensions := make([]string, len(t.Extensions))
@ -107,7 +107,7 @@ func (t Types) GetExtensions() string {
return output.String() return output.String()
} }
func (t Types) GetMimeTypes() string { func (t *Types) GetMimeTypes() string {
var output strings.Builder var output strings.Builder
mimeTypes := make([]string, len(t.MimeTypes)) mimeTypes := make([]string, len(t.MimeTypes))

10
types/video/video.go
View File

@ -57,8 +57,10 @@ func (t Format) Validate(filePath string) bool {
return true return true
} }
func init() { func New() Format {
format := Format{} return Format{}
}
types.Register(format)
func init() {
types.SupportedFormats.Register(New())
} }