refactor and to go mod

2025-12-19 13:36:09 +05:00 · 2021-02-18 16:56:55 +03:00
parent 0e49a98626
commit 94f212fa75
50 changed files with 13 additions and 29 deletions
--- a/server/cmd/main.go
+++ b/server/cmd/main.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"net"
+	"os"
+	"time"
+
+	"github.com/alexflint/go-arg"
+	"github.com/pkg/browser"
+
+	"server"
+	"server/log"
+	"server/settings"
+	"server/version"
+)
+
+type args struct {
+	Port     string `arg:"-p" help:"web server port"`
+	Path     string `arg:"-d" help:"database path"`
+	LogPath  string `arg:"-l" help:"log path"`
+	RDB      bool   `arg:"-r" help:"start in read-only DB mode"`
+	DontKill bool   `arg:"-k" help:"dont kill program on signal"`
+	UI       bool   `arg:"-u" help:"run page torrserver in browser"`
+}
+
+func (args) Version() string {
+	return "TorrServer " + version.Version
+}
+
+var params args
+
+func main() {
+	arg.MustParse(&params)
+
+	if params.Path == "" {
+		params.Path, _ = os.Getwd()
+	}
+
+	if params.Port == "" {
+		params.Port = "8090"
+	}
+
+	settings.Path = params.Path
+	log.Init(params.LogPath)
+
+	dnsResolve()
+	Preconfig(params.DontKill)
+
+	if params.UI {
+		go func() {
+			time.Sleep(time.Second)
+			browser.OpenURL("http://127.0.0.1:" + params.Port)
+		}()
+	}
+
+	server.Start(params.Port, params.RDB)
+	log.TLogln(server.WaitServer())
+	time.Sleep(time.Second * 3)
+	os.Exit(0)
+}
+
+func dnsResolve() {
+	addrs, err := net.LookupHost("www.themoviedb.org")
+	if len(addrs) == 0 {
+		fmt.Println("Check dns", addrs, err)
+
+		fn := func(ctx context.Context, network, address string) (net.Conn, error) {
+			d := net.Dialer{}
+			return d.DialContext(ctx, "udp", "1.1.1.1:53")
+		}
+
+		net.DefaultResolver = &net.Resolver{
+			Dial: fn,
+		}
+
+		addrs, err = net.LookupHost("www.themoviedb.org")
+		fmt.Println("Check new dns", addrs, err)
+	}
+}
--- a/server/cmd/preconfig_pos.go
+++ b/server/cmd/preconfig_pos.go
@@ -0,0 +1,31 @@
+// +build !windows
+
+package main
+
+import (
+	"fmt"
+	"os"
+	"os/signal"
+	"syscall"
+)
+
+func Preconfig(dkill bool) {
+	if dkill {
+		sigc := make(chan os.Signal, 1)
+		signal.Notify(sigc,
+			syscall.SIGHUP,
+			syscall.SIGINT,
+			syscall.SIGSTOP,
+			syscall.SIGPIPE,
+			syscall.SIGTERM,
+			syscall.SIGQUIT)
+		go func() {
+			for s := range sigc {
+				if dkill {
+					fmt.Println("Signal catched:", s)
+					fmt.Println("For stop server, close in api")
+				}
+			}
+		}()
+	}
+}
--- a/server/cmd/preconfig_win.go
+++ b/server/cmd/preconfig_win.go
@@ -0,0 +1,7 @@
+// +build windows
+
+package main
+
+func Preconfig(kill bool) {
+
+}
--- a/server/log/log.go
+++ b/server/log/log.go
@@ -0,0 +1,24 @@
+package log
+
+import (
+	"log"
+	"os"
+)
+
+func Init(path string) {
+	if path != "" {
+		ff, err := os.Create(path)
+		if err != nil {
+			TLogln("Error create log file:", err)
+			return
+		}
+
+		os.Stdout = ff
+		os.Stderr = ff
+		log.SetOutput(ff)
+	}
+}
+
+func TLogln(v ...interface{}) {
+	log.Println(v...)
+}
--- a/server/server.go
+++ b/server/server.go
@@ -0,0 +1,27 @@
+package server
+
+import (
+	"server/settings"
+	"server/web"
+)
+
+func Start(port string, roSets bool) {
+	settings.InitSets(roSets)
+	if port == "" {
+		port = "8090"
+	}
+	web.Start(port)
+}
+
+func WaitServer() string {
+	err := web.Wait()
+	if err != nil {
+		return err.Error()
+	}
+	return ""
+}
+
+func Stop() {
+	web.Stop()
+	settings.CloseDB()
+}
--- a/server/settings/btsets.go
+++ b/server/settings/btsets.go
@@ -0,0 +1,93 @@
+package settings
+
+import (
+	"encoding/json"
+
+	"server/log"
+)
+
+type BTSets struct {
+	// Cache
+	CacheSize       int64 // in byte, def 200 mb
+	PreloadBuffer   bool
+	ReaderReadAHead int // in percent, 5%-100%, [...S__X__E...] [S-E] not clean
+
+	// Storage
+	SaveOnDisk  bool   // save on disk?
+	ContentPath string // path to save content
+
+	// Torrent
+	ForceEncrypt             bool
+	RetrackersMode           int  // 0 - don`t add, 1 - add retrackers (def), 2 - remove retrackers 3 - replace retrackers
+	TorrentDisconnectTimeout int  // in seconds
+	EnableDebug              bool // print logs
+
+	// BT Config
+	EnableIPv6         bool
+	DisableTCP         bool
+	DisableUTP         bool
+	DisableUPNP        bool
+	DisableDHT         bool
+	DisableUpload      bool
+	DownloadRateLimit  int // in kb, 0 - inf
+	UploadRateLimit    int // in kb, 0 - inf
+	ConnectionsLimit   int
+	DhtConnectionLimit int // 0 - inf
+	PeersListenPort    int
+	Strategy           int // 0 - RequestStrategyDuplicateRequestTimeout, 1 - RequestStrategyFuzzing, 2 - RequestStrategyFastest
+}
+
+func (v *BTSets) String() string {
+	buf, _ := json.Marshal(v)
+	return string(buf)
+}
+
+var (
+	BTsets *BTSets
+)
+
+func SetBTSets(sets *BTSets) {
+	if ReadOnly {
+		return
+	}
+
+	if sets.ReaderReadAHead < 5 {
+		sets.ReaderReadAHead = 5
+	}
+	if sets.ReaderReadAHead > 100 {
+		sets.ReaderReadAHead = 100
+	}
+	BTsets = sets
+	buf, err := json.Marshal(BTsets)
+	if err != nil {
+		log.TLogln("Error marshal btsets", err)
+		return
+	}
+	tdb.Set("Settings", "BitTorr", buf)
+}
+
+func loadBTSets() {
+	buf := tdb.Get("Settings", "BitTorr")
+	if len(buf) > 0 {
+		err := json.Unmarshal(buf, &BTsets)
+		if err == nil {
+			if BTsets.ReaderReadAHead < 5 {
+				BTsets.ReaderReadAHead = 5
+			}
+			return
+		}
+		log.TLogln("Error unmarshal btsets", err)
+	}
+
+	sets := new(BTSets)
+	sets.EnableDebug = false
+	sets.DisableUTP = true
+	sets.CacheSize = 200 * 1024 * 1024 // 200mb
+	sets.PreloadBuffer = false
+	sets.ConnectionsLimit = 20
+	sets.DhtConnectionLimit = 500
+	sets.RetrackersMode = 1
+	sets.TorrentDisconnectTimeout = 30
+	sets.ReaderReadAHead = 70 // 70% preload
+	BTsets = sets
+}
--- a/server/settings/db.go
+++ b/server/settings/db.go
@@ -0,0 +1,177 @@
+package settings
+
+import (
+	"path/filepath"
+	"strings"
+
+	bolt "go.etcd.io/bbolt"
+	"server/log"
+)
+
+type TDB struct {
+	Path string
+	db   *bolt.DB
+}
+
+func NewTDB() *TDB {
+	db, err := bolt.Open(filepath.Join(Path, "config.db"), 0666, nil)
+	if err != nil {
+		log.TLogln(err)
+		return nil
+	}
+
+	tdb := new(TDB)
+	tdb.db = db
+	tdb.Path = Path
+	return tdb
+}
+
+func (v *TDB) CloseDB() {
+	if v.db != nil {
+		v.db.Close()
+		v.db = nil
+	}
+}
+
+func (v *TDB) Get(xpath, name string) []byte {
+	spath := strings.Split(xpath, "/")
+	if len(spath) == 0 {
+		return nil
+	}
+	var ret []byte
+	err := v.db.View(func(tx *bolt.Tx) error {
+		buckt := tx.Bucket([]byte(spath[0]))
+		if buckt == nil {
+			return nil
+		}
+
+		for i, p := range spath {
+			if i == 0 {
+				continue
+			}
+			buckt = buckt.Bucket([]byte(p))
+			if buckt == nil {
+				return nil
+			}
+		}
+
+		ret = buckt.Get([]byte(name))
+		return nil
+	})
+
+	if err != nil {
+		log.TLogln("Error get sets", xpath+"/"+name, ", error:", err)
+	}
+
+	return ret
+}
+
+func (v *TDB) Set(xpath, name string, value []byte) {
+	if ReadOnly {
+		return
+	}
+
+	spath := strings.Split(xpath, "/")
+	if len(spath) == 0 {
+		return
+	}
+	err := v.db.Update(func(tx *bolt.Tx) error {
+		buckt, err := tx.CreateBucketIfNotExists([]byte(spath[0]))
+		if err != nil {
+			return err
+		}
+
+		for i, p := range spath {
+			if i == 0 {
+				continue
+			}
+			buckt, err = buckt.CreateBucketIfNotExists([]byte(p))
+			if err != nil {
+				return err
+			}
+		}
+
+		return buckt.Put([]byte(name), value)
+	})
+
+	if err != nil {
+		log.TLogln("Error put sets", xpath+"/"+name, ", error:", err)
+		log.TLogln("value:", value)
+	}
+
+	return
+}
+
+func (v *TDB) List(xpath string) []string {
+	spath := strings.Split(xpath, "/")
+	if len(spath) == 0 {
+		return nil
+	}
+	var ret []string
+	err := v.db.View(func(tx *bolt.Tx) error {
+		buckt := tx.Bucket([]byte(spath[0]))
+		if buckt == nil {
+			return nil
+		}
+
+		for i, p := range spath {
+			if i == 0 {
+				continue
+			}
+			buckt = buckt.Bucket([]byte(p))
+			if buckt == nil {
+				return nil
+			}
+		}
+
+		buckt.ForEach(func(k, _ []byte) error {
+			if len(k) > 0 {
+				ret = append(ret, string(k))
+			}
+			return nil
+		})
+
+		return nil
+	})
+
+	if err != nil {
+		log.TLogln("Error list sets", xpath, ", error:", err)
+	}
+
+	return ret
+}
+
+func (v *TDB) Rem(xpath, name string) {
+	if ReadOnly {
+		return
+	}
+
+	spath := strings.Split(xpath, "/")
+	if len(spath) == 0 {
+		return
+	}
+	err := v.db.Update(func(tx *bolt.Tx) error {
+		buckt := tx.Bucket([]byte(spath[0]))
+		if buckt == nil {
+			return nil
+		}
+
+		for i, p := range spath {
+			if i == 0 {
+				continue
+			}
+			buckt = buckt.Bucket([]byte(p))
+			if buckt == nil {
+				return nil
+			}
+		}
+
+		return buckt.Delete([]byte(name))
+	})
+
+	if err != nil {
+		log.TLogln("Error rem sets", xpath+"/"+name, ", error:", err)
+	}
+
+	return
+}
--- a/server/settings/migrate.go
+++ b/server/settings/migrate.go
@@ -0,0 +1,104 @@
+package settings
+
+import (
+	"encoding/binary"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	bolt "go.etcd.io/bbolt"
+	"server/web/api/utils"
+)
+
+var (
+	dbTorrentsName = []byte("Torrents")
+)
+
+type torrentOldDB struct {
+	Name      string
+	Magnet    string
+	InfoBytes []byte
+	Hash      string
+	Size      int64
+	Timestamp int64
+}
+
+func Migrate() {
+	if _, err := os.Lstat(filepath.Join(Path, "torrserver.db")); os.IsNotExist(err) {
+		return
+	}
+
+	db, err := bolt.Open(filepath.Join(Path, "torrserver.db"), 0666, nil)
+	if err != nil {
+		return
+	}
+
+	torrs := make([]*torrentOldDB, 0)
+	err = db.View(func(tx *bolt.Tx) error {
+		tdb := tx.Bucket(dbTorrentsName)
+		if tdb == nil {
+			return nil
+		}
+		c := tdb.Cursor()
+		for h, _ := c.First(); h != nil; h, _ = c.Next() {
+			hdb := tdb.Bucket(h)
+			if hdb != nil {
+				torr := new(torrentOldDB)
+				torr.Hash = string(h)
+				tmp := hdb.Get([]byte("Name"))
+				if tmp == nil {
+					return fmt.Errorf("error load torrent")
+				}
+				torr.Name = string(tmp)
+
+				tmp = hdb.Get([]byte("Link"))
+				if tmp == nil {
+					return fmt.Errorf("error load torrent")
+				}
+				torr.Magnet = string(tmp)
+
+				tmp = hdb.Get([]byte("Size"))
+				if tmp == nil {
+					return fmt.Errorf("error load torrent")
+				}
+				torr.Size = b2i(tmp)
+
+				tmp = hdb.Get([]byte("Timestamp"))
+				if tmp == nil {
+					return fmt.Errorf("error load torrent")
+				}
+				torr.Timestamp = b2i(tmp)
+
+				torrs = append(torrs, torr)
+			}
+		}
+		return nil
+	})
+	db.Close()
+	if err == nil && len(torrs) > 0 {
+		for _, torr := range torrs {
+			spec, err := utils.ParseLink(torr.Magnet)
+			if err != nil {
+				continue
+			}
+
+			title := torr.Name
+			if len(spec.DisplayName) > len(title) {
+				title = spec.DisplayName
+			}
+
+			AddTorrent(&TorrentDB{
+				TorrentSpec: spec,
+				Name:        torr.Name,
+				Title:       title,
+				Timestamp:   torr.Timestamp,
+				Size:        torr.Size,
+			})
+		}
+	}
+	os.Remove(filepath.Join(Path, "torrserver.db"))
+}
+
+func b2i(v []byte) int64 {
+	return int64(binary.BigEndian.Uint64(v))
+}
--- a/server/settings/settings.go
+++ b/server/settings/settings.go
@@ -0,0 +1,18 @@
+package settings
+
+var (
+	tdb      *TDB
+	Path     string
+	ReadOnly bool
+)
+
+func InitSets(readOnly bool) {
+	ReadOnly = readOnly
+	tdb = NewTDB()
+	loadBTSets()
+	Migrate()
+}
+
+func CloseDB() {
+	tdb.CloseDB()
+}
--- a/server/settings/torrent.go
+++ b/server/settings/torrent.go
@@ -0,0 +1,82 @@
+package settings
+
+import (
+	"encoding/json"
+	"sort"
+	"sync"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+)
+
+type TorrentDB struct {
+	*torrent.TorrentSpec
+
+	Name   string `json:"name"`
+	Title  string `json:"title,omitempty"`
+	Poster string `json:"poster,omitempty"`
+	Data   string `json:"data,omitempty"`
+
+	Timestamp int64 `json:"timestamp,omitempty"`
+	Size      int64 `json:"size,omitempty"`
+}
+
+type File struct {
+	Name string `json:"name,omitempty"`
+	Id   int    `json:"id,omitempty"`
+	Size int64  `json:"size,omitempty"`
+}
+
+var mu sync.Mutex
+
+func AddTorrent(torr *TorrentDB) {
+	list := ListTorrent()
+	mu.Lock()
+	find := -1
+	for i, db := range list {
+		if db.InfoHash.HexString() == torr.InfoHash.HexString() {
+			find = i
+			break
+		}
+	}
+	if find != -1 {
+		list[find] = torr
+	} else {
+		list = append(list, torr)
+	}
+	for _, db := range list {
+		buf, err := json.Marshal(db)
+		if err == nil {
+			tdb.Set("Torrents", db.InfoHash.HexString(), buf)
+		}
+	}
+	mu.Unlock()
+}
+
+func ListTorrent() []*TorrentDB {
+	mu.Lock()
+	defer mu.Unlock()
+
+	var list []*TorrentDB
+	keys := tdb.List("Torrents")
+	for _, key := range keys {
+		buf := tdb.Get("Torrents", key)
+		if len(buf) > 0 {
+			var torr *TorrentDB
+			err := json.Unmarshal(buf, &torr)
+			if err == nil {
+				list = append(list, torr)
+			}
+		}
+	}
+	sort.Slice(list, func(i, j int) bool {
+		return list[i].Timestamp > list[j].Timestamp
+	})
+	return list
+}
+
+func RemTorrent(hash metainfo.Hash) {
+	mu.Lock()
+	tdb.Rem("Torrents", hash.HexString())
+	mu.Unlock()
+}
--- a/server/settings/viewed.go
+++ b/server/settings/viewed.go
@@ -0,0 +1,96 @@
+package settings
+
+import (
+	"encoding/json"
+
+	"server/log"
+)
+
+type Viewed struct {
+	Hash      string `json:"hash"`
+	FileIndex int    `json:"file_index"`
+}
+
+func SetViewed(vv *Viewed) {
+	var indexes map[int]struct{}
+	var err error
+
+	buf := tdb.Get("Viewed", vv.Hash)
+	if len(buf) == 0 {
+		indexes = make(map[int]struct{})
+		indexes[vv.FileIndex] = struct{}{}
+		buf, err = json.Marshal(indexes)
+		if err == nil {
+			tdb.Set("Viewed", vv.Hash, buf)
+		}
+	} else {
+		err = json.Unmarshal(buf, &indexes)
+		if err == nil {
+			indexes[vv.FileIndex] = struct{}{}
+			buf, err = json.Marshal(indexes)
+			if err == nil {
+				tdb.Set("Viewed", vv.Hash, buf)
+			}
+		}
+	}
+	if err != nil {
+		log.TLogln("Error set viewed:", err)
+	}
+}
+
+func RemViewed(vv *Viewed) {
+	buf := tdb.Get("Viewed", vv.Hash)
+	var indeces map[int]struct{}
+	err := json.Unmarshal(buf, &indeces)
+	if err == nil {
+		delete(indeces, vv.FileIndex)
+		buf, err = json.Marshal(indeces)
+		if err == nil {
+			tdb.Set("Viewed", vv.Hash, buf)
+		}
+	}
+	if err != nil {
+		log.TLogln("Error rem viewed:", err)
+	}
+}
+
+func ListViewed(hash string) []*Viewed {
+	var err error
+	if hash != "" {
+		buf := tdb.Get("Viewed", hash)
+		if len(buf) == 0 {
+			return []*Viewed{}
+		}
+		var indeces map[int]struct{}
+		err = json.Unmarshal(buf, &indeces)
+		if err == nil {
+			var ret []*Viewed
+			for i, _ := range indeces {
+				ret = append(ret, &Viewed{hash, i})
+			}
+			return ret
+		}
+	} else {
+		var ret []*Viewed
+		keys := tdb.List("Viewed")
+		for _, key := range keys {
+			buf := tdb.Get("Viewed", key)
+			if len(buf) == 0 {
+				return []*Viewed{}
+			}
+			var indeces map[int]struct{}
+			err = json.Unmarshal(buf, &indeces)
+			if err == nil {
+				for i, _ := range indeces {
+					ret = append(ret, &Viewed{key, i})
+				}
+			}
+		}
+		return ret
+	}
+
+	if err != nil {
+		log.TLogln("Error list viewed:", err)
+	}
+	return []*Viewed{}
+}
--- a/server/torr/apihelper.go
+++ b/server/torr/apihelper.go
@@ -0,0 +1,151 @@
+package torr
+
+import (
+	"io"
+	"os"
+	"sort"
+	"time"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+	"server/log"
+	sets "server/settings"
+)
+
+var (
+	bts *BTServer
+)
+
+func InitApiHelper(bt *BTServer) {
+	bts = bt
+}
+
+func AddTorrent(spec *torrent.TorrentSpec, title, poster string, data string) (*Torrent, error) {
+	torr, err := NewTorrent(spec, bts)
+	if err != nil {
+		log.TLogln("error add torrent:", err)
+		return nil, err
+	}
+
+	torDB := GetTorrentDB(spec.InfoHash)
+
+	if torr.Title == "" {
+		torr.Title = title
+		if title == "" && torDB != nil {
+			torr.Title = torDB.Title
+		}
+	}
+	if torr.Poster == "" {
+		torr.Poster = poster
+		if torr.Poster == "" && torDB != nil {
+			torr.Poster = torDB.Poster
+		}
+	}
+	if torr.Data == "" {
+		torr.Data = data
+		if torr.Data == "" && torDB != nil {
+			torr.Data = torDB.Data
+		}
+	}
+
+	return torr, nil
+}
+
+func SaveTorrentToDB(torr *Torrent) {
+	log.TLogln("save to db:", torr.Hash())
+	AddTorrentDB(torr)
+}
+
+func GetTorrent(hashHex string) *Torrent {
+	hash := metainfo.NewHashFromHex(hashHex)
+	tor := bts.GetTorrent(hash)
+	if tor != nil {
+		tor.AddExpiredTime(time.Minute)
+		return tor
+	}
+
+	tr := GetTorrentDB(hash)
+	if tr != nil {
+		tor = tr
+		go func() {
+			tr, _ := NewTorrent(tor.TorrentSpec, bts)
+			if tr != nil {
+				tr.Title = tor.Title
+				tr.Poster = tor.Poster
+				tr.Size = tor.Size
+				tr.Timestamp = tor.Timestamp
+				tr.GotInfo()
+			}
+		}()
+	}
+	return tor
+}
+
+func RemTorrent(hashHex string) {
+	hash := metainfo.NewHashFromHex(hashHex)
+	bts.RemoveTorrent(hash)
+	RemTorrentDB(hash)
+}
+
+func ListTorrent() []*Torrent {
+	btlist := bts.ListTorrents()
+	dblist := ListTorrentsDB()
+
+	for hash, t := range dblist {
+		if _, ok := btlist[hash]; !ok {
+			btlist[hash] = t
+		}
+	}
+	var ret []*Torrent
+
+	for _, t := range btlist {
+		ret = append(ret, t)
+	}
+
+	sort.Slice(ret, func(i, j int) bool {
+		if ret[i].Timestamp != ret[j].Timestamp {
+			return ret[i].Timestamp > ret[j].Timestamp
+		} else {
+			return ret[i].Title > ret[j].Title
+		}
+	})
+
+	return ret
+}
+
+func DropTorrent(hashHex string) {
+	hash := metainfo.NewHashFromHex(hashHex)
+	bts.RemoveTorrent(hash)
+}
+
+func SetSettings(set *sets.BTSets) {
+	if sets.ReadOnly {
+		return
+	}
+	bts.Disconnect()
+	sets.SetBTSets(set)
+	bts.Connect()
+}
+
+func Shutdown() {
+	bts.Disconnect()
+	sets.CloseDB()
+	os.Exit(0)
+}
+
+func WriteStatus(w io.Writer) {
+	bts.client.WriteStatus(w)
+}
+
+func Preload(torr *Torrent, index int) {
+	if !sets.BTsets.PreloadBuffer {
+		size := int64(32 * 1024 * 1024)
+		if size > sets.BTsets.CacheSize {
+			size = sets.BTsets.CacheSize
+		}
+		torr.Preload(index, size)
+	} else {
+		size := int64(float32(sets.BTsets.ReaderReadAHead) / 100.0 * float32(sets.BTsets.CacheSize))
+		torr.Preload(index, size)
+	}
+}
--- a/server/torr/btserver.go
+++ b/server/torr/btserver.go
@@ -0,0 +1,138 @@
+package torr
+
+import (
+	"log"
+	"sync"
+	"time"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+	"server/settings"
+	"server/torr/storage/torrstor"
+	"server/torr/utils"
+)
+
+type BTServer struct {
+	config *torrent.ClientConfig
+	client *torrent.Client
+
+	storage *torrstor.Storage
+
+	torrents map[metainfo.Hash]*Torrent
+
+	mu sync.Mutex
+}
+
+func NewBTS() *BTServer {
+	bts := new(BTServer)
+	bts.torrents = make(map[metainfo.Hash]*Torrent)
+	return bts
+}
+
+func (bt *BTServer) Connect() error {
+	bt.mu.Lock()
+	defer bt.mu.Unlock()
+	var err error
+	bt.configure()
+	bt.client, err = torrent.NewClient(bt.config)
+	bt.torrents = make(map[metainfo.Hash]*Torrent)
+	InitApiHelper(bt)
+	return err
+}
+
+func (bt *BTServer) Disconnect() {
+	bt.mu.Lock()
+	defer bt.mu.Unlock()
+	if bt.client != nil {
+		bt.client.Close()
+		bt.client = nil
+		utils.FreeOSMemGC()
+	}
+}
+
+func (bt *BTServer) configure() {
+	blocklist, _ := utils.ReadBlockedIP()
+	bt.config = torrent.NewDefaultClientConfig()
+
+	if !settings.BTsets.SaveOnDisk {
+		bt.storage = torrstor.NewStorage(settings.BTsets.CacheSize)
+		bt.config.DefaultStorage = bt.storage
+	} else {
+		bt.config.DataDir = settings.BTsets.ContentPath
+	}
+
+	userAgent := "qBittorrent/4.3.2"
+	peerID := "-qB4320-"
+	cliVers := userAgent //"uTorrent/2210(25302)"
+
+	bt.config.Debug = settings.BTsets.EnableDebug
+	bt.config.DisableIPv6 = settings.BTsets.EnableIPv6 == false
+	bt.config.DisableTCP = settings.BTsets.DisableTCP
+	bt.config.DisableUTP = settings.BTsets.DisableUTP
+	bt.config.NoDefaultPortForwarding = settings.BTsets.DisableUPNP
+	bt.config.NoDHT = settings.BTsets.DisableDHT
+	bt.config.NoUpload = settings.BTsets.DisableUpload
+	bt.config.IPBlocklist = blocklist
+	bt.config.Bep20 = peerID
+	bt.config.PeerID = utils.PeerIDRandom(peerID)
+	bt.config.HTTPUserAgent = userAgent
+	bt.config.ExtendedHandshakeClientVersion = cliVers
+	bt.config.EstablishedConnsPerTorrent = settings.BTsets.ConnectionsLimit
+	bt.config.UpnpID = "YouROK/TorrServer"
+
+	//bt.config.DropMutuallyCompletePeers = true
+	//bt.config.DropDuplicatePeerIds = true
+
+	// Encryption/Obfuscation
+	bt.config.HeaderObfuscationPolicy = torrent.HeaderObfuscationPolicy{
+		RequirePreferred: settings.BTsets.ForceEncrypt,
+		Preferred:        true,
+	}
+
+	switch settings.BTsets.Strategy {
+	case 1: // RequestStrategyFuzzing
+		bt.config.DefaultRequestStrategy = torrent.RequestStrategyFuzzing()
+	case 2: // RequestStrategyFastest
+		bt.config.DefaultRequestStrategy = torrent.RequestStrategyFastest()
+	default: // RequestStrategyDuplicateRequestTimeout
+		bt.config.DefaultRequestStrategy = torrent.RequestStrategyDuplicateRequestTimeout(5 * time.Second)
+	}
+
+	if settings.BTsets.DhtConnectionLimit > 0 {
+		bt.config.ConnTracker.SetMaxEntries(settings.BTsets.DhtConnectionLimit)
+	}
+	if settings.BTsets.DownloadRateLimit > 0 {
+		bt.config.DownloadRateLimiter = utils.Limit(settings.BTsets.DownloadRateLimit * 1024)
+	}
+	if settings.BTsets.UploadRateLimit > 0 {
+		bt.config.UploadRateLimiter = utils.Limit(settings.BTsets.UploadRateLimit * 1024)
+	}
+	if settings.BTsets.PeersListenPort > 0 {
+		bt.config.ListenPort = settings.BTsets.PeersListenPort
+	} else {
+		bt.config.ListenPort = 50109
+	}
+
+	log.Println("Configure client:", settings.BTsets)
+}
+
+func (bt *BTServer) GetTorrent(hash torrent.InfoHash) *Torrent {
+	if torr, ok := bt.torrents[hash]; ok {
+		return torr
+	}
+	return nil
+}
+
+func (bt *BTServer) ListTorrents() map[metainfo.Hash]*Torrent {
+	list := make(map[metainfo.Hash]*Torrent)
+	for k, v := range bt.torrents {
+		list[k] = v
+	}
+	return list
+}
+
+func (bt *BTServer) RemoveTorrent(hash torrent.InfoHash) {
+	if torr, ok := bt.torrents[hash]; ok {
+		torr.Close()
+	}
+}
--- a/server/torr/dbwrapper.go
+++ b/server/torr/dbwrapper.go
@@ -0,0 +1,67 @@
+package torr
+
+import (
+	"time"
+
+	"server/settings"
+	"server/torr/state"
+
+	"github.com/anacrolix/torrent/metainfo"
+)
+
+func AddTorrentDB(torr *Torrent) {
+	t := new(settings.TorrentDB)
+	t.TorrentSpec = torr.TorrentSpec
+	t.Name = torr.Name()
+	t.Title = torr.Title
+	t.Data = torr.Data
+	if t.Title == "" {
+		t.Title = t.Name
+	}
+	t.Poster = torr.Poster
+	t.Size = torr.Size
+	if t.Size == 0 && torr.Torrent != nil {
+		t.Size = torr.Torrent.Length()
+	}
+	t.Timestamp = time.Now().Unix()
+	settings.AddTorrent(t)
+}
+
+func GetTorrentDB(hash metainfo.Hash) *Torrent {
+	list := settings.ListTorrent()
+	for _, db := range list {
+		if hash == db.InfoHash {
+			torr := new(Torrent)
+			torr.TorrentSpec = db.TorrentSpec
+			torr.Title = db.Title
+			torr.Poster = db.Poster
+			torr.Timestamp = db.Timestamp
+			torr.Size = db.Size
+			torr.Data = db.Data
+			torr.Stat = state.TorrentInDB
+			return torr
+		}
+	}
+	return nil
+}
+
+func RemTorrentDB(hash metainfo.Hash) {
+	settings.RemTorrent(hash)
+}
+
+func ListTorrentsDB() map[metainfo.Hash]*Torrent {
+	ret := make(map[metainfo.Hash]*Torrent)
+	list := settings.ListTorrent()
+	for _, db := range list {
+		torr := new(Torrent)
+		torr.TorrentSpec = db.TorrentSpec
+		torr.Title = db.Title
+		torr.Poster = db.Poster
+		torr.Timestamp = db.Timestamp
+		torr.Size = db.Size
+		torr.Data = db.Data
+		torr.Stat = state.TorrentInDB
+		ret[torr.TorrentSpec.InfoHash] = torr
+	}
+	return ret
+}
--- a/server/torr/state/state.go
+++ b/server/torr/state/state.go
@@ -0,0 +1,72 @@
+package state
+
+type TorrentStat int
+
+func (t TorrentStat) String() string {
+	switch t {
+	case TorrentAdded:
+		return "Torrent added"
+	case TorrentGettingInfo:
+		return "Torrent getting info"
+	case TorrentPreload:
+		return "Torrent preload"
+	case TorrentWorking:
+		return "Torrent working"
+	case TorrentClosed:
+		return "Torrent closed"
+	case TorrentInDB:
+		return "Torrent in db"
+	default:
+		return "Torrent unknown status"
+	}
+}
+
+const (
+	TorrentAdded = TorrentStat(iota)
+	TorrentGettingInfo
+	TorrentPreload
+	TorrentWorking
+	TorrentClosed
+	TorrentInDB
+)
+
+type TorrentStatus struct {
+	Title               string      `json:"title"`
+	Poster              string      `json:"poster"`
+	Data                string      `json:"data,omitempty"`
+	Timestamp           int64       `json:"timestamp"`
+	Name                string      `json:"name,omitempty"`
+	Hash                string      `json:"hash,omitempty"`
+	Stat                TorrentStat `json:"stat"`
+	StatString          string      `json:"stat_string"`
+	LoadedSize          int64       `json:"loaded_size,omitempty"`
+	TorrentSize         int64       `json:"torrent_size,omitempty"`
+	PreloadedBytes      int64       `json:"preloaded_bytes,omitempty"`
+	PreloadSize         int64       `json:"preload_size,omitempty"`
+	DownloadSpeed       float64     `json:"download_speed,omitempty"`
+	UploadSpeed         float64     `json:"upload_speed,omitempty"`
+	TotalPeers          int         `json:"total_peers,omitempty"`
+	PendingPeers        int         `json:"pending_peers,omitempty"`
+	ActivePeers         int         `json:"active_peers,omitempty"`
+	ConnectedSeeders    int         `json:"connected_seeders,omitempty"`
+	HalfOpenPeers       int         `json:"half_open_peers,omitempty"`
+	BytesWritten        int64       `json:"bytes_written,omitempty"`
+	BytesWrittenData    int64       `json:"bytes_written_data,omitempty"`
+	BytesRead           int64       `json:"bytes_read,omitempty"`
+	BytesReadData       int64       `json:"bytes_read_data,omitempty"`
+	BytesReadUsefulData int64       `json:"bytes_read_useful_data,omitempty"`
+	ChunksWritten       int64       `json:"chunks_written,omitempty"`
+	ChunksRead          int64       `json:"chunks_read,omitempty"`
+	ChunksReadUseful    int64       `json:"chunks_read_useful,omitempty"`
+	ChunksReadWasted    int64       `json:"chunks_read_wasted,omitempty"`
+	PiecesDirtiedGood   int64       `json:"pieces_dirtied_good,omitempty"`
+	PiecesDirtiedBad    int64       `json:"pieces_dirtied_bad,omitempty"`
+
+	FileStats []*TorrentFileStat `json:"file_stats,omitempty"`
+}
+
+type TorrentFileStat struct {
+	Id     int    `json:"id,omitempty"`
+	Path   string `json:"path,omitempty"`
+	Length int64  `json:"length,omitempty"`
+}
--- a/server/torr/storage/state/state.go
+++ b/server/torr/storage/state/state.go
@@ -0,0 +1,29 @@
+package state
+
+import (
+	"server/torr/state"
+)
+
+type CacheState struct {
+	Hash         string
+	Capacity     int64
+	Filled       int64
+	PiecesLength int64
+	PiecesCount  int
+	Torrent      *state.TorrentStatus
+	Pieces       map[int]ItemState
+	Readers      []*ReaderState
+}
+
+type ItemState struct {
+	Id        int
+	Length    int64
+	Size      int64
+	Completed bool
+}
+
+type ReaderState struct {
+	Start  int
+	End    int
+	Reader int
+}
--- a/server/torr/storage/storage.go
+++ b/server/torr/storage/storage.go
@@ -0,0 +1,12 @@
+package storage
+
+import (
+	"github.com/anacrolix/torrent/metainfo"
+	"github.com/anacrolix/torrent/storage"
+)
+
+type Storage interface {
+	storage.ClientImpl
+
+	CloseHash(hash metainfo.Hash)
+}
--- a/server/torr/storage/torrstor/cache.go
+++ b/server/torr/storage/torrstor/cache.go
@@ -0,0 +1,219 @@
+package torrstor
+
+import (
+	"sort"
+	"sync"
+
+	"github.com/anacrolix/torrent"
+	"server/log"
+	"server/settings"
+	"server/torr/storage/state"
+	"server/torr/utils"
+
+	"github.com/anacrolix/torrent/metainfo"
+	"github.com/anacrolix/torrent/storage"
+)
+
+type Cache struct {
+	storage.TorrentImpl
+	storage *Storage
+
+	capacity int64
+	filled   int64
+	hash     metainfo.Hash
+
+	pieceLength int64
+	pieceCount  int
+
+	pieces map[int]*Piece
+
+	readers   map[*Reader]struct{}
+	muReaders sync.Mutex
+
+	isRemove bool
+	muRemove sync.Mutex
+	torrent  *torrent.Torrent
+}
+
+func NewCache(capacity int64, storage *Storage) *Cache {
+	ret := &Cache{
+		capacity: capacity,
+		filled:   0,
+		pieces:   make(map[int]*Piece),
+		storage:  storage,
+		readers:  make(map[*Reader]struct{}),
+	}
+
+	return ret
+}
+
+func (c *Cache) Init(info *metainfo.Info, hash metainfo.Hash) {
+	log.TLogln("Create cache for:", info.Name, hash.HexString())
+	if c.capacity == 0 {
+		c.capacity = info.PieceLength * 4
+	}
+
+	c.pieceLength = info.PieceLength
+	c.pieceCount = info.NumPieces()
+	c.hash = hash
+
+	for i := 0; i < c.pieceCount; i++ {
+		c.pieces[i] = &Piece{
+			Id:     i,
+			Length: info.Piece(i).Length(),
+			Hash:   info.Piece(i).Hash().HexString(),
+			cache:  c,
+		}
+	}
+}
+
+func (c *Cache) SetTorrent(torr *torrent.Torrent) {
+	c.torrent = torr
+}
+
+func (c *Cache) Piece(m metainfo.Piece) storage.PieceImpl {
+	if val, ok := c.pieces[m.Index()]; ok {
+		return val
+	}
+	return nil
+}
+
+func (c *Cache) Close() error {
+	log.TLogln("Close cache for:", c.hash)
+	if _, ok := c.storage.caches[c.hash]; ok {
+		delete(c.storage.caches, c.hash)
+	}
+	c.pieces = nil
+
+	c.muReaders.Lock()
+	c.readers = nil
+	c.muReaders.Unlock()
+
+	utils.FreeOSMemGC()
+	return nil
+}
+
+func (c *Cache) removePiece(piece *Piece) {
+	piece.Release()
+	utils.FreeOSMemGC()
+}
+
+func (c *Cache) AdjustRA(readahead int64) {
+	if settings.BTsets.CacheSize == 0 {
+		c.capacity = readahead * 3
+	}
+	c.muReaders.Lock()
+	for r, _ := range c.readers {
+		r.SetReadahead(readahead)
+	}
+	c.muReaders.Unlock()
+}
+
+func (c *Cache) GetState() *state.CacheState {
+	cState := new(state.CacheState)
+
+	piecesState := make(map[int]state.ItemState, 0)
+	var fill int64 = 0
+	for _, p := range c.pieces {
+		if p.Size > 0 {
+			fill += p.Length
+			piecesState[p.Id] = state.ItemState{
+				Id:        p.Id,
+				Size:      p.Size,
+				Length:    p.Length,
+				Completed: p.complete,
+			}
+		}
+	}
+
+	readersState := make([]*state.ReaderState, 0)
+	c.muReaders.Lock()
+	for r, _ := range c.readers {
+		rng := r.getPiecesRange()
+		pc := r.getReaderPiece()
+		readersState = append(readersState, &state.ReaderState{
+			Start:  rng.Start,
+			End:    rng.End,
+			Reader: pc,
+		})
+	}
+	c.muReaders.Unlock()
+
+	c.filled = fill
+	cState.Capacity = c.capacity
+	cState.PiecesLength = c.pieceLength
+	cState.PiecesCount = c.pieceCount
+	cState.Hash = c.hash.HexString()
+	cState.Filled = fill
+	cState.Pieces = piecesState
+	cState.Readers = readersState
+	return cState
+}
+
+func (c *Cache) cleanPieces() {
+	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()
+
+	remPieces := c.getRemPieces()
+	if c.filled > c.capacity {
+		rems := (c.filled - c.capacity) / c.pieceLength
+		for _, p := range remPieces {
+			c.removePiece(p)
+			rems--
+			if rems <= 0 {
+				break
+			}
+		}
+	}
+}
+
+func (c *Cache) getRemPieces() []*Piece {
+	piecesRemove := make([]*Piece, 0)
+	fill := int64(0)
+
+	ranges := make([]Range, 0)
+	c.muReaders.Lock()
+	for r, _ := range c.readers {
+		ranges = append(ranges, r.getPiecesRange())
+	}
+	c.muReaders.Unlock()
+	ranges = mergeRange(ranges)
+
+	for id, p := range c.pieces {
+		if p.Size > 0 {
+			fill += p.Size
+		}
+		if len(ranges) > 0 {
+			if !inRanges(ranges, id) {
+				piece := c.torrent.Piece(id)
+				if piece.State().Priority != torrent.PiecePriorityNone {
+					piece.SetPriority(torrent.PiecePriorityNone)
+				}
+				if p.Size > 0 {
+					piecesRemove = append(piecesRemove, p)
+				}
+			}
+		} else {
+			piece := c.torrent.Piece(id)
+			if piece.State().Priority != torrent.PiecePriorityNone {
+				piece.SetPriority(torrent.PiecePriorityNone)
+			}
+		}
+	}
+
+	sort.Slice(piecesRemove, func(i, j int) bool {
+		return piecesRemove[i].accessed < piecesRemove[j].accessed
+	})
+
+	c.filled = fill
+	return piecesRemove
+}
--- a/server/torr/storage/torrstor/piece.go
+++ b/server/torr/storage/torrstor/piece.go
@@ -0,0 +1,106 @@
+package torrstor
+
+import (
+	"errors"
+	"io"
+	"sync"
+	"time"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/storage"
+)
+
+type Piece struct {
+	storage.PieceImpl
+
+	Id     int
+	Hash   string
+	Length int64
+	Size   int64
+
+	complete bool
+	readed   bool
+	accessed int64
+	buffer   []byte
+
+	mu    sync.RWMutex
+	cache *Cache
+}
+
+func (p *Piece) WriteAt(b []byte, off int64) (n int, err error) {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if p.buffer == nil {
+		go p.cache.cleanPieces()
+		p.buffer = make([]byte, p.cache.pieceLength)
+	}
+	n = copy(p.buffer[off:], b[:])
+	p.Size += int64(n)
+	p.accessed = time.Now().Unix()
+	return
+}
+
+func (p *Piece) ReadAt(b []byte, off int64) (n int, err error) {
+	p.mu.RLock()
+	defer p.mu.RUnlock()
+
+	size := len(b)
+	if size+int(off) > len(p.buffer) {
+		size = len(p.buffer) - int(off)
+		if size < 0 {
+			size = 0
+		}
+	}
+	if len(p.buffer) < int(off) || len(p.buffer) < int(off)+size {
+		return 0, io.EOF
+	}
+	n = copy(b, p.buffer[int(off) : int(off)+size][:])
+	p.accessed = time.Now().Unix()
+	if int(off)+size >= len(p.buffer) {
+		p.readed = true
+	}
+	if int64(len(b))+off >= p.Size {
+		go p.cache.cleanPieces()
+	}
+	if n == 0 && err == nil {
+		return 0, io.EOF
+	}
+	return n, nil
+}
+
+func (p *Piece) MarkComplete() error {
+	if len(p.buffer) == 0 {
+		return errors.New("piece is not complete")
+	}
+	p.complete = true
+	return nil
+}
+
+func (p *Piece) MarkNotComplete() error {
+	p.complete = false
+	return nil
+}
+
+func (p *Piece) Completion() storage.Completion {
+	return storage.Completion{
+		Complete: p.complete && len(p.buffer) > 0,
+		Ok:       true,
+	}
+}
+
+func (p *Piece) Release() {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+	if p.buffer != nil {
+		p.buffer = nil
+	}
+	p.Size = 0
+	p.complete = false
+
+	//Костыль чтобы двиг понял что куска нет, иногда загружает его по новый хз почему
+	pce := p.cache.torrent.Piece(p.Id)
+	pce.SetPriority(torrent.PiecePriorityNone)
+	pce.UpdateCompletion()
+	pce.SetPriority(torrent.PiecePriorityNone)
+}
--- a/server/torr/storage/torrstor/ranges.go
+++ b/server/torr/storage/torrstor/ranges.go
@@ -0,0 +1,49 @@
+package torrstor
+
+import (
+	"sort"
+)
+
+type Range struct {
+	Start, End int
+}
+
+func inRanges(ranges []Range, ind int) bool {
+	for _, r := range ranges {
+		if ind >= r.Start && ind <= r.End {
+			return true
+		}
+	}
+	return false
+}
+
+func mergeRange(ranges []Range) []Range {
+	if len(ranges) <= 1 {
+		return ranges
+	}
+	// copy ranges
+	merged := append([]Range(nil), ranges...)
+
+	sort.Slice(merged, func(i, j int) bool {
+		if merged[i].Start < merged[j].Start {
+			return true
+		}
+		if merged[i].Start == merged[j].Start && merged[i].End < merged[j].End {
+			return true
+		}
+		return false
+	})
+
+	j := 0
+	for i := 1; i < len(merged); i++ {
+		if merged[j].End >= merged[i].Start {
+			if merged[j].End < merged[i].End {
+				merged[j].End = merged[i].End
+			}
+		} else {
+			j++
+			merged[j] = merged[i]
+		}
+	}
+	return merged[:j+1]
+}
--- a/server/torr/storage/torrstor/reader.go
+++ b/server/torr/storage/torrstor/reader.go
@@ -0,0 +1,114 @@
+package torrstor
+
+import (
+	"io"
+	"sync"
+
+	"github.com/anacrolix/torrent"
+	"server/log"
+)
+
+type Reader struct {
+	torrent.Reader
+	offset    int64
+	readahead int64
+	file      *torrent.File
+
+	cache    *Cache
+	isClosed bool
+
+	///Preload
+	muPreload sync.Mutex
+}
+
+func newReader(file *torrent.File, cache *Cache) *Reader {
+	r := new(Reader)
+	r.file = file
+	r.Reader = file.NewReader()
+
+	r.SetReadahead(0)
+	r.cache = cache
+
+	cache.muReaders.Lock()
+	cache.readers[r] = struct{}{}
+	cache.muReaders.Unlock()
+	return r
+}
+
+func (r *Reader) Seek(offset int64, whence int) (n int64, err error) {
+	if r.isClosed {
+		return 0, io.EOF
+	}
+	switch whence {
+	case io.SeekStart:
+		r.offset = offset
+	case io.SeekCurrent:
+		r.offset += offset
+	case io.SeekEnd:
+		r.offset = r.file.Length() + offset
+	}
+	n, err = r.Reader.Seek(offset, whence)
+	r.offset = n
+	return
+}
+
+func (r *Reader) Read(p []byte) (n int, err error) {
+	err = io.EOF
+	if r.isClosed {
+		return
+	}
+	if r.file.Torrent() != nil && r.file.Torrent().Info() != nil {
+		n, err = r.Reader.Read(p)
+		r.offset += int64(n)
+		go r.preload()
+	} else {
+		log.TLogln("Torrent closed and readed")
+	}
+	return
+}
+
+func (r *Reader) SetReadahead(length int64) {
+	r.Reader.SetReadahead(length)
+	r.readahead = length
+}
+
+func (r *Reader) Offset() int64 {
+	return r.offset
+}
+
+func (r *Reader) Readahead() int64 {
+	return r.readahead
+}
+
+func (r *Reader) Close() {
+	// file reader close in gotorrent
+	// this struct close in cache
+	r.isClosed = true
+	if len(r.file.Torrent().Files()) > 0 {
+		r.Reader.Close()
+	}
+	go r.cache.getRemPieces()
+}
+
+func (c *Cache) NewReader(file *torrent.File) *Reader {
+	return newReader(file, c)
+}
+
+func (c *Cache) Readers() int {
+	if c == nil {
+		return 0
+	}
+	c.muReaders.Lock()
+	defer c.muReaders.Unlock()
+	if c == nil || c.readers == nil {
+		return 0
+	}
+	return len(c.readers)
+}
+
+func (c *Cache) CloseReader(r *Reader) {
+	r.cache.muReaders.Lock()
+	r.Close()
+	delete(r.cache.readers, r)
+	r.cache.muReaders.Unlock()
+}
--- a/server/torr/storage/torrstor/readerloader.go
+++ b/server/torr/storage/torrstor/readerloader.go
@@ -0,0 +1,54 @@
+package torrstor
+
+import (
+	"github.com/anacrolix/torrent"
+	"server/settings"
+)
+
+func (r *Reader) getPiecesRange() Range {
+	startOff, endOff := r.getOffsetRange()
+	return Range{r.getPieceNum(startOff), r.getPieceNum(endOff)}
+}
+
+func (r *Reader) getReaderPiece() int {
+	readerOff := r.offset
+	return r.getPieceNum(readerOff)
+}
+
+func (r *Reader) getPieceNum(offset int64) int {
+	return int((offset + r.file.Offset()) / r.cache.pieceLength)
+}
+
+func (r *Reader) getOffsetRange() (int64, int64) {
+	prc := int64(settings.BTsets.ReaderReadAHead)
+	readers := int64(len(r.cache.readers))
+	if readers == 0 {
+		readers = 1
+	}
+
+	beginOffset := r.offset - (r.cache.capacity/readers)*(100-prc)/100
+	endOffset := r.offset + (r.cache.capacity/readers)*prc/100
+
+	if beginOffset < 0 {
+		beginOffset = 0
+	}
+
+	if endOffset > r.file.Length() {
+		endOffset = r.file.Length()
+	}
+	return beginOffset, endOffset
+}
+
+func (r *Reader) preload() {
+	torr := r.file.Torrent()
+	rrange := r.getPiecesRange()
+	rahPiece := int(r.readahead / torr.Info().PieceLength)
+	readerPiece := r.getReaderPiece()
+
+	// from reader readahead to end of range
+	for i := readerPiece + rahPiece; i < rrange.End; i++ {
+		if torr.Piece(i).State().Priority == torrent.PiecePriorityNone {
+			torr.Piece(i).SetPriority(torrent.PiecePriorityNormal)
+		}
+	}
+}
--- a/server/torr/storage/torrstor/storage.go
+++ b/server/torr/storage/torrstor/storage.go
@@ -0,0 +1,64 @@
+package torrstor
+
+import (
+	"sync"
+
+	"server/torr/storage"
+
+	"github.com/anacrolix/torrent/metainfo"
+	storage2 "github.com/anacrolix/torrent/storage"
+)
+
+type Storage struct {
+	storage.Storage
+
+	caches   map[metainfo.Hash]*Cache
+	capacity int64
+	mu       sync.Mutex
+}
+
+func NewStorage(capacity int64) *Storage {
+	stor := new(Storage)
+	stor.capacity = capacity
+	stor.caches = make(map[metainfo.Hash]*Cache)
+	return stor
+}
+
+func (s *Storage) OpenTorrent(info *metainfo.Info, infoHash metainfo.Hash) (storage2.TorrentImpl, error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	ch := NewCache(s.capacity, s)
+	ch.Init(info, infoHash)
+	s.caches[infoHash] = ch
+	return ch, nil
+}
+
+func (s *Storage) CloseHash(hash metainfo.Hash) {
+	if s.caches == nil {
+		return
+	}
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if ch, ok := s.caches[hash]; ok {
+		ch.Close()
+		delete(s.caches, hash)
+	}
+}
+
+func (s *Storage) Close() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	for _, ch := range s.caches {
+		ch.Close()
+	}
+	return nil
+}
+
+func (s *Storage) GetCache(hash metainfo.Hash) *Cache {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if cache, ok := s.caches[hash]; ok {
+		return cache
+	}
+	return nil
+}
--- a/server/torr/stream.go
+++ b/server/torr/stream.go
@@ -0,0 +1,60 @@
+package torr
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"net/http"
+	"time"
+
+	"github.com/anacrolix/missinggo/httptoo"
+	"github.com/anacrolix/torrent"
+	sets "server/settings"
+	"server/torr/state"
+)
+
+func (t *Torrent) Stream(fileID int, req *http.Request, resp http.ResponseWriter) error {
+	if !t.GotInfo() {
+		http.NotFound(resp, req)
+		return errors.New("torrent don't get info")
+	}
+
+	st := t.Status()
+	var stFile *state.TorrentFileStat
+	for _, fileStat := range st.FileStats {
+		if fileStat.Id == fileID {
+			stFile = fileStat
+			break
+		}
+	}
+	if stFile == nil {
+		return fmt.Errorf("file with id %v not found", fileID)
+	}
+
+	files := t.Files()
+	var file *torrent.File
+	for _, tfile := range files {
+		if tfile.Path() == stFile.Path {
+			file = tfile
+			break
+		}
+	}
+	if file == nil {
+		return fmt.Errorf("file with id %v not found", fileID)
+	}
+
+	reader := t.NewReader(file)
+
+	log.Println("Connect client")
+
+	sets.SetViewed(&sets.Viewed{t.Hash().HexString(), fileID})
+
+	resp.Header().Set("Connection", "close")
+	resp.Header().Set("ETag", httptoo.EncodeQuotedString(fmt.Sprintf("%s/%s", t.Hash().HexString(), file.Path())))
+
+	http.ServeContent(resp, req, file.Path(), time.Unix(t.Timestamp, 0), reader)
+
+	t.CloseReader(reader)
+	log.Println("Disconnect client")
+	return nil
+}
--- a/server/torr/torrent.go
+++ b/server/torr/torrent.go
@@ -0,0 +1,443 @@
+package torr
+
+import (
+	"errors"
+	"fmt"
+	"sort"
+	"sync"
+	"time"
+
+	"server/log"
+	"server/settings"
+	"server/torr/state"
+	cacheSt "server/torr/storage/state"
+	"server/torr/storage/torrstor"
+	"server/torr/utils"
+	utils2 "server/utils"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+)
+
+type Torrent struct {
+	Title  string
+	Poster string
+	Data   string
+	*torrent.TorrentSpec
+
+	Stat      state.TorrentStat
+	Timestamp int64
+	Size      int64
+
+	*torrent.Torrent
+	muTorrent sync.Mutex
+
+	bt    *BTServer
+	cache *torrstor.Cache
+
+	lastTimeSpeed       time.Time
+	DownloadSpeed       float64
+	UploadSpeed         float64
+	BytesReadUsefulData int64
+	BytesWrittenData    int64
+
+	PreloadSize    int64
+	PreloadedBytes int64
+
+	expiredTime time.Time
+
+	closed <-chan struct{}
+
+	progressTicker *time.Ticker
+}
+
+func NewTorrent(spec *torrent.TorrentSpec, bt *BTServer) (*Torrent, error) {
+	// TODO panic when settings sets
+	if bt == nil {
+		return nil, errors.New("BT client not connected")
+	}
+	switch settings.BTsets.RetrackersMode {
+	case 1:
+		spec.Trackers = append(spec.Trackers, [][]string{utils.GetDefTrackers()}...)
+	case 2:
+		spec.Trackers = nil
+	case 3:
+		spec.Trackers = [][]string{utils.GetDefTrackers()}
+	}
+
+	goTorrent, _, err := bt.client.AddTorrentSpec(spec)
+	if err != nil {
+		return nil, err
+	}
+
+	bt.mu.Lock()
+	defer bt.mu.Unlock()
+	if tor, ok := bt.torrents[spec.InfoHash]; ok {
+		return tor, nil
+	}
+
+	torr := new(Torrent)
+	torr.Torrent = goTorrent
+	torr.Stat = state.TorrentAdded
+	torr.lastTimeSpeed = time.Now()
+	torr.bt = bt
+	torr.closed = goTorrent.Closed()
+	torr.TorrentSpec = spec
+	torr.AddExpiredTime(time.Minute)
+	torr.Timestamp = time.Now().Unix()
+
+	go torr.watch()
+
+	bt.torrents[spec.InfoHash] = torr
+	return torr, nil
+}
+
+func (t *Torrent) WaitInfo() bool {
+	if t.Torrent == nil {
+		return false
+	}
+
+	// Close torrent if not info while 10 minutes
+	tm := time.NewTimer(time.Minute * 10)
+
+	select {
+	case <-t.Torrent.GotInfo():
+		t.cache = t.bt.storage.GetCache(t.Hash())
+		t.cache.SetTorrent(t.Torrent)
+		return true
+	case <-t.closed:
+		return false
+	case <-tm.C:
+		return false
+	}
+}
+
+func (t *Torrent) GotInfo() bool {
+	if t.Stat == state.TorrentClosed {
+		return false
+	}
+	t.Stat = state.TorrentGettingInfo
+	if t.WaitInfo() {
+		t.Stat = state.TorrentWorking
+		t.AddExpiredTime(time.Minute * 5)
+		return true
+	} else {
+		t.Close()
+		return false
+	}
+}
+
+func (t *Torrent) AddExpiredTime(duration time.Duration) {
+	t.expiredTime = time.Now().Add(duration)
+}
+
+func (t *Torrent) watch() {
+	t.progressTicker = time.NewTicker(time.Second)
+	defer t.progressTicker.Stop()
+
+	for {
+		select {
+		case <-t.progressTicker.C:
+			go t.progressEvent()
+		case <-t.closed:
+			return
+		}
+	}
+}
+
+func (t *Torrent) progressEvent() {
+	if t.expired() {
+		log.TLogln("Torrent close by timeout", t.Torrent.InfoHash().HexString())
+		t.bt.RemoveTorrent(t.Hash())
+		return
+	}
+
+	t.muTorrent.Lock()
+	if t.Torrent != nil && t.Torrent.Info() != nil {
+		st := t.Torrent.Stats()
+		deltaDlBytes := st.BytesReadUsefulData.Int64() - t.BytesReadUsefulData
+		deltaUpBytes := st.BytesWrittenData.Int64() - t.BytesWrittenData
+		deltaTime := time.Since(t.lastTimeSpeed).Seconds()
+
+		t.DownloadSpeed = float64(deltaDlBytes) / deltaTime
+		t.UploadSpeed = float64(deltaUpBytes) / deltaTime
+
+		t.BytesWrittenData = st.BytesWrittenData.Int64()
+		t.BytesReadUsefulData = st.BytesReadUsefulData.Int64()
+
+		t.PreloadedBytes = t.Torrent.BytesCompleted()
+	} else {
+		t.DownloadSpeed = 0
+		t.UploadSpeed = 0
+	}
+	t.muTorrent.Unlock()
+
+	t.lastTimeSpeed = time.Now()
+	t.updateRA()
+}
+
+func (t *Torrent) updateRA() {
+	t.muTorrent.Lock()
+	defer t.muTorrent.Unlock()
+	if t.Torrent != nil && t.Torrent.Info() != nil {
+		pieceLen := t.Torrent.Info().PieceLength
+		adj := pieceLen * int64(t.Torrent.Stats().ActivePeers) / int64(1+t.cache.Readers())
+		switch {
+		case adj < pieceLen:
+			adj = pieceLen
+		case adj > pieceLen*4:
+			adj = pieceLen * 4
+		}
+		go t.cache.AdjustRA(adj)
+	}
+}
+
+func (t *Torrent) expired() bool {
+	return t.cache.Readers() == 0 && t.expiredTime.Before(time.Now()) && (t.Stat == state.TorrentWorking || t.Stat == state.TorrentClosed)
+}
+
+func (t *Torrent) Files() []*torrent.File {
+	if t.Torrent != nil && t.Torrent.Info() != nil {
+		files := t.Torrent.Files()
+		return files
+	}
+	return nil
+}
+
+func (t *Torrent) Hash() metainfo.Hash {
+	if t.Torrent != nil {
+		t.Torrent.InfoHash()
+	}
+	if t.TorrentSpec != nil {
+		return t.TorrentSpec.InfoHash
+	}
+	return [20]byte{}
+}
+
+func (t *Torrent) Length() int64 {
+	if t.Info() == nil {
+		return 0
+	}
+	return t.Torrent.Length()
+}
+
+func (t *Torrent) NewReader(file *torrent.File) *torrstor.Reader {
+	if t.Stat == state.TorrentClosed {
+		return nil
+	}
+	reader := t.cache.NewReader(file)
+	return reader
+}
+
+func (t *Torrent) CloseReader(reader *torrstor.Reader) {
+	t.cache.CloseReader(reader)
+	t.AddExpiredTime(time.Second * time.Duration(settings.BTsets.TorrentDisconnectTimeout))
+}
+
+func (t *Torrent) GetCache() *torrstor.Cache {
+	return t.cache
+}
+
+func (t *Torrent) Preload(index int, size int64) {
+	if size <= 0 {
+		return
+	}
+	t.PreloadSize = size
+
+	if t.Stat == state.TorrentGettingInfo {
+		if !t.WaitInfo() {
+			return
+		}
+		// wait change status
+		time.Sleep(100 * time.Millisecond)
+	}
+
+	t.muTorrent.Lock()
+	if t.Stat != state.TorrentWorking {
+		t.muTorrent.Unlock()
+		return
+	}
+
+	t.Stat = state.TorrentPreload
+	t.muTorrent.Unlock()
+
+	defer func() {
+		if t.Stat == state.TorrentPreload {
+			t.Stat = state.TorrentWorking
+		}
+	}()
+
+	file := t.findFileIndex(index)
+	if file == nil {
+		file = t.Files()[0]
+	}
+
+	if t.Info() != nil {
+		pl := t.Info().PieceLength
+		mb5 := int64(5 * 1024 * 1024)
+
+		pieceFileStart := int(file.Offset() / pl)
+		pieceFileEnd := int((file.Offset() + file.Length()) / pl)
+		readerPieceBefore := int((file.Offset() + size - mb5) / pl)
+		readerPieceAfter := int((file.Offset() + file.Length() - mb5) / pl)
+
+		lastStat := time.Now().Add(-time.Second)
+
+		for true {
+			t.muTorrent.Lock()
+			if t.Torrent == nil {
+				return
+			}
+			t.PreloadedBytes = t.Torrent.BytesCompleted()
+			t.muTorrent.Unlock()
+
+			stat := fmt.Sprint(file.Torrent().InfoHash().HexString(), " ", utils2.Format(float64(t.PreloadedBytes)), "/", utils2.Format(float64(t.PreloadSize)), " Speed:", utils2.Format(t.DownloadSpeed), " Peers:[", t.Torrent.Stats().ConnectedSeeders, "]", t.Torrent.Stats().ActivePeers, "/", t.Torrent.Stats().TotalPeers)
+			if time.Since(lastStat) > time.Second {
+				log.TLogln("Preload:", stat)
+				lastStat = time.Now()
+			}
+
+			isComplete := true
+			if readerPieceBefore >= pieceFileStart {
+				for i := pieceFileStart; i < readerPieceBefore; i++ {
+					if !t.Piece(i).State().Complete {
+						isComplete = false
+						if t.Piece(i).State().Priority == torrent.PiecePriorityNone {
+							t.Piece(i).SetPriority(torrent.PiecePriorityNormal)
+						}
+					}
+				}
+			}
+			if readerPieceAfter <= pieceFileEnd {
+				for i := readerPieceAfter; i <= pieceFileEnd; i++ {
+					if !t.Piece(i).State().Complete {
+						isComplete = false
+						if t.Piece(i).State().Priority == torrent.PiecePriorityNone {
+							t.Piece(i).SetPriority(torrent.PiecePriorityNormal)
+						}
+					}
+				}
+			}
+			t.AddExpiredTime(time.Second * time.Duration(settings.BTsets.TorrentDisconnectTimeout))
+			if isComplete {
+				break
+			}
+			time.Sleep(time.Millisecond * 10)
+		}
+	}
+	log.TLogln("End preload:", file.Torrent().InfoHash().HexString(), "Peers:[", t.Torrent.Stats().ConnectedSeeders, "]", t.Torrent.Stats().ActivePeers, "/", t.Torrent.Stats().TotalPeers)
+}
+
+func (t *Torrent) drop() {
+	t.muTorrent.Lock()
+	if t.Torrent != nil {
+		t.Torrent.Drop()
+		t.Torrent = nil
+	}
+	t.muTorrent.Unlock()
+}
+
+func (t *Torrent) Close() {
+	t.Stat = state.TorrentClosed
+
+	t.bt.mu.Lock()
+	if _, ok := t.bt.torrents[t.Hash()]; ok {
+		delete(t.bt.torrents, t.Hash())
+	}
+	t.bt.mu.Unlock()
+
+	t.drop()
+}
+
+func (t *Torrent) Status() *state.TorrentStatus {
+	t.muTorrent.Lock()
+	defer t.muTorrent.Unlock()
+
+	st := new(state.TorrentStatus)
+
+	st.Stat = t.Stat
+	st.StatString = t.Stat.String()
+	st.Title = t.Title
+	st.Poster = t.Poster
+	st.Data = t.Data
+	st.Timestamp = t.Timestamp
+	st.TorrentSize = t.Size
+
+	if t.TorrentSpec != nil {
+		st.Hash = t.TorrentSpec.InfoHash.HexString()
+	}
+	if t.Torrent != nil {
+		st.Name = t.Torrent.Name()
+		st.Hash = t.Torrent.InfoHash().HexString()
+		st.LoadedSize = t.Torrent.BytesCompleted()
+
+		st.PreloadedBytes = t.PreloadedBytes
+		st.PreloadSize = t.PreloadSize
+		st.DownloadSpeed = t.DownloadSpeed
+		st.UploadSpeed = t.UploadSpeed
+
+		tst := t.Torrent.Stats()
+		st.BytesWritten = tst.BytesWritten.Int64()
+		st.BytesWrittenData = tst.BytesWrittenData.Int64()
+		st.BytesRead = tst.BytesRead.Int64()
+		st.BytesReadData = tst.BytesReadData.Int64()
+		st.BytesReadUsefulData = tst.BytesReadUsefulData.Int64()
+		st.ChunksWritten = tst.ChunksWritten.Int64()
+		st.ChunksRead = tst.ChunksRead.Int64()
+		st.ChunksReadUseful = tst.ChunksReadUseful.Int64()
+		st.ChunksReadWasted = tst.ChunksReadWasted.Int64()
+		st.PiecesDirtiedGood = tst.PiecesDirtiedGood.Int64()
+		st.PiecesDirtiedBad = tst.PiecesDirtiedBad.Int64()
+		st.TotalPeers = tst.TotalPeers
+		st.PendingPeers = tst.PendingPeers
+		st.ActivePeers = tst.ActivePeers
+		st.ConnectedSeeders = tst.ConnectedSeeders
+		st.HalfOpenPeers = tst.HalfOpenPeers
+
+		if t.Torrent.Info() != nil {
+			st.TorrentSize = t.Torrent.Length()
+
+			files := t.Files()
+			sort.Slice(files, func(i, j int) bool {
+				return files[i].Path() < files[j].Path()
+			})
+			for i, f := range files {
+				st.FileStats = append(st.FileStats, &state.TorrentFileStat{
+					Id:     i + 1, // in web id 0 is undefined
+					Path:   f.Path(),
+					Length: f.Length(),
+				})
+			}
+		}
+	}
+	return st
+}
+
+func (t *Torrent) CacheState() *cacheSt.CacheState {
+	if t.Torrent != nil && t.cache != nil {
+		st := t.cache.GetState()
+		st.Torrent = t.Status()
+		return st
+	}
+	return nil
+}
+
+func (t *Torrent) findFileIndex(index int) *torrent.File {
+	st := t.Status()
+	var stFile *state.TorrentFileStat
+	for _, f := range st.FileStats {
+		if index == f.Id {
+			stFile = f
+			break
+		}
+	}
+	if stFile == nil {
+		return nil
+	}
+	for _, file := range t.Files() {
+		if file.Path() == stFile.Path {
+			return file
+		}
+	}
+	return nil
+}
--- a/server/torr/utils/blockedIP.go
+++ b/server/torr/utils/blockedIP.go
@@ -0,0 +1,35 @@
+package utils
+
+import (
+	"bufio"
+	"io/ioutil"
+	"path/filepath"
+	"strings"
+
+	"server/settings"
+
+	"github.com/anacrolix/torrent/iplist"
+)
+
+func ReadBlockedIP() (ranger iplist.Ranger, err error) {
+	buf, err := ioutil.ReadFile(filepath.Join(settings.Path, "blocklist"))
+	if err != nil {
+		return nil, err
+	}
+	scanner := bufio.NewScanner(strings.NewReader(string(buf)))
+	var ranges []iplist.Range
+	for scanner.Scan() {
+		r, ok, err := iplist.ParseBlocklistP2PLine(scanner.Bytes())
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			ranges = append(ranges, r)
+		}
+	}
+	err = scanner.Err()
+	if len(ranges) > 0 {
+		ranger = iplist.New(ranges)
+	}
+	return
+}
--- a/server/torr/utils/freemem.go
+++ b/server/torr/utils/freemem.go
@@ -0,0 +1,15 @@
+package utils
+
+import (
+	"runtime"
+	"runtime/debug"
+)
+
+func FreeOSMem() {
+	debug.FreeOSMemory()
+}
+
+func FreeOSMemGC() {
+	runtime.GC()
+	debug.FreeOSMemory()
+}
--- a/server/torr/utils/torrent.go
+++ b/server/torr/utils/torrent.go
@@ -0,0 +1,78 @@
+package utils
+
+import (
+	"encoding/base32"
+	"io/ioutil"
+	"math/rand"
+	"net/http"
+	"strings"
+
+	"golang.org/x/time/rate"
+)
+
+var defTrackers = []string{
+	"http://retracker.local",
+	"http://bt4.t-ru.org/ann?magnet",
+	"http://retracker.mgts.by:80/announce",
+	"http://tracker.city9x.com:2710/announce",
+	"http://tracker.electro-torrent.pl:80/announce",
+	"http://tracker.internetwarriors.net:1337/announce",
+	"http://tracker2.itzmx.com:6961/announce",
+	"udp://opentor.org:2710",
+	"udp://public.popcorn-tracker.org:6969/announce",
+	"udp://tracker.opentrackr.org:1337/announce",
+	"http://bt.svao-ix.ru/announce",
+	"udp://explodie.org:6969/announce",
+}
+
+var loadedTrackers []string
+
+func GetDefTrackers() []string {
+	loadNewTracker()
+	if len(loadedTrackers) == 0 {
+		return defTrackers
+	}
+	return loadedTrackers
+}
+
+func loadNewTracker() {
+	if len(loadedTrackers) > 0 {
+		return
+	}
+	resp, err := http.Get("https://raw.githubusercontent.com/ngosang/trackerslist/master/trackers_best_ip.txt")
+	if err == nil {
+		buf, err := ioutil.ReadAll(resp.Body)
+		if err == nil {
+			arr := strings.Split(string(buf), "\n")
+			var ret []string
+			for _, s := range arr {
+				s = strings.TrimSpace(s)
+				if len(s) > 0 {
+					ret = append(ret, s)
+				}
+			}
+			loadedTrackers = append(ret, defTrackers...)
+		}
+	}
+}
+
+func PeerIDRandom(peer string) string {
+	randomBytes := make([]byte, 32)
+	_, err := rand.Read(randomBytes)
+	if err != nil {
+		panic(err)
+	}
+	return peer + base32.StdEncoding.EncodeToString(randomBytes)[:20-len(peer)]
+}
+
+func Limit(i int) *rate.Limiter {
+	l := rate.NewLimiter(rate.Inf, 0)
+	if i > 0 {
+		b := i
+		if b < 16*1024 {
+			b = 16 * 1024
+		}
+		l = rate.NewLimiter(rate.Limit(i), b)
+	}
+	return l
+}
--- a/server/utils/filetypes.go
+++ b/server/utils/filetypes.go
@@ -0,0 +1,89 @@
+package utils
+
+import (
+	"path/filepath"
+
+	"server/torr/state"
+)
+
+var extVideo = map[string]interface{}{
+	".3g2":   nil,
+	".3gp":   nil,
+	".aaf":   nil,
+	".asf":   nil,
+	".avchd": nil,
+	".avi":   nil,
+	".drc":   nil,
+	".flv":   nil,
+	".m2ts":  nil,
+	".ts":    nil,
+	".m2v":   nil,
+	".m4p":   nil,
+	".m4v":   nil,
+	".mkv":   nil,
+	".mng":   nil,
+	".mov":   nil,
+	".mp2":   nil,
+	".mp4":   nil,
+	".mpe":   nil,
+	".mpeg":  nil,
+	".mpg":   nil,
+	".mpv":   nil,
+	".mxf":   nil,
+	".nsv":   nil,
+	".ogg":   nil,
+	".ogv":   nil,
+	".qt":    nil,
+	".rm":    nil,
+	".rmvb":  nil,
+	".roq":   nil,
+	".svi":   nil,
+	".vob":   nil,
+	".webm":  nil,
+	".wmv":   nil,
+	".yuv":   nil,
+}
+
+var extAudio = map[string]interface{}{
+	".aac":  nil,
+	".aiff": nil,
+	".ape":  nil,
+	".au":   nil,
+	".flac": nil,
+	".gsm":  nil,
+	".it":   nil,
+	".m3u":  nil,
+	".m4a":  nil,
+	".mid":  nil,
+	".mod":  nil,
+	".mp3":  nil,
+	".mpa":  nil,
+	".pls":  nil,
+	".ra":   nil,
+	".s3m":  nil,
+	".sid":  nil,
+	".wav":  nil,
+	".wma":  nil,
+	".xm":   nil,
+}
+
+func GetMimeType(filename string) string {
+	ext := filepath.Ext(filename)
+	if _, ok := extVideo[ext]; ok {
+		return "video/*"
+	}
+	if _, ok := extAudio[ext]; ok {
+		return "audio/*"
+	}
+	return "*/*"
+}
+
+func GetPlayableFiles(st state.TorrentStatus) []*state.TorrentFileStat {
+	files := make([]*state.TorrentFileStat, 0)
+	for _, f := range st.FileStats {
+		if GetMimeType(f.Path) != "*/*" {
+			files = append(files, f)
+		}
+	}
+	return files
+}
--- a/server/utils/prallel.go
+++ b/server/utils/prallel.go
@@ -0,0 +1,17 @@
+package utils
+
+import (
+	"sync"
+)
+
+func ParallelFor(begin, end int, fn func(i int)) {
+	var wg sync.WaitGroup
+	wg.Add(end - begin)
+	for i := begin; i < end; i++ {
+		go func(i int) {
+			fn(i)
+			wg.Done()
+		}(i)
+	}
+	wg.Wait()
+}
--- a/server/utils/strings.go
+++ b/server/utils/strings.go
@@ -0,0 +1,48 @@
+package utils
+
+import (
+	"fmt"
+	"strconv"
+)
+
+const (
+	_ = 1.0 << (10 * iota) // ignore first value by assigning to blank identifier
+	KB
+	MB
+	GB
+	TB
+	PB
+	EB
+)
+
+func Format(b float64) string {
+	multiple := ""
+	value := b
+
+	switch {
+	case b >= EB:
+		value /= EB
+		multiple = "EB"
+	case b >= PB:
+		value /= PB
+		multiple = "PB"
+	case b >= TB:
+		value /= TB
+		multiple = "TB"
+	case b >= GB:
+		value /= GB
+		multiple = "GB"
+	case b >= MB:
+		value /= MB
+		multiple = "MB"
+	case b >= KB:
+		value /= KB
+		multiple = "KB"
+	case b == 0:
+		return "0"
+	default:
+		return strconv.FormatInt(int64(b), 10) + "B"
+	}
+
+	return fmt.Sprintf("%.2f%s", value, multiple)
+}
--- a/server/version/version.go
+++ b/server/version/version.go
@@ -0,0 +1,3 @@
+package version
+
+const Version = "1.2.80_beta7.2"
--- a/server/web/api/cache.go
+++ b/server/web/api/cache.go
@@ -0,0 +1,51 @@
+package api
+
+import (
+	"net/http"
+
+	"server/torr"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+)
+
+//Action: get
+type cacheReqJS struct {
+	requestI
+	Hash string `json:"hash,omitempty"`
+}
+
+func cache(c *gin.Context) {
+	var req cacheReqJS
+	err := c.ShouldBindJSON(&req)
+	if err != nil {
+		c.AbortWithError(http.StatusBadRequest, err)
+		return
+	}
+	c.Status(http.StatusBadRequest)
+	switch req.Action {
+	case "get":
+		{
+			getCache(req, c)
+		}
+	}
+}
+
+func getCache(req cacheReqJS, c *gin.Context) {
+	if req.Hash == "" {
+		c.AbortWithError(http.StatusBadRequest, errors.New("hash is empty"))
+		return
+	}
+	tor := torr.GetTorrent(req.Hash)
+
+	if tor != nil {
+		st := tor.CacheState()
+		if st == nil {
+			c.JSON(200, struct{}{})
+		} else {
+			c.JSON(200, st)
+		}
+	} else {
+		c.Status(http.StatusNotFound)
+	}
+}
--- a/server/web/api/doc.go
+++ b/server/web/api/doc.go
@@ -0,0 +1,41 @@
+package api
+
+/*
+API
+
+respnose JSON{
+
+}
+request JSON{
+	Action string
+}
+
+echo version
+
+{
+	add torrent
+	remove torrent
+	list all torrents
+	get torrent
+	stream torrent
+} all in one function
+
+{
+	get viewed files mark in torrent
+	set viewed files mark in torrent
+	rem viewed files mark in torrent
+} all in one
+
+{
+	get m3u list of one torrent
+	get m3u list of one torrent and resume play
+	get m3u list of all torrent
+}
+
+{
+	get settings
+	set settings
+}
+
+???
+*/
--- a/server/web/api/m3u.go
+++ b/server/web/api/m3u.go
@@ -0,0 +1,125 @@
+package api
+
+import (
+	"bytes"
+	"fmt"
+	"net/http"
+	"net/url"
+	"path/filepath"
+	"sort"
+	"time"
+
+	"github.com/anacrolix/missinggo/httptoo"
+	sets "server/settings"
+	"server/torr"
+	"server/torr/state"
+	"server/utils"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+)
+
+func allPlayList(c *gin.Context) {
+	torrs := torr.ListTorrent()
+
+	host := "http://" + c.Request.Host
+	list := "#EXTM3U\n"
+	hash := ""
+	// fn=file.m3u fix forkplayer bug with end .m3u in link
+	for _, tr := range torrs {
+		list += "#EXTINF:0 type=\"playlist\"," + tr.Title + "\n"
+		list += host + "/stream/" + url.PathEscape(tr.Title) + ".m3u?link=" + tr.TorrentSpec.InfoHash.HexString() + "&m3u&fn=file.m3u\n"
+		hash += tr.Hash().HexString()
+	}
+
+	sendM3U(c, "all.m3u", hash, list)
+}
+
+// http://127.0.0.1:8090/playlist?hash=...
+// http://127.0.0.1:8090/playlist?hash=...&fromlast
+func playList(c *gin.Context) {
+	hash, _ := c.GetQuery("hash")
+	_, fromlast := c.GetQuery("fromlast")
+	if hash == "" {
+		c.AbortWithError(http.StatusBadRequest, errors.New("hash is empty"))
+		return
+	}
+
+	tor := torr.GetTorrent(hash)
+	if tor == nil {
+		c.AbortWithStatus(http.StatusNotFound)
+		return
+	}
+	if !tor.WaitInfo() {
+		c.AbortWithError(http.StatusInternalServerError, errors.New("error get torrent info"))
+		return
+	}
+
+	host := "http://" + c.Request.Host
+	list := getM3uList(tor.Status(), host, fromlast)
+	list = "#EXTM3U\n" + list
+
+	sendM3U(c, tor.Name()+".m3u", tor.Hash().HexString(), list)
+}
+
+func sendM3U(c *gin.Context, name, hash string, m3u string) {
+	c.Header("Content-Type", "audio/x-mpegurl")
+	c.Header("Connection", "close")
+	if hash != "" {
+		c.Header("ETag", httptoo.EncodeQuotedString(fmt.Sprintf("%s/%s", hash, name)))
+	}
+	if name == "" {
+		name = "playlist.m3u"
+	}
+	c.Header("Content-Disposition", `attachment; filename="`+name+`"`)
+	http.ServeContent(c.Writer, c.Request, name, time.Now(), bytes.NewReader([]byte(m3u)))
+	c.Status(200)
+}
+
+func getM3uList(tor *state.TorrentStatus, host string, fromLast bool) string {
+	m3u := ""
+	from := 0
+	if fromLast {
+		pos := searchLastPlayed(tor)
+		if pos != -1 {
+			from = pos
+		}
+	}
+	for i, f := range tor.FileStats {
+		if i >= from {
+			if utils.GetMimeType(f.Path) != "*/*" {
+				fn := filepath.Base(f.Path)
+				if fn == "" {
+					fn = f.Path
+				}
+				m3u += "#EXTINF:0," + fn + "\n"
+				name := filepath.Base(f.Path)
+				m3u += host + "/stream/" + url.PathEscape(name) + "?link=" + tor.Hash + "&index=" + fmt.Sprint(f.Id) + "&play\n"
+			}
+		}
+	}
+	return m3u
+}
+
+func searchLastPlayed(tor *state.TorrentStatus) int {
+	viewed := sets.ListViewed(tor.Hash)
+	if len(viewed) == 0 {
+		return -1
+	}
+	sort.Slice(viewed, func(i, j int) bool {
+		return viewed[i].FileIndex > viewed[j].FileIndex
+	})
+
+	lastViewedIndex := viewed[0].FileIndex
+
+	for i, stat := range tor.FileStats {
+		if stat.Id == lastViewedIndex {
+			if i >= len(tor.FileStats) {
+				return -1
+			}
+			return i
+		}
+	}
+
+	return -1
+}
--- a/server/web/api/route.go
+++ b/server/web/api/route.go
@@ -0,0 +1,55 @@
+package api
+
+import (
+	"net/http"
+	"time"
+
+	"github.com/gin-gonic/gin"
+	sets "server/settings"
+	"server/torr"
+	"server/version"
+)
+
+type requestI struct {
+	Action string `json:"action,omitempty"`
+}
+
+func SetupRoute(route *gin.Engine) {
+	route.GET("/echo", echo)
+	route.GET("/shutdown", shutdown)
+
+	route.POST("/settings", settings)
+
+	route.POST("/torrents", torrents)
+	route.POST("/torrent/upload", torrentUpload)
+
+	route.POST("/cache", cache)
+
+	route.HEAD("/stream", stream)
+	route.HEAD("/stream/*fname", stream)
+
+	route.GET("/stream", stream)
+	route.GET("/stream/*fname", stream)
+
+	route.POST("/viewed", viewed)
+
+	route.GET("/playlistall/all.m3u", allPlayList)
+	route.GET("/playlist", playList)
+	route.GET("/playlist/*fname", playList)
+}
+
+func echo(c *gin.Context) {
+	c.String(200, "%v", version.Version)
+}
+
+func shutdown(c *gin.Context) {
+	if sets.ReadOnly {
+		c.Status(http.StatusForbidden)
+		return
+	}
+	c.Status(200)
+	go func() {
+		time.Sleep(1000)
+		torr.Shutdown()
+	}()
+}
--- a/server/web/api/settings.go
+++ b/server/web/api/settings.go
@@ -0,0 +1,37 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+
+	sets "server/settings"
+	"server/torr"
+)
+
+//Action: get, set
+type setsReqJS struct {
+	requestI
+	Sets *sets.BTSets `json:"sets,omitempty"`
+}
+
+func settings(c *gin.Context) {
+	var req setsReqJS
+	err := c.ShouldBindJSON(&req)
+	if err != nil {
+		c.AbortWithError(http.StatusBadRequest, err)
+		return
+	}
+
+	if req.Action == "get" {
+		c.JSON(200, sets.BTsets)
+		return
+	}
+	if req.Action == "set" {
+		torr.SetSettings(req.Sets)
+		c.Status(200)
+		return
+	}
+	c.AbortWithError(http.StatusBadRequest, errors.New("action is empty"))
+}
--- a/server/web/api/stream.go
+++ b/server/web/api/stream.go
@@ -0,0 +1,113 @@
+package api
+
+import (
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+
+	"server/torr"
+	"server/web/api/utils"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+)
+
+// get stat
+// http://127.0.0.1:8090/stream/fname?link=...&stat
+// get m3u
+// http://127.0.0.1:8090/stream/fname?link=...&index=1&m3u
+// http://127.0.0.1:8090/stream/fname?link=...&index=1&m3u&fromlast
+// stream torrent
+// http://127.0.0.1:8090/stream/fname?link=...&index=1&play
+// http://127.0.0.1:8090/stream/fname?link=...&index=1&play&save
+// http://127.0.0.1:8090/stream/fname?link=...&index=1&play&save&title=...&poster=...
+// only save
+// http://127.0.0.1:8090/stream/fname?link=...&save&title=...&poster=...
+
+func stream(c *gin.Context) {
+	link := c.Query("link")
+	indexStr := c.Query("index")
+	_, preload := c.GetQuery("preload")
+	_, stat := c.GetQuery("stat")
+	_, save := c.GetQuery("save")
+	_, m3u := c.GetQuery("m3u")
+	_, fromlast := c.GetQuery("fromlast")
+	_, play := c.GetQuery("play")
+	title := c.Query("title")
+	poster := c.Query("poster")
+
+	if link == "" {
+		c.AbortWithError(http.StatusBadRequest, errors.New("link should not be empty"))
+		return
+	}
+
+	if title == "" {
+		title = c.Param("fname")
+		title, _ = url.PathUnescape(title)
+		title = strings.TrimLeft(title, "/")
+	} else {
+		title, _ = url.QueryUnescape(title)
+	}
+
+	link, _ = url.QueryUnescape(link)
+	poster, _ = url.QueryUnescape(poster)
+
+	spec, err := utils.ParseLink(link)
+	if err != nil {
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	tor, err := torr.AddTorrent(spec, title, poster, "")
+	if err != nil {
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	if !tor.GotInfo() {
+		c.AbortWithError(http.StatusInternalServerError, errors.New("timeout connection torrent"))
+		return
+	}
+
+	// save to db
+	if save {
+		torr.SaveTorrentToDB(tor)
+		c.Status(200) // only set status, not return
+	}
+
+	// find file
+	index := -1
+	if len(tor.Files()) == 1 {
+		index = 1
+	} else {
+		ind, err := strconv.Atoi(indexStr)
+		if err == nil {
+			index = ind
+		}
+	}
+	if index == -1 && play { // if file index not set and play file exec
+		c.AbortWithError(http.StatusBadRequest, errors.New("\"index\" is empty or wrong"))
+		return
+	}
+	// preload torrent
+	if preload {
+		torr.Preload(tor, index)
+	}
+	// return stat if query
+	if stat {
+		c.JSON(200, tor.Status())
+		return
+	} else
+	// return m3u if query
+	if m3u {
+		m3ulist := "#EXTM3U\n" + getM3uList(tor.Status(), "http://"+c.Request.Host, fromlast)
+		sendM3U(c, tor.Name()+".m3u", tor.Hash().HexString(), m3ulist)
+		return
+	} else
+	// return play if query
+	if play {
+		tor.Stream(index, c.Request, c.Writer)
+		return
+	}
+}
--- a/server/web/api/torrents.go
+++ b/server/web/api/torrents.go
@@ -0,0 +1,137 @@
+package api
+
+import (
+	"net/http"
+
+	"server/log"
+	"server/torr"
+	"server/torr/state"
+	"server/web/api/utils"
+
+	"github.com/gin-gonic/gin"
+	"github.com/pkg/errors"
+)
+
+//Action: add, get, rem, list, drop
+type torrReqJS struct {
+	requestI
+	Link     string `json:"link,omitempty"`
+	Hash     string `json:"hash,omitempty"`
+	Title    string `json:"title,omitempty"`
+	Poster   string `json:"poster,omitempty"`
+	Data     string `json:"data,omitempty"`
+	SaveToDB bool   `json:"save_to_db,omitempty"`
+}
+
+func torrents(c *gin.Context) {
+	var req torrReqJS
+	err := c.ShouldBindJSON(&req)
+	if err != nil {
+		c.AbortWithError(http.StatusBadRequest, err)
+		return
+	}
+	c.Status(http.StatusBadRequest)
+	switch req.Action {
+	case "add":
+		{
+			addTorrent(req, c)
+		}
+	case "get":
+		{
+			getTorrent(req, c)
+		}
+	case "rem":
+		{
+			remTorrent(req, c)
+		}
+	case "list":
+		{
+			listTorrent(req, c)
+		}
+	case "drop":
+		{
+			dropTorrent(req, c)
+		}
+	}
+}
+
+func addTorrent(req torrReqJS, c *gin.Context) {
+	if req.Link == "" {
+		c.AbortWithError(http.StatusBadRequest, errors.New("link is empty"))
+		return
+	}
+
+	log.TLogln("add torrent", req.Link)
+	torrSpec, err := utils.ParseLink(req.Link)
+	if err != nil {
+		log.TLogln("error add torrent:", err)
+		c.AbortWithError(http.StatusBadRequest, err)
+		return
+	}
+
+	tor, err := torr.AddTorrent(torrSpec, req.Title, req.Poster, req.Data)
+	if err != nil {
+		log.TLogln("error add torrent:", err)
+		c.AbortWithError(http.StatusInternalServerError, err)
+		return
+	}
+
+	go func() {
+		if !tor.GotInfo() {
+			log.TLogln("error add torrent:", "timeout connection torrent")
+			return
+		}
+
+		if req.SaveToDB {
+			torr.SaveTorrentToDB(tor)
+		}
+	}()
+
+	c.JSON(200, tor.Status())
+}
+
+func getTorrent(req torrReqJS, c *gin.Context) {
+	if req.Hash == "" {
+		c.AbortWithError(http.StatusBadRequest, errors.New("hash is empty"))
+		return
+	}
+	tor := torr.GetTorrent(req.Hash)
+
+	if tor != nil {
+		st := tor.Status()
+		c.JSON(200, st)
+	} else {
+		c.Status(http.StatusNotFound)
+	}
+}
+
+func remTorrent(req torrReqJS, c *gin.Context) {
+	if req.Hash == "" {
+		c.AbortWithError(http.StatusBadRequest, errors.New("hash is empty"))
+		return
+	}
+	torr.RemTorrent(req.Hash)
+	c.Status(200)
+}
+
+func listTorrent(req torrReqJS, c *gin.Context) {
+	list := torr.ListTorrent()
+	if list == nil {
+		c.JSON(200, []*state.TorrentStatus{})
+		return
+	}
+	var stats []*state.TorrentStatus
+	for _, tr := range list {
+		stats = append(stats, tr.Status())
+	}
+	c.JSON(200, stats)
+}
+
+func dropTorrent(req torrReqJS, c *gin.Context) {
+	if req.Hash == "" {
+		c.AbortWithError(http.StatusBadRequest, errors.New("hash is empty"))
+		return
+	}
+	torr.DropTorrent(req.Hash)
+	c.Status(200)
+}
--- a/server/web/api/upload.go
+++ b/server/web/api/upload.go
@@ -0,0 +1,70 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	"server/log"
+	"server/torr"
+	"server/web/api/utils"
+)
+
+func torrentUpload(c *gin.Context) {
+	form, err := c.MultipartForm()
+	if err != nil {
+		c.AbortWithError(http.StatusBadRequest, err)
+		return
+	}
+	defer form.RemoveAll()
+
+	save := len(form.Value["save"]) > 0
+	title := ""
+	if len(form.Value["title"]) > 0 {
+		title = form.Value["title"][0]
+	}
+	poster := ""
+	if len(form.Value["poster"]) > 0 {
+		poster = form.Value["poster"][0]
+	}
+	data := ""
+	if len(form.Value["data"]) > 0 {
+		data = form.Value["data"][0]
+	}
+	var tor *torr.Torrent
+	for name, file := range form.File {
+		log.TLogln("add torrent file", name)
+
+		torrFile, err := file[0].Open()
+		if err != nil {
+			log.TLogln("error upload torrent:", err)
+			continue
+		}
+		defer torrFile.Close()
+
+		spec, err := utils.ParseFile(torrFile)
+		if err != nil {
+			log.TLogln("error upload torrent:", err)
+			continue
+		}
+
+		tor, err = torr.AddTorrent(spec, title, poster, data)
+		if err != nil {
+			log.TLogln("error upload torrent:", err)
+			continue
+		}
+
+		go func() {
+			if !tor.GotInfo() {
+				log.TLogln("error add torrent:", "timeout connection torrent")
+				return
+			}
+
+			if save {
+				torr.SaveTorrentToDB(tor)
+			}
+		}()
+
+		break
+	}
+	c.JSON(200, tor.Status())
+}
--- a/server/web/api/utils/link.go
+++ b/server/web/api/utils/link.go
@@ -0,0 +1,133 @@
+package utils
+
+import (
+	"errors"
+	"fmt"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"runtime"
+	"strings"
+	"time"
+
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/metainfo"
+)
+
+func ParseFile(file multipart.File) (*torrent.TorrentSpec, error) {
+	minfo, err := metainfo.Load(file)
+	if err != nil {
+		return nil, err
+	}
+	info, err := minfo.UnmarshalInfo()
+	if err != nil {
+		return nil, err
+	}
+
+	mag := minfo.Magnet(info.Name, minfo.HashInfoBytes())
+	return &torrent.TorrentSpec{
+		InfoBytes:   minfo.InfoBytes,
+		Trackers:    [][]string{mag.Trackers},
+		DisplayName: info.Name,
+		InfoHash:    minfo.HashInfoBytes(),
+	}, nil
+}
+
+func ParseLink(link string) (*torrent.TorrentSpec, error) {
+	urlLink, err := url.Parse(link)
+	if err != nil {
+		return nil, err
+	}
+
+	switch strings.ToLower(urlLink.Scheme) {
+	case "magnet":
+		return fromMagnet(urlLink.String())
+	case "http", "https":
+		return fromHttp(urlLink.String())
+	case "":
+		return fromMagnet("magnet:?xt=urn:btih:" + urlLink.Path)
+	case "file":
+		return fromFile(urlLink.Path)
+	default:
+		err = fmt.Errorf("unknown scheme:", urlLink, urlLink.Scheme)
+	}
+	return nil, err
+}
+
+func fromMagnet(link string) (*torrent.TorrentSpec, error) {
+	mag, err := metainfo.ParseMagnetUri(link)
+	if err != nil {
+		return nil, err
+	}
+
+	var trackers [][]string
+	if len(mag.Trackers) > 0 {
+		trackers = [][]string{mag.Trackers}
+	}
+
+	return &torrent.TorrentSpec{
+		InfoBytes:   nil,
+		Trackers:    trackers,
+		DisplayName: mag.DisplayName,
+		InfoHash:    mag.InfoHash,
+	}, nil
+}
+
+func fromHttp(url string) (*torrent.TorrentSpec, error) {
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	client := new(http.Client)
+	client.Timeout = time.Duration(time.Second * 30)
+	req.Header.Set("User-Agent", "DWL/1.1.1 (Torrent)")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+	if resp.StatusCode != 200 {
+		return nil, errors.New(resp.Status)
+	}
+
+	minfo, err := metainfo.Load(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+	info, err := minfo.UnmarshalInfo()
+	if err != nil {
+		return nil, err
+	}
+	mag := minfo.Magnet(info.Name, minfo.HashInfoBytes())
+
+	return &torrent.TorrentSpec{
+		InfoBytes:   minfo.InfoBytes,
+		Trackers:    [][]string{mag.Trackers},
+		DisplayName: info.Name,
+		InfoHash:    minfo.HashInfoBytes(),
+	}, nil
+}
+
+func fromFile(path string) (*torrent.TorrentSpec, error) {
+	if runtime.GOOS == "windows" && strings.HasPrefix(path, "/") {
+		path = strings.TrimPrefix(path, "/")
+	}
+	minfo, err := metainfo.LoadFromFile(path)
+	if err != nil {
+		return nil, err
+	}
+	info, err := minfo.UnmarshalInfo()
+	if err != nil {
+		return nil, err
+	}
+
+	mag := minfo.Magnet(info.Name, minfo.HashInfoBytes())
+	return &torrent.TorrentSpec{
+		InfoBytes:   minfo.InfoBytes,
+		Trackers:    [][]string{mag.Trackers},
+		DisplayName: info.Name,
+		InfoHash:    minfo.HashInfoBytes(),
+	}, nil
+}
--- a/server/web/api/viewed.go
+++ b/server/web/api/viewed.go
@@ -0,0 +1,57 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/gin-gonic/gin"
+	sets "server/settings"
+)
+
+/*
+file index starts from 1
+*/
+
+// Action: set, rem, list
+type viewedReqJS struct {
+	requestI
+	*sets.Viewed
+}
+
+func viewed(c *gin.Context) {
+	var req viewedReqJS
+	err := c.ShouldBindJSON(&req)
+	if err != nil {
+		c.AbortWithError(http.StatusBadRequest, err)
+		return
+	}
+
+	switch req.Action {
+	case "set":
+		{
+			setViewed(req, c)
+		}
+	case "rem":
+		{
+			remViewed(req, c)
+		}
+	case "list":
+		{
+			listViewed(req, c)
+		}
+	}
+}
+
+func setViewed(req viewedReqJS, c *gin.Context) {
+	sets.SetViewed(req.Viewed)
+	c.Status(200)
+}
+
+func remViewed(req viewedReqJS, c *gin.Context) {
+	sets.RemViewed(req.Viewed)
+	c.Status(200)
+}
+
+func listViewed(req viewedReqJS, c *gin.Context) {
+	list := sets.ListViewed(req.Hash)
+	c.JSON(200, list)
+}
--- a/server/web/pages/route.go
+++ b/server/web/pages/route.go
@@ -0,0 +1,21 @@
+package pages
+
+import (
+	"github.com/gin-gonic/gin"
+	"server/torr"
+	"server/web/pages/template"
+)
+
+func SetupRoute(route *gin.Engine) {
+	route.GET("/", mainPage)
+	route.GET("/stat", statPage)
+}
+
+func mainPage(c *gin.Context) {
+	c.Data(200, "text/html; charset=utf-8", template.IndexHtml)
+}
+
+func statPage(c *gin.Context) {
+	torr.WriteStatus(c.Writer)
+	c.Status(200)
+}
--- a/server/web/pages/template/index_html.go
+++ b/server/web/pages/template/index_html.go
--- a/server/web/server.go
+++ b/server/web/server.go
@@ -0,0 +1,41 @@
+package web
+
+import (
+	"github.com/gin-contrib/cors"
+	"github.com/gin-gonic/gin"
+	"server/log"
+	"server/torr"
+	"server/version"
+	"server/web/api"
+	"server/web/pages"
+)
+
+var (
+	BTS      = torr.NewBTS()
+	waitChan = make(chan error)
+)
+
+func Start(port string) {
+	log.TLogln("Start TorrServer", version.Version)
+	err := BTS.Connect()
+	if err != nil {
+		waitChan <- err
+		return
+	}
+
+	route := gin.New()
+	route.Use(gin.Recovery(), cors.Default())
+	api.SetupRoute(route)
+	pages.SetupRoute(route)
+
+	waitChan <- route.Run(":" + port)
+}
+
+func Wait() error {
+	return <-waitChan
+}
+
+func Stop() {
+	BTS.Disconnect()
+	waitChan <- nil
+}