feta/storage/tootstore.go

package storage

import "errors"
import "io/ioutil"
import "os"
import "strings"
import "sync"

import "github.com/sneak/feta/toot"

// TootStorageBackend is the interface to which storage backends must
// conform for storing toots
type TootStorageBackend interface {
	TootExists(t toot.Toot) bool
	StoreToot(t toot.Toot) error
	StoreToots(tc []*toot.Toot) error
}

// TootFSStorage is a TootStorageBackend that writes to the local
// filesystem.
type TootFSStorage struct {
	root string
}

// NewTootFSStorage returns a *TootFSStorage for writing toots to the
// local filesystem
func NewTootFSStorage(root string) *TootFSStorage {
	ts := new(TootFSStorage)
	ts.root = root
	return ts
}

// StoreToots writes a slice of pointers to toots to disk
func (ts *TootFSStorage) StoreToots(tc []*toot.Toot) error {
	var returnErrors []string
	for _, item := range tc {
		err := ts.StoreToot(*item)
		if err != nil {
			returnErrors = append(returnErrors, err.Error())
			continue
		}
	}
	if len(returnErrors) == 0 {
		return nil
	}
	return errors.New(strings.Join(returnErrors, "; "))
}

// TootExists checks to see if we have already written a toot to disk or
// not.  Note that the ingester de-dupes with a table in memory so that this
// will only really get used on app restarts
func (ts *TootFSStorage) TootExists(t toot.Toot) bool {
	path := t.DiskStoragePath()
	full := ts.root + "/" + path
	_, err := os.Stat(full)
	if os.IsNotExist(err) {
		return false
	}
	return true
}

// StoreToot writes a single toot to disk
func (ts *TootFSStorage) StoreToot(t toot.Toot) error {
	path := t.DiskStoragePath()
	full := ts.root + "/" + path
	return ioutil.WriteFile(full, t.Original, 0644)
}

// TootMemoryStorage is a TootStorageBackend that just stores all ingested
// toots in ram forever until the computer fills up and catches fire and explodes
type TootMemoryStorage struct {
	sync.Mutex
	toots map[toot.Hash]toot.Toot
	//maxSize uint   // FIXME support eviction
}

// NewTootMemoryStorage returns a *TootMemoryStorage for storing toots in
// ram forever
func NewTootMemoryStorage() *TootMemoryStorage {
	ts := new(TootMemoryStorage)
	ts.toots = make(map[toot.Hash]toot.Toot)
	return ts
}

// StoreToot saves a single toot into an in-memory hashtable
func (ts *TootMemoryStorage) StoreToot(t toot.Toot) {
	if ts.TootExists(t) {
		return
	}
	ts.Lock()
	defer ts.Unlock()
	ts.toots[t.Hash] = t
	return
}

// TootExists checks to see if we have a toot in memory already
func (ts *TootMemoryStorage) TootExists(t toot.Toot) bool {
	ts.Lock()
	defer ts.Unlock()
	if _, ok := ts.toots[t.Hash]; ok { //this syntax is so gross
		return true
	}
	return false
}