package khepri import ( "encoding/json" "errors" "io" "io/ioutil" "os" "github.com/fd0/khepri/backend" "github.com/fd0/khepri/chunker" ) type ContentHandler struct { be backend.Server key *Key content *StorageMap } // NewContentHandler creates a new content handler. func NewContentHandler(be backend.Server, key *Key) (*ContentHandler, error) { ch := &ContentHandler{ be: be, key: key, content: NewStorageMap(), } return ch, nil } // LoadSnapshot adds all blobs from a snapshot into the content handler and returns the snapshot. func (ch *ContentHandler) LoadSnapshot(id backend.ID) (*Snapshot, error) { sn, err := LoadSnapshot(ch, id) if err != nil { return nil, err } ch.content.Merge(sn.StorageMap) return sn, nil } // LoadAllSnapshots adds all blobs from all snapshots that can be decrypted // into the content handler. func (ch *ContentHandler) LoadAllSnapshots() error { // add all maps from all snapshots that can be decrypted to the storage map err := backend.EachID(ch.be, backend.Snapshot, func(id backend.ID) { sn, err := LoadSnapshot(ch, id) if err != nil { return } ch.content.Merge(sn.StorageMap) }) if err != nil { return err } return nil } // Save encrypts data and stores it to the backend as type t. If the data was // already saved before, the blob is returned. func (ch *ContentHandler) Save(t backend.Type, data []byte) (*Blob, error) { // compute plaintext hash id := backend.Hash(data) // test if the hash is already in the backend blob := ch.content.Find(id) if blob != nil { return blob, nil } // else create a new blob blob = &Blob{ ID: id, Size: uint64(len(data)), } // encrypt blob ciphertext, err := ch.key.Encrypt(data) if err != nil { return nil, err } // save blob sid, err := ch.be.Create(t, ciphertext) if err != nil { return nil, err } blob.Storage = sid blob.StorageSize = uint64(len(ciphertext)) // insert blob into the storage map ch.content.Insert(blob) return blob, nil } // SaveJSON serialises item as JSON and uses Save() to store it to the backend as type t. func (ch *ContentHandler) SaveJSON(t backend.Type, item interface{}) (*Blob, error) { // convert to json data, err := json.Marshal(item) if err != nil { return nil, err } // compress and save data return ch.Save(t, backend.Compress(data)) } // SaveFile stores the content of the file on the backend as a Blob by calling // Save for each chunk. func (ch *ContentHandler) SaveFile(filename string, size uint) (Blobs, error) { file, err := os.Open(filename) defer file.Close() if err != nil { return nil, err } // if the file is small enough, store it directly if size < chunker.MinSize { buf, err := ioutil.ReadAll(file) if err != nil { return nil, err } blob, err := ch.Save(backend.Blob, buf) if err != nil { return nil, err } return Blobs{blob}, nil } // else store all chunks blobs := Blobs{} chunker := chunker.New(file) for { chunk, err := chunker.Next() if err == io.EOF { break } if err != nil { return nil, err } blob, err := ch.Save(backend.Blob, chunk.Data) if err != nil { return nil, err } blobs = append(blobs, blob) } return blobs, nil } // Load tries to load and decrypt content identified by t and id from the backend. func (ch *ContentHandler) Load(t backend.Type, id backend.ID) ([]byte, error) { if t == backend.Snapshot { // load data buf, err := ch.be.Get(t, id) if err != nil { return nil, err } // decrypt buf, err = ch.key.Decrypt(buf) if err != nil { return nil, err } return buf, nil } // lookup storage hash blob := ch.content.Find(id) if blob == nil { return nil, errors.New("Storage ID not found") } // load data buf, err := ch.be.Get(t, blob.Storage) if err != nil { return nil, err } // check length if len(buf) != int(blob.StorageSize) { return nil, errors.New("Invalid storage length") } // decrypt buf, err = ch.key.Decrypt(buf) if err != nil { return nil, err } // check length if len(buf) != int(blob.Size) { return nil, errors.New("Invalid length") } return buf, nil } // LoadJSON calls Load() to get content from the backend and afterwards calls // json.Unmarshal on the item. func (ch *ContentHandler) LoadJSON(t backend.Type, id backend.ID, item interface{}) error { // load from backend buf, err := ch.Load(t, id) if err != nil { return err } // inflate and unmarshal err = json.Unmarshal(backend.Uncompress(buf), item) return err } // LoadJSONRaw loads data with the given storage id and type from the backend, // decrypts it and calls json.Unmarshal on the item. func (ch *ContentHandler) LoadJSONRaw(t backend.Type, id backend.ID, item interface{}) error { // load data buf, err := ch.be.Get(t, id) if err != nil { return err } // decrypt buf, err = ch.key.Decrypt(buf) if err != nil { return err } // inflate and unmarshal err = json.Unmarshal(backend.Uncompress(buf), item) return err }