mirror of
https://github.com/octoleo/restic.git
synced 2024-12-22 10:58:55 +00:00
145 lines
3.3 KiB
Go
145 lines
3.3 KiB
Go
package restic
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/restic/restic/backend"
|
|
)
|
|
|
|
type Server struct {
|
|
be backend.Backend
|
|
key *Key
|
|
}
|
|
|
|
func NewServer(be backend.Backend) Server {
|
|
return Server{be: be}
|
|
}
|
|
|
|
func NewServerWithKey(be backend.Backend, key *Key) Server {
|
|
return Server{be: be, key: key}
|
|
}
|
|
|
|
// Each lists all entries of type t in the backend and calls function f() with
|
|
// the id and data.
|
|
func (s Server) Each(t backend.Type, f func(id backend.ID, data []byte, err error)) error {
|
|
return backend.Each(s.be, t, f)
|
|
}
|
|
|
|
// Each lists all entries of type t in the backend and calls function f() with
|
|
// the id.
|
|
func (s Server) EachID(t backend.Type, f func(backend.ID)) error {
|
|
return backend.EachID(s.be, t, f)
|
|
}
|
|
|
|
// Find loads the list of all blobs of type t and searches for IDs which start
|
|
// with prefix. If none is found, nil and ErrNoIDPrefixFound is returned. If
|
|
// more than one is found, nil and ErrMultipleIDMatches is returned.
|
|
func (s Server) Find(t backend.Type, prefix string) (backend.ID, error) {
|
|
return backend.Find(s.be, t, prefix)
|
|
}
|
|
|
|
// FindSnapshot takes a string and tries to find a snapshot whose ID matches
|
|
// the string as closely as possible.
|
|
func (s Server) FindSnapshot(id string) (backend.ID, error) {
|
|
return backend.FindSnapshot(s.be, id)
|
|
}
|
|
|
|
// PrefixLength returns the number of bytes required so that all prefixes of
|
|
// all IDs of type t are unique.
|
|
func (s Server) PrefixLength(t backend.Type) (int, error) {
|
|
return backend.PrefixLength(s.be, t)
|
|
}
|
|
|
|
// Returns the backend used for this server.
|
|
func (s Server) Backend() backend.Backend {
|
|
return s.be
|
|
}
|
|
|
|
func (s *Server) SearchKey(password string) error {
|
|
key, err := SearchKey(*s, password)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
s.key = key
|
|
|
|
return nil
|
|
}
|
|
|
|
func (s Server) Decrypt(ciphertext []byte) ([]byte, error) {
|
|
if s.key == nil {
|
|
return nil, errors.New("key for server not set")
|
|
}
|
|
|
|
return s.key.Decrypt(ciphertext)
|
|
}
|
|
|
|
func (s Server) Encrypt(ciphertext, plaintext []byte) (int, error) {
|
|
if s.key == nil {
|
|
return 0, errors.New("key for server not set")
|
|
}
|
|
|
|
return s.key.Encrypt(ciphertext, plaintext)
|
|
}
|
|
|
|
func (s Server) Key() *Key {
|
|
return s.key
|
|
}
|
|
|
|
// Each calls Each() with the given parameters, Decrypt() on the ciphertext
|
|
// and, on successful decryption, f with the plaintext.
|
|
func (s Server) EachDecrypted(t backend.Type, f func(backend.ID, []byte, error)) error {
|
|
if s.key == nil {
|
|
return errors.New("key for server not set")
|
|
}
|
|
|
|
return s.Each(t, func(id backend.ID, data []byte, e error) {
|
|
if e != nil {
|
|
f(id, nil, e)
|
|
return
|
|
}
|
|
|
|
buf, err := s.key.Decrypt(data)
|
|
if err != nil {
|
|
f(id, nil, err)
|
|
return
|
|
}
|
|
|
|
f(id, buf, nil)
|
|
})
|
|
}
|
|
|
|
// Proxy methods to backend
|
|
|
|
func (s Server) List(t backend.Type) (backend.IDs, error) {
|
|
return s.be.List(t)
|
|
}
|
|
|
|
func (s Server) Get(t backend.Type, id backend.ID) ([]byte, error) {
|
|
return s.be.Get(t, id)
|
|
}
|
|
|
|
func (s Server) Create(t backend.Type, data []byte) (backend.ID, error) {
|
|
return s.be.Create(t, data)
|
|
}
|
|
|
|
func (s Server) Test(t backend.Type, id backend.ID) (bool, error) {
|
|
return s.be.Test(t, id)
|
|
}
|
|
|
|
func (s Server) Remove(t backend.Type, id backend.ID) error {
|
|
return s.be.Remove(t, id)
|
|
}
|
|
|
|
func (s Server) Close() error {
|
|
return s.be.Close()
|
|
}
|
|
|
|
func (s Server) Delete() error {
|
|
if b, ok := s.be.(backend.Deleter); ok {
|
|
return b.Delete()
|
|
}
|
|
|
|
return errors.New("Delete() called for backend that does not implement this method")
|
|
}
|