sovonegr/TorrServerJellyfin
1
0
Fork 0
mirror of https://github.com/Ernous/TorrServerJellyfin.git synced 2025-12-19 13:36:09 +05:00
Code Issues Packages Projects Releases Wiki Activity

set disk cache as mem cache

Browse Source
This commit is contained in:
YouROK
2021-06-01 12:11:47 +03:00
parent 21d98d0e2e
commit 789cb8f072
4 changed files with 60 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

79
server/torr/storage/torrstor/cache.go
View File

@@ -1,11 +1,9 @@
package torrstor
import (
"io/ioutil"
"os"
"path/filepath"
"sort"
"strconv"
"sync"
"time"
@@ -76,21 +74,6 @@ func (c *Cache) Init(info *metainfo.Info, hash metainfo.Hash) {
for i := 0; i < c.pieceCount; i++ {
c.pieces[i] = NewPiece(i, c)
}
if settings.BTsets.UseDisk {
name := filepath.Join(settings.BTsets.TorrentsSavePath, hash.HexString())
fs, err := ioutil.ReadDir(name)
if err == nil {
for _, f := range fs {
id, err := strconv.Atoi(f.Name())
if err == nil {
c.pieces[id].Size = f.Size()
c.pieces[id].Complete = f.Size() == c.pieceLength
c.pieces[id].Accessed = f.ModTime().Unix()
}
}
}
}
}
func (c *Cache) SetTorrent(torr *torrent.Torrent) {
@@ -274,68 +257,6 @@ func (c *Cache) isIdInFileBE(ranges []Range, id int) bool {
return false
}
// run only in cache on disk
func (c *Cache) LoadPiecesOnDisk() {
if c.torrent == nil || !settings.BTsets.UseDisk {
return
}
if c.isRemove {
return
}
c.muRemove.Lock()
if c.isRemove {
c.muRemove.Unlock()
return
}
c.isRemove = true
defer func() { c.isRemove = false }()
c.muRemove.Unlock()
ranges := make([]Range, 0)
c.muReaders.Lock()
for r, _ := range c.readers {
ranges = append(ranges, r.getPiecesRange())
}
c.muReaders.Unlock()
ranges = mergeRange(ranges)
for r, _ := range c.readers {
pc := r.getReaderPiece()
limit := 5
for limit > 0 {
if c.pieces != nil && c.pieces[pc] != nil && !c.pieces[pc].Complete {
if c.torrent.PieceState(pc).Priority == torrent.PiecePriorityNone {
c.torrent.Piece(pc).SetPriority(torrent.PiecePriorityNormal)
}
limit--
}
pc++
}
}
if len(c.readers) == 0 {
limit := 5
pc := 0
end := c.pieceCount
for pc <= end {
if c.pieces != nil && c.pieces[pc] != nil && !c.pieces[pc].Complete {
break
}
pc++
}
for pc <= end && limit > 0 {
if c.pieces != nil && c.pieces[pc] != nil && !c.pieces[pc].Complete {
if c.torrent.PieceState(pc).Priority == torrent.PiecePriorityNone {
c.torrent.Piece(pc).SetPriority(torrent.PiecePriorityNormal)
}
limit--
}
pc++
}
}
}
//////////////////
// Reader section
////////

52
server/torr/storage/torrstor/diskpiece.go
View File

@@ -1,12 +1,15 @@
package torrstor
import (
"io"
"os"
"path/filepath"
"strconv"
"sync"
"time"
"github.com/anacrolix/torrent"
"server/log"
"server/settings"
)
@@ -14,29 +17,35 @@ import (
type DiskPiece struct {
piece *Piece
file *os.File
name string
mu sync.RWMutex
}
func NewDiskPiece(p *Piece) *DiskPiece {
name := filepath.Join(settings.BTsets.TorrentsSavePath, p.cache.hash.HexString(), strconv.Itoa(p.Id))
ff, err := os.OpenFile(name, os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
log.TLogln("Error open file:", err)
return nil
ff, err := os.Stat(name)
if err == nil {
p.Size = ff.Size()
p.Complete = ff.Size() == p.cache.pieceLength
p.Accessed = ff.ModTime().Unix()
}
return &DiskPiece{piece: p, file: ff}
return &DiskPiece{piece: p, name: name}
}
func (p *DiskPiece) WriteAt(b []byte, off int64) (n int, err error) {
p.mu.Lock()
defer p.mu.Unlock()
n, err = p.file.WriteAt(b, off)
go p.piece.cache.LoadPiecesOnDisk()
ff, err := os.OpenFile(p.name, os.O_RDWR|os.O_CREATE, 0666)
if err != nil {
log.TLogln("Error open file:", err)
return 0, err
}
defer ff.Close()
n, err = ff.WriteAt(b, off)
p.piece.Size += int64(n)
if p.piece.Size > p.piece.cache.pieceLength {
p.piece.Size = p.piece.cache.pieceLength
}
@@ -48,12 +57,33 @@ func (p *DiskPiece) ReadAt(b []byte, off int64) (n int, err error) {
p.mu.Lock()
defer p.mu.Unlock()
n, err = p.file.ReadAt(b, off)
ff, err := os.OpenFile(p.name, os.O_RDONLY, 0666)
if os.IsNotExist(err) {
return 0, io.EOF
}
if err != nil {
log.TLogln("Error open file:", err)
return 0, err
}
defer ff.Close()
n, err = ff.ReadAt(b, off)
p.piece.Accessed = time.Now().Unix()
if int64(len(b))+off >= p.piece.Size {
go p.piece.cache.cleanPieces()
}
return n, nil
}
func (p *DiskPiece) Release() {
p.file.Close()
p.mu.Lock()
defer p.mu.Unlock()
p.piece.Size = 0
p.piece.Complete = false
os.Remove(p.name)
p.piece.cache.torrent.Piece(p.piece.Id).SetPriority(torrent.PiecePriorityNone)
}