WIP Add support for custom torrents' approval storages

* migrate torrentapproval to list storage
* add initial support for torrent file storage (watch directory with fsnotify)
* replace frontend/http/bencode package with github.com/zeebo/bencode module
* sanitize code (fix warnings)

TODO:
* parse torrent files to get hashes,
* watch directory event types

DON'T use for now

middleware/torrentapproval/container/container.go

@@ -0,0 +1,53 @@
+package container
+
+import (
+	"errors"
+	"github.com/chihaya/chihaya/bittorrent"
+	"github.com/chihaya/chihaya/pkg/stop"
+	"gopkg.in/yaml.v2"
+	"sync"
+)
+
+type Builder interface {
+	New() (Container, error)
+}
+
+var (
+	buildersMU sync.Mutex
+	builders   = make(map[string]Builder)
+
+	ErrContainerDoesNotExist = errors.New("torrent hash container with that name does not exist")
+)
+
+func Register(n string, c Builder) {
+	if len(n) == 0 {
+		panic("middleware: could not register a Container with an empty name")
+	}
+	if c == nil {
+		panic("middleware: could not register a Container with nil builder")
+	}
+
+	buildersMU.Lock()
+	defer buildersMU.Unlock()
+	builders[n] = c
+}
+
+type Container interface {
+	stop.Stopper
+	Contains(bittorrent.InfoHash) bool
+}
+
+func GetContainer(name string, confBytes []byte) (Container, error) {
+	buildersMU.Lock()
+	defer buildersMU.Unlock()
+	var err error
+	var cn Container
+	if builder, exist := builders[name]; !exist {
+		err = ErrContainerDoesNotExist
+	} else {
+		if err = yaml.Unmarshal(confBytes, &cn); err == nil {
+			cn, err = builder.New()
+		}
+	}
+	return cn, err
+}

middleware/torrentapproval/container/directory/directory.go

@@ -0,0 +1,104 @@
+package directory
+
+import (
+	"fmt"
+	"github.com/chihaya/chihaya/bittorrent"
+	"github.com/chihaya/chihaya/middleware/torrentapproval/container"
+	"github.com/chihaya/chihaya/middleware/torrentapproval/container/list"
+	"github.com/chihaya/chihaya/pkg/log"
+	"github.com/chihaya/chihaya/pkg/stop"
+	"github.com/fsnotify/fsnotify"
+	"os"
+	"path/filepath"
+	"sync"
+)
+
+func init() {
+	container.Register("list", builder{})
+}
+
+type builder struct {
+	WhitelistPath string `yaml:"whitelist_path"`
+	BlacklistPath string `yaml:"blacklist_path"`
+}
+
+func (b builder) New() (container.Container, error) {
+	if len(b.WhitelistPath) > 0 && len(b.BlacklistPath) > 0 {
+		return nil, fmt.Errorf("using both whitelist and blacklist is invalid")
+	}
+	var err error
+	dirLister := &directory{
+		List: list.List{
+			Hashes: sync.Map{},
+			Invert: len(b.WhitelistPath) == 0,
+		},
+		files:   sync.Map{},
+		root:    b.WhitelistPath,
+		watcher: nil,
+	}
+	if dirLister.Invert {
+		dirLister.root = b.BlacklistPath
+	}
+	var w *fsnotify.Watcher
+	if w, err = fsnotify.NewWatcher(); err != nil {
+		return nil, fmt.Errorf("unable to initialize fsnotify mechanism")
+	}
+	if dirContent, err := os.ReadDir(dirLister.root); err != nil {
+		return nil, err
+	} else {
+		for _, f := range dirContent {
+			if !f.IsDir() {
+				if err = dirLister.processFile(f.Name(), false); err != nil {
+					log.Warn(err)
+				}
+			}
+		}
+	}
+	if err = w.Add(dirLister.root); err != nil {
+		_ = w.Close()
+		dirLister = nil
+	}
+	return dirLister, err
+}
+
+func (d *directory) watch() {
+	go func() {
+		for err := range d.watcher.Errors {
+			log.Error(err)
+		}
+	}()
+	go func() {
+		for event := range d.watcher.Events {
+			log.Debug(event.String())
+			//todo: implement event type parsing
+		}
+	}()
+}
+
+func (d *directory) processFile(name string, delete bool) error {
+	fullName := filepath.Join(d.root, name)
+	if delete {
+		if hash, found := d.files.Load(fullName); found{
+			d.Hashes.Delete(hash)
+		}
+	} else {
+		var hashBytes []byte
+		info := bittorrent.InfoHashFromBytes(hashBytes)
+		d.files.Store(fullName, info)
+		d.Hashes.Store(info, list.DUMMY)
+	}
+	return nil
+}
+
+type directory struct {
+	list.List
+	files   sync.Map
+	root    string
+	watcher *fsnotify.Watcher
+}
+
+func (d *directory) Stop() stop.Result {
+	ch := make(stop.Channel)
+	go ch.Done(d.watcher.Close())
+	return ch.Result()
+}

middleware/torrentapproval/container/list/list.go

@@ -0,0 +1,63 @@
+package list
+
+import (
+	"encoding/hex"
+	"fmt"
+	"github.com/chihaya/chihaya/bittorrent"
+	"github.com/chihaya/chihaya/middleware/torrentapproval/container"
+	"github.com/chihaya/chihaya/pkg/stop"
+	"sync"
+)
+
+func init() {
+	container.Register("list", Builder{})
+}
+
+type Builder struct {
+	Whitelist []string `yaml:"whitelist"`
+	Blacklist []string `yaml:"blacklist"`
+}
+
+var DUMMY struct{}
+
+func (b Builder) New() (container.Container, error) {
+	if len(b.Whitelist) > 0 && len(b.Blacklist) > 0 {
+		return nil, fmt.Errorf("using both whitelist and blacklist is invalid")
+	}
+	l := &List{
+		Hashes: sync.Map{},
+		Invert: len(b.Whitelist) == 0,
+	}
+
+	hashList := b.Whitelist
+	if l.Invert {
+		l.Invert = true
+		hashList = b.Blacklist
+	}
+
+	for _, hashString := range hashList {
+		hashinfo, err := hex.DecodeString(hashString)
+		if err != nil {
+			return nil, fmt.Errorf("whitelist : invalid hash %s", hashString)
+		}
+		if len(hashinfo) != 20 {
+			return nil, fmt.Errorf("whitelist : hash %s is not 20 byes", hashString)
+		}
+		l.Hashes.Store(bittorrent.InfoHashFromBytes(hashinfo), DUMMY)
+	}
+	return l, nil
+}
+
+type List struct {
+	Invert bool
+	Hashes sync.Map
+}
+
+func (l *List) Stop() stop.Result {
+	return stop.AlreadyStopped
+}
+
+func (l *List) Contains(hash bittorrent.InfoHash) bool {
+	_, result := l.Hashes.Load(hash)
+	return result != l.Invert
+}