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:173e1528be116f7f8d9520f27eb732bda4f35fa5
Branches Tags
SeanOMik:master
..
compare: SeanOMik:16d1428a52f9ed51d7058b24a0fc20a98641f8f4
Branches Tags
SeanOMik:master

No commits in common. "173e1528be116f7f8d9520f27eb732bda4f35fa5" and "16d1428a52f9ed51d7058b24a0fc20a98641f8f4" have entirely different histories.
173e1528be ... 16d1428a52

4 changed files with 88 additions and 119 deletions
Show Stats Expand all files Collapse all files

158
cmd/files.go
View File

@ -13,6 +13,7 @@ import (
"crypto/rand"
"os"
"path/filepath"
"runtime"
"strconv"
"strings"
"sync"
@ -34,6 +35,11 @@ type regexes struct {
filename *regexp.Regexp
}
type concurrency struct {
directoryScans chan int
fileScans chan int
}
type scanStats struct {
filesMatched int
filesSkipped int
@ -41,13 +47,6 @@ type scanStats struct {
directoriesSkipped int
}
type scanStatsChannels struct {
filesMatched chan int
filesSkipped chan int
directoriesMatched chan int
directoriesSkipped chan int
}
type splitPath struct {
base string
number int
@ -93,30 +92,16 @@ func kill(path string, cache *fileCache) error {
return nil
}
func split(path string, regexes *regexes) (*splitPath, error) {
p := splitPath{}
var err error
split := regexes.filename.FindAllStringSubmatch(path, -1)
if len(split) < 1 || len(split[0]) < 3 {
return &splitPath{}, nil
func preparePath(path string) string {
if runtime.GOOS == "windows" {
return fmt.Sprintf("%s/%s", mediaPrefix, filepath.ToSlash(path))
}
p.base = split[0][1]
p.number, err = strconv.Atoi(split[0][2])
if err != nil {
return &splitPath{}, err
}
p.extension = split[0][3]
return &p, nil
return mediaPrefix + path
}
func newFile(list []string, sortOrder string, regexes *regexes, formats *types.Types) (string, error) {
path, err := pickFile(list)
func newFile(paths []string, filters *filters, sortOrder string, regexes *regexes, cache *fileCache, formats *types.Types) (string, error) {
path, err := pickFile(paths, filters, sortOrder, cache, formats)
if err != nil {
return "", err
}
@ -182,6 +167,28 @@ func nextFile(path, sortOrder string, regexes *regexes, formats *types.Types) (s
return fileName, err
}
func split(path string, regexes *regexes) (*splitPath, error) {
p := splitPath{}
var err error
split := regexes.filename.FindAllStringSubmatch(path, -1)
if len(split) < 1 || len(split[0]) < 3 {
return &splitPath{}, nil
}
p.base = split[0][1]
p.number, err = strconv.Atoi(split[0][2])
if err != nil {
return &splitPath{}, err
}
p.extension = split[0][3]
return &p, nil
}
func tryExtensions(splitPath *splitPath, formats *types.Types) (string, error) {
var fileName string
@ -288,42 +295,49 @@ func pathCount(path string) (int, int, error) {
return files, directories, nil
}
func walkPath(path string, fileChannel chan<- string, fileScans chan int, stats *scanStatsChannels, formats *types.Types) error {
func scanPath(path string, fileChannel chan<- string, statChannel chan<- *scanStats, errorChannel chan<- error, concurrency *concurrency, formats *types.Types) {
var wg sync.WaitGroup
errorChannel := make(chan error)
done := make(chan bool, 1)
stats := &scanStats{
filesMatched: 0,
filesSkipped: 0,
directoriesMatched: 0,
directoriesSkipped: 0,
}
err := filepath.WalkDir(path, func(p string, info os.DirEntry, err error) error {
if err != nil {
return err
}
filepath.WalkDir(path, func(p string, info os.DirEntry, err error) error {
switch {
case !Recursive && info.IsDir() && p != path:
return filepath.SkipDir
case !info.IsDir():
wg.Add(1)
fileScans <- 1
concurrency.fileScans <- 1
go func() {
defer func() {
<-concurrency.fileScans
wg.Done()
<-fileScans
}()
path, err := normalizePath(p)
if err != nil {
errorChannel <- err
return
}
if !formats.Validate(path) {
stats.filesSkipped <- 1
stats.filesSkipped = stats.filesSkipped + 1
return
}
fileChannel <- path
stats.filesMatched <- 1
stats.filesMatched = stats.filesMatched + 1
}()
case info.IsDir():
files, directories, err := pathCount(p)
@ -333,43 +347,33 @@ func walkPath(path string, fileChannel chan<- string, fileScans chan int, stats
if files > 0 && (files < int(MinimumFileCount)) || (files > int(MaximumFileCount)) {
// This count will not otherwise include the parent directory itself, so increment by one
stats.directoriesSkipped <- directories + 1
stats.filesSkipped <- files
stats.directoriesSkipped = stats.directoriesSkipped + directories + 1
stats.filesSkipped = stats.filesSkipped + files
return filepath.SkipDir
}
stats.directoriesMatched <- 1
stats.directoriesMatched = stats.directoriesMatched + 1
}
return nil
return err
})
go func() {
wg.Wait()
done <- true
}()
wg.Wait()
Poll:
for {
select {
case e := <-errorChannel:
return e
case <-done:
break Poll
}
statChannel <- stats
if err != nil {
errorChannel <- err
}
return nil
}
func scanPaths(paths []string, sort string, cache *fileCache, formats *types.Types) ([]string, error) {
var list []string
fileChannel := make(chan string)
statChannel := make(chan *scanStats)
errorChannel := make(chan error)
directoryScans := make(chan int, maxDirectoryScans)
fileScans := make(chan int, maxFileScans)
done := make(chan bool, 1)
stats := &scanStats{
@ -379,11 +383,9 @@ func scanPaths(paths []string, sort string, cache *fileCache, formats *types.Typ
directoriesSkipped: 0,
}
statsChannels := &scanStatsChannels{
filesMatched: make(chan int),
filesSkipped: make(chan int),
directoriesMatched: make(chan int),
directoriesSkipped: make(chan int),
concurrency := &concurrency{
directoryScans: make(chan int, maxDirectoryScans),
fileScans: make(chan int, maxFileScans),
}
var wg sync.WaitGroup
@ -392,20 +394,16 @@ func scanPaths(paths []string, sort string, cache *fileCache, formats *types.Typ
for i := 0; i < len(paths); i++ {
wg.Add(1)
directoryScans <- 1
concurrency.directoryScans <- 1
go func(i int) {
defer func() {
<-concurrency.directoryScans
wg.Done()
<-directoryScans
}()
err := walkPath(paths[i], fileChannel, fileScans, statsChannels, formats)
if err != nil {
errorChannel <- err
return
}
scanPath(paths[i], fileChannel, statChannel, errorChannel, concurrency, formats)
}(i)
}
@ -419,14 +417,11 @@ Poll:
select {
case p := <-fileChannel:
list = append(list, p)
case s := <-statsChannels.filesMatched:
stats.filesMatched = stats.filesMatched + s
case s := <-statsChannels.filesSkipped:
stats.filesSkipped = stats.filesSkipped + s
case s := <-statsChannels.directoriesMatched:
stats.directoriesMatched = stats.directoriesMatched + s
case s := <-statsChannels.directoriesSkipped:
stats.directoriesSkipped = stats.directoriesSkipped + s
case s := <-statChannel:
stats.filesMatched = stats.filesMatched + s.filesMatched
stats.filesSkipped = stats.filesSkipped + s.filesSkipped
stats.directoriesMatched = stats.directoriesMatched + s.directoriesMatched
stats.directoriesSkipped = stats.directoriesSkipped + s.directoriesSkipped
case e := <-errorChannel:
return []string{}, e
case <-done:
@ -492,7 +487,12 @@ func fileList(paths []string, filters *filters, sort string, cache *fileCache, f
}
}
func pickFile(list []string) (string, error) {
func pickFile(args []string, filters *filters, sort string, cache *fileCache, formats *types.Types) (string, error) {
list, err := fileList(args, filters, sort, cache, formats)
if err != nil {
return "", err
}
fileCount := len(list)
if fileCount < 1 {

2
cmd/root.go
View File

@ -11,7 +11,7 @@ import (
)
const (
ReleaseVersion string = "0.91.0"
ReleaseVersion string = "0.90.3"
)
var (

47
cmd/web.go
View File

@ -19,7 +19,6 @@ import (
"strconv"
"strings"
"sync"
"syscall"
"time"
"github.com/julienschmidt/httprouter"
@ -41,14 +40,6 @@ const (
timeout time.Duration = 10 * time.Second
)
func preparePath(path string) string {
if runtime.GOOS == "windows" {
return fmt.Sprintf("%s/%s", mediaPrefix, filepath.ToSlash(path))
}
return mediaPrefix + path
}
func serveStaticFile(paths []string, cache *fileCache, errorChannel chan<- error) httprouter.Handle {
return func(w http.ResponseWriter, r *http.Request, p httprouter.Params) {
prefix := Prefix + sourcePrefix
@ -105,19 +96,7 @@ func serveStaticFile(paths []string, cache *fileCache, errorChannel chan<- error
return
}
var status string
written, err := w.Write(buf)
switch {
case errors.Is(err, syscall.EPIPE):
status = " (incomplete)"
case err != nil:
errorChannel <- err
serverError(w, r, nil)
return
}
written, _ := w.Write(buf)
refererUri, err := stripQueryParams(refererToUri(r.Referer()))
if err != nil {
@ -140,13 +119,12 @@ func serveStaticFile(paths []string, cache *fileCache, errorChannel chan<- error
}
if Verbose {
fmt.Printf("%s | Serve: %s (%s) to %s in %s%s\n",
fmt.Printf("%s | Serve: %s (%s) to %s in %s\n",
startTime.Format(logDate),
filePath,
humanReadableSize(written),
realIP(r),
time.Since(startTime).Round(time.Microsecond),
status,
)
}
}
@ -174,10 +152,10 @@ func serveRoot(paths []string, regexes *regexes, cache *fileCache, formats *type
_, refreshInterval := refreshInterval(r)
var path string
var filePath string
if refererUri != "" {
path, err = nextFile(strippedRefererUri, sortOrder, regexes, formats)
filePath, err = nextFile(strippedRefererUri, sortOrder, regexes, formats)
if err != nil {
errorChannel <- err
@ -187,15 +165,6 @@ func serveRoot(paths []string, regexes *regexes, cache *fileCache, formats *type
}
}
list, err := fileList(paths, filters, sortOrder, cache, formats)
if err != nil {
errorChannel <- err
serverError(w, r, nil)
return
}
loop:
for timeout := time.After(timeout); ; {
select {
@ -204,14 +173,14 @@ func serveRoot(paths []string, regexes *regexes, cache *fileCache, formats *type
default:
}
if path != "" {
if filePath != "" {
break loop
}
path, err = newFile(list, sortOrder, regexes, formats)
filePath, err = newFile(paths, filters, sortOrder, regexes, cache, formats)
switch {
case err != nil && err == ErrNoMediaFound:
notFound(w, r, path)
notFound(w, r, filePath)
return
case err != nil:
@ -228,7 +197,7 @@ func serveRoot(paths []string, regexes *regexes, cache *fileCache, formats *type
newUrl := fmt.Sprintf("http://%s%s%s%s",
r.Host,
Prefix,
preparePath(path),
preparePath(filePath),
queryParams,
)
http.Redirect(w, r, newUrl, RedirectStatusCode)

BIN
default.pgo
View File

Binary file not shown.