Example #1
0
func (app *App) OpenKV(tx *db.Tx, storage *db.VolumeStorage) (kv.KV, error) {
	var kvstores []kv.KV

	c := storage.Cursor()
	for item := c.First(); item != nil; item = c.Next() {
		backend, err := item.Backend()
		if err != nil {
			return nil, err
		}
		s, err := app.openStorage(backend)
		if err != nil {
			return nil, err
		}

		sharingKeyName, err := item.SharingKeyName()
		if err != nil {
			return nil, err
		}
		sharingKey, err := tx.SharingKeys().Get(sharingKeyName)
		if err != nil {
			return nil, fmt.Errorf("getting sharing key %q: %v", sharingKeyName, err)
		}
		var secret [32]byte
		sharingKey.Secret(&secret)
		s = untrusted.New(s, &secret)

		kvstores = append(kvstores, s)
	}

	return kvmulti.New(kvstores...), nil
}
Example #2
0
func TestPut(t *testing.T) {
	a := &kvmock.InMemory{}
	b := &kvmock.InMemory{}
	multi := kvmulti.New(a, b)
	if err := multi.Put([]byte("k1"), []byte("v1")); err != nil {
		t.Fatal(err)
	}
	if !reflect.DeepEqual(a.Data, map[string]string{"k1": "v1"}) {
		t.Errorf("bad data in a: %v", a.Data)
	}
	if !reflect.DeepEqual(b.Data, map[string]string{"k1": "v1"}) {
		t.Errorf("bad data in b: %v", a.Data)
	}
}
Example #3
0
func TestGetFallback(t *testing.T) {
	a := &kvmock.InMemory{}
	b := &kvmock.InMemory{}
	multi := kvmulti.New(a, b)
	if err := b.Put([]byte("k1"), []byte("v1")); err != nil {
		t.Fatal(err)
	}
	v, err := multi.Get([]byte("k1"))
	if err != nil {
		t.Error(err)
	}
	if g, e := string(v), "v1"; g != e {
		t.Errorf("bad value: %q != %q", g, e)
	}
}
Example #4
0
// Open key-value stores as allowed for this peer. Uses the opener
// function for the actual open action.
//
// If the peer is not allowed to use any storage, returns
// ErrNoStorageForPeer.
//
// Returned KV is valid after the transaction. Strings passed to the
// opener function are valid after the transaction.
func (p *PeerStorage) Open(opener func(string) (kv.KV, error)) (kv.KV, error) {
	var kvstores []kv.KV
	c := p.b.Cursor()
	for k, _ := c.First(); k != nil; k, _ = c.Next() {
		backend := string(k)
		// later value may include quota style restrictions
		s, err := opener(backend)
		if err != nil {
			// TODO once kv.KV has Close, close all in kvstores
			return nil, err
		}
		kvstores = append(kvstores, s)
	}
	if len(kvstores) == 0 {
		return nil, ErrNoStorageForPeer
	}
	return kvmulti.New(kvstores...), nil
}
Example #5
0
func (app *App) openKV(conf *wire.KV) (kv.KV, error) {
	var kvstores []kv.KV

	if conf.Local != nil {
		kvpath := filepath.Join(app.DataDir, "chunks")
		var s kv.KV
		var err error
		s, err = kvfiles.Open(kvpath)
		if err != nil {
			return nil, err
		}
		if conf.Local.Secret != nil {
			var secret [32]byte
			copy(secret[:], conf.Local.Secret)
			s = untrusted.New(s, &secret)
		}
		kvstores = append(kvstores, s)
	}

	for _, ext := range conf.External {
		var s kv.KV
		var err error
		s, err = kvfiles.Open(ext.Path)
		if err != nil {
			return nil, err
		}
		if ext.Secret != nil {
			var secret [32]byte
			copy(secret[:], ext.Secret)
			s = untrusted.New(s, &secret)
		}
		kvstores = append(kvstores, s)
	}

	if len(conf.XXX_unrecognized) > 0 {
		return nil, fmt.Errorf("unknown storage: %v", conf)
	}

	return kvmulti.New(kvstores...), nil
}