initial

src/server/settings/DB.go

@@ -0,0 +1,52 @@
+package settings
+
+import (
+	"fmt"
+	"path/filepath"
+
+	"github.com/boltdb/bolt"
+)
+
+var (
+	db             *bolt.DB
+	dbInfosName    = []byte("Infos")
+	dbTorrentsName = []byte("Torrents")
+	dbSettingsName = []byte("Settings")
+	Path           string
+)
+
+func openDB() error {
+	if db != nil {
+		return nil
+	}
+
+	var err error
+	db, err = bolt.Open(filepath.Join(Path, "torrserver.db"), 0666, nil)
+	if err != nil {
+		fmt.Print(err)
+		return err
+	}
+
+	err = db.Update(func(tx *bolt.Tx) error {
+		_, err = tx.CreateBucketIfNotExists(dbSettingsName)
+		if err != nil {
+			return fmt.Errorf("could not create Settings bucket: %v", err)
+		}
+		_, err = tx.CreateBucketIfNotExists(dbTorrentsName)
+		if err != nil {
+			return fmt.Errorf("could not create Torrents bucket: %v", err)
+		}
+		return nil
+	})
+	if err != nil {
+		CloseDB()
+	}
+	return err
+}
+
+func CloseDB() {
+	if db != nil {
+		db.Close()
+		db = nil
+	}
+}

src/server/settings/Info.go

@@ -0,0 +1,61 @@
+package settings
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/boltdb/bolt"
+)
+
+func AddInfo(hash, info string) error {
+	err := openDB()
+	if err != nil {
+		return err
+	}
+
+	hash = strings.ToUpper(hash)
+	return db.Update(func(tx *bolt.Tx) error {
+		dbt, err := tx.CreateBucketIfNotExists([]byte(dbInfosName))
+		if err != nil {
+			return err
+		}
+
+		dbi, err := dbt.CreateBucketIfNotExists([]byte(hash))
+		if err != nil {
+			return err
+		}
+
+		err = dbi.Put([]byte("Info"), []byte(info))
+		if err != nil {
+			return fmt.Errorf("error save torrent info %v", err)
+		}
+		return nil
+	})
+}
+
+func GetInfo(hash string) string {
+	err := openDB()
+	if err != nil {
+		return "{}"
+	}
+
+	hash = strings.ToUpper(hash)
+	ret := "{}"
+	err = db.View(func(tx *bolt.Tx) error {
+		hdb := tx.Bucket(dbInfosName)
+		if hdb == nil {
+			return fmt.Errorf("could not find torrent info")
+		}
+		hdb = hdb.Bucket([]byte(hash))
+		if hdb != nil {
+			info := hdb.Get([]byte("Info"))
+			if info == nil {
+				return fmt.Errorf("error get torrent info")
+			}
+			ret = string(info)
+			return nil
+		}
+		return nil
+	})
+	return ret
+}

src/server/settings/Settings.go

@@ -0,0 +1,102 @@
+package settings
+
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+
+	"github.com/boltdb/bolt"
+)
+
+var (
+	sets      *Settings
+	StartTime time.Time
+)
+
+func init() {
+	sets = new(Settings)
+	sets.CacheSize = 200 * 1024 * 1024
+	sets.PreloadBufferSize = 20 * 1024 * 1024
+	sets.ConnectionsLimit = 100
+	sets.RetrackersMode = 1
+	sets.DisableDHT = true
+	StartTime = time.Now()
+}
+
+type Settings struct {
+	CacheSize         int64 // in byte, def 200 mb
+	PreloadBufferSize int64 // in byte, buffer for preload
+
+	RetrackersMode int //0 - don`t add, 1 - add retrackers, 2 - remove retrackers
+
+	//BT Config
+	DisableTCP        bool
+	DisableUTP        bool
+	DisableUPNP       bool
+	DisableDHT        bool
+	DisableUpload     bool
+	Encryption        int // 0 - Enable, 1 - disable, 2 - force
+	DownloadRateLimit int // in kb, 0 - inf
+	UploadRateLimit   int // in kb, 0 - inf
+	ConnectionsLimit  int
+}
+
+func Get() *Settings {
+	return sets
+}
+
+func (s *Settings) String() string {
+	buf, _ := json.MarshalIndent(sets, "", " ")
+	return string(buf)
+}
+
+func ReadSettings() error {
+	err := openDB()
+	if err != nil {
+		return err
+	}
+	buf := make([]byte, 0)
+	err = db.View(func(tx *bolt.Tx) error {
+		sdb := tx.Bucket(dbSettingsName)
+		if sdb == nil {
+			return fmt.Errorf("error load settings")
+		}
+
+		buf = sdb.Get([]byte("json"))
+		if buf == nil {
+			return fmt.Errorf("error load settings")
+		}
+		return nil
+	})
+	err = json.Unmarshal(buf, sets)
+	if err != nil {
+		return err
+	}
+	if sets.ConnectionsLimit <= 0 {
+		sets.ConnectionsLimit = 50
+	}
+	if sets.CacheSize <= 0 {
+		sets.CacheSize = 200 * 1024 * 1024
+	}
+	return nil
+}
+
+func SaveSettings() error {
+	err := openDB()
+	if err != nil {
+		return err
+	}
+
+	buf, err := json.Marshal(sets)
+	if err != nil {
+		return err
+	}
+
+	return db.Update(func(tx *bolt.Tx) error {
+		setsDB, err := tx.CreateBucketIfNotExists(dbSettingsName)
+		if err != nil {
+			return err
+		}
+		return setsDB.Put([]byte("json"), []byte(buf))
+	})
+}

src/server/settings/Torrent.go

@@ -0,0 +1,292 @@
+package settings
+
+import (
+	"encoding/binary"
+	"fmt"
+
+	"github.com/boltdb/bolt"
+)
+
+type Torrent struct {
+	Name      string
+	Magnet    string
+	Hash      string
+	Size      int64
+	Timestamp int64
+
+	Files []File
+}
+
+type File struct {
+	Name   string
+	Size   int64
+	Viewed bool
+}
+
+func SetViewed(hash, filename string) error {
+	err := openDB()
+	if err != nil {
+		return err
+	}
+
+	return db.Update(func(tx *bolt.Tx) error {
+		dbt := tx.Bucket(dbTorrentsName)
+		if dbt == nil {
+			return fmt.Errorf("could not find torrent")
+		}
+		hdb := dbt.Bucket([]byte(hash))
+		if hdb == nil {
+			return fmt.Errorf("could not find torrent")
+		}
+
+		fdb := hdb.Bucket([]byte("Files"))
+		if fdb == nil {
+			return fmt.Errorf("could not find torrent")
+		}
+
+		fdb = fdb.Bucket([]byte(filename))
+		if fdb == nil {
+			return fmt.Errorf("could not find torrent")
+		}
+
+		err = fdb.Put([]byte("Viewed"), []byte{1})
+		if err != nil {
+			return fmt.Errorf("error save torrent %v", err)
+		}
+		return nil
+	})
+}
+
+func SaveTorrentDB(torrent *Torrent) error {
+	err := openDB()
+	if err != nil {
+		return err
+	}
+
+	return db.Update(func(tx *bolt.Tx) error {
+		dbt, err := tx.CreateBucketIfNotExists(dbTorrentsName)
+		if err != nil {
+			return fmt.Errorf("could not create Torrents bucket: %v", err)
+		}
+		fmt.Println("Save torrent:", torrent.Name)
+		hdb, err := dbt.CreateBucketIfNotExists([]byte(torrent.Hash))
+		if err != nil {
+			return fmt.Errorf("could not create Torrent bucket: %v", err)
+		}
+
+		err = hdb.Put([]byte("Name"), []byte(torrent.Name))
+		if err != nil {
+			return fmt.Errorf("error save torrent: %v", err)
+		}
+		err = hdb.Put([]byte("Link"), []byte(torrent.Magnet))
+		if err != nil {
+			return fmt.Errorf("error save torrent: %v", err)
+		}
+		err = hdb.Put([]byte("Size"), i2b(torrent.Size))
+		if err != nil {
+			return fmt.Errorf("error save torrent: %v", err)
+		}
+		err = hdb.Put([]byte("Timestamp"), i2b(torrent.Timestamp))
+		if err != nil {
+			return fmt.Errorf("error save torrent: %v", err)
+		}
+
+		fdb, err := hdb.CreateBucketIfNotExists([]byte("Files"))
+		if err != nil {
+			return fmt.Errorf("error save torrent files: %v", err)
+		}
+
+		for _, f := range torrent.Files {
+			ffdb, err := fdb.CreateBucketIfNotExists([]byte(f.Name))
+			if err != nil {
+				return fmt.Errorf("error save torrent files: %v", err)
+			}
+			err = ffdb.Put([]byte("Size"), i2b(f.Size))
+			if err != nil {
+				return fmt.Errorf("error save torrent files: %v", err)
+			}
+
+			b := 0
+			if f.Viewed {
+				b = 1
+			}
+
+			err = ffdb.Put([]byte("Viewed"), []byte{byte(b)})
+			if err != nil {
+				return fmt.Errorf("error save torrent files: %v", err)
+			}
+		}
+
+		return nil
+	})
+}
+
+func RemoveTorrentDB(hash string) error {
+	err := openDB()
+	if err != nil {
+		return err
+	}
+
+	return db.Update(func(tx *bolt.Tx) error {
+		dbt := tx.Bucket(dbTorrentsName)
+		if dbt == nil {
+			return fmt.Errorf("could not find torrent")
+		}
+
+		return dbt.DeleteBucket([]byte(hash))
+	})
+}
+
+func LoadTorrentDB(hash string) (*Torrent, error) {
+	err := openDB()
+	if err != nil {
+		return nil, err
+	}
+
+	var torr *Torrent
+	err = db.View(func(tx *bolt.Tx) error {
+		hdb := tx.Bucket(dbTorrentsName)
+		if hdb == nil {
+			return fmt.Errorf("could not find torrent")
+		}
+		hdb = hdb.Bucket([]byte(hash))
+		if hdb != nil {
+			torr = new(Torrent)
+			torr.Hash = string(hash)
+			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)
+
+			fdb := hdb.Bucket([]byte("Files"))
+			if fdb == nil {
+				return fmt.Errorf("error load torrent files")
+			}
+			cf := fdb.Cursor()
+			for fn, _ := cf.First(); fn != nil; fn, _ = cf.Next() {
+				file := File{Name: string(fn)}
+				ffdb := fdb.Bucket(fn)
+				if ffdb == nil {
+					return fmt.Errorf("error load torrent files")
+				}
+
+				tmp := ffdb.Get([]byte("Size"))
+				if tmp == nil {
+					return fmt.Errorf("error load torrent file")
+				}
+				file.Size = b2i(tmp)
+
+				tmp = ffdb.Get([]byte("Viewed"))
+				if tmp == nil {
+					return fmt.Errorf("error load torrent file")
+				}
+				file.Viewed = len(tmp) > 0 && tmp[0] == 1
+				torr.Files = append(torr.Files, file)
+			}
+			SortFiles(torr.Files)
+		}
+		return nil
+	})
+	return torr, err
+}
+
+func LoadTorrentsDB() ([]*Torrent, error) {
+	err := openDB()
+	if err != nil {
+		return nil, err
+	}
+
+	torrs := make([]*Torrent, 0)
+	err = db.View(func(tx *bolt.Tx) error {
+		tdb := tx.Bucket(dbTorrentsName)
+		c := tdb.Cursor()
+		for h, _ := c.First(); h != nil; h, _ = c.Next() {
+			hdb := tdb.Bucket(h)
+			if hdb != nil {
+				torr := new(Torrent)
+				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)
+
+				fdb := hdb.Bucket([]byte("Files"))
+				if fdb == nil {
+					return fmt.Errorf("error load torrent files")
+				}
+				cf := fdb.Cursor()
+				for fn, _ := cf.First(); fn != nil; fn, _ = cf.Next() {
+					file := File{Name: string(fn)}
+					ffdb := fdb.Bucket(fn)
+					if ffdb == nil {
+						return fmt.Errorf("error load torrent files")
+					}
+					tmp := ffdb.Get([]byte("Size"))
+					if tmp == nil {
+						return fmt.Errorf("error load torrent file")
+					}
+					file.Size = b2i(tmp)
+
+					tmp = ffdb.Get([]byte("Viewed"))
+					if tmp == nil {
+						return fmt.Errorf("error load torrent file")
+					}
+					file.Viewed = len(tmp) > 0 && tmp[0] == 1
+					torr.Files = append(torr.Files, file)
+				}
+				SortFiles(torr.Files)
+				torrs = append(torrs, torr)
+			}
+		}
+		return nil
+	})
+	return torrs, err
+}
+
+func i2b(v int64) []byte {
+	b := make([]byte, 8)
+	binary.BigEndian.PutUint64(b, uint64(v))
+	return b
+}
+
+func b2i(v []byte) int64 {
+	return int64(binary.BigEndian.Uint64(v))
+}

src/server/settings/UsableFiles.go

@@ -0,0 +1,88 @@
+package settings
+
+import (
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+var (
+	uFiles = map[string]interface{}{
+		".3g2":   nil,
+		".3gp":   nil,
+		".aaf":   nil,
+		".asf":   nil,
+		".avchd": nil,
+		".avi":   nil,
+		".drc":   nil,
+		".flv":   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,
+		".ts":    nil,
+		".m2ts":  nil,
+		".mts":   nil,
+		".qt":    nil,
+		".rm":    nil,
+		".rmvb":  nil,
+		".roq":   nil,
+		".svi":   nil,
+		".vob":   nil,
+		".webm":  nil,
+		".wmv":   nil,
+		".yuv":   nil,
+
+		".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 SortFiles(files []File) {
+	sort.Slice(files, func(i, j int) bool {
+		if haveUsable(files[i].Name) && !haveUsable(files[j].Name) {
+			return true
+		}
+		if !haveUsable(files[i].Name) && haveUsable(files[j].Name) {
+			return false
+		}
+
+		return files[i].Name < files[j].Name
+	})
+}
+
+func haveUsable(name string) bool {
+	ext := strings.ToLower(filepath.Ext(name))
+	_, ok := uFiles[ext]
+	return ok
+}