func TestFilter(t *testing.T) {
datastore.OpenTest()
defer datastore.CloseTest()
// Create testbed volume and data instances
uuid, _ := initTestRepo()
var config dvid.Config
server.CreateTestInstance(t, uuid, "labelblk", "labels", config)
d, err := datastore.NewData(uuid, labelvolT, "bodies", config)
if err != nil {
t.Fatalf("Unable to create labelvol instance: %s\n", err)
}
server.CreateTestSync(t, uuid, "labels", "bodies")
server.CreateTestSync(t, uuid, "bodies", "labels")
// Populate the labels, which should automatically populate the labelvol
_ = createLabelTestVolume(t, uuid, "labels")
if err := datastore.BlockOnUpdating(uuid, "bodies"); err != nil {
t.Fatalf("Error blocking on sync of labels -> bodies: %v\n", err)
}
// Create a ROI that will be used for filter test.
server.CreateTestInstance(t, uuid, "roi", "myroi", config)
roiRequest := fmt.Sprintf("%snode/%s/myroi/roi", server.WebAPIPath, uuid)
server.TestHTTP(t, "POST", roiRequest, getROIReader())
// Create the filter spec
fs := storage.FilterSpec(fmt.Sprintf("roi:myroi,%s", uuid))
var filter storage.Filter
filterer, ok := d.(storage.Filterer)
if !ok {
t.Fatalf("labelvol instance does not implement storage.Filterer\n")
}
filter, err = filterer.NewFilter(fs)
if err != nil {
t.Fatalf("Can't create filter from spec %q: %v\n", fs, err)
}
if filter == nil {
t.Fatalf("No filter could be created from spec %q\n", fs)
}
// Test the filter.
tkv := storage.TKeyValue{K: NewTKey(23, dvid.ChunkPoint3d{0, 0, 0}.ToIZYXString())}
skip, err := filter.Check(&tkv)
if !skip {
t.Errorf("Expected filter check 1 to skip, instead filter.Check() returned not skip")
}
tkv = storage.TKeyValue{K: NewTKey(23, dvid.ChunkPoint3d{1, 1, 1}.ToIZYXString())}
skip, err = filter.Check(&tkv)
if skip {
t.Errorf("Expected filter check 2 to not skip!")
}
tkv = storage.TKeyValue{K: NewTKey(23, dvid.ChunkPoint3d{2, 1, 2}.ToIZYXString())}
skip, err = filter.Check(&tkv)
if skip {
t.Errorf("Expected filter check 2 to not skip!")
}
tkv = storage.TKeyValue{K: NewTKey(23, dvid.ChunkPoint3d{3, 1, 1}.ToIZYXString())}
skip, err = filter.Check(&tkv)
if !skip {
t.Errorf("Expected filter check 3 to skip!")
}
}
// copyData copies all key-value pairs pertinent to the given data instance d2. If d2 is nil,
// the destination data instance is d1, useful for migration of data to a new store.
// Each datatype can implement filters that can restrict the transmitted key-value pairs
// based on the given FilterSpec.
func copyData(oldKV, newKV storage.OrderedKeyValueDB, d1, d2 dvid.Data, uuid dvid.UUID, f storage.Filter, flatten bool) error {
// Get data context for this UUID.
v, err := VersionFromUUID(uuid)
if err != nil {
return err
}
srcCtx := NewVersionedCtx(d1, v)
var dstCtx *VersionedCtx
if d2 == nil {
d2 = d1
dstCtx = srcCtx
} else {
dstCtx = NewVersionedCtx(d2, v)
}
// Send this instance's key-value pairs
var wg sync.WaitGroup
wg.Add(1)
stats := new(txStats)
stats.lastTime = time.Now()
var kvTotal, kvSent int
var bytesTotal, bytesSent uint64
keysOnly := false
if flatten {
// Start goroutine to receive flattened key-value pairs and store them.
ch := make(chan *storage.TKeyValue, 1000)
go func() {
for {
tkv := <-ch
if tkv == nil {
wg.Done()
dvid.Infof("Copied %d %q key-value pairs (%s, out of %d kv pairs, %s) [flattened]\n",
kvSent, d1.DataName(), humanize.Bytes(bytesSent), kvTotal, humanize.Bytes(bytesTotal))
stats.printStats()
return
}
kvTotal++
curBytes := uint64(len(tkv.V) + len(tkv.K))
bytesTotal += curBytes
if f != nil {
skip, err := f.Check(tkv)
if err != nil {
dvid.Errorf("problem applying filter on data %q: %v\n", d1.DataName(), err)
continue
}
if skip {
continue
}
}
kvSent++
bytesSent += curBytes
if err := newKV.Put(dstCtx, tkv.K, tkv.V); err != nil {
dvid.Errorf("can't put k/v pair to destination instance %q: %v\n", d2.DataName(), err)
}
stats.addKV(tkv.K, tkv.V)
}
}()
begKey, endKey := srcCtx.TKeyRange()
err := oldKV.ProcessRange(srcCtx, begKey, endKey, &storage.ChunkOp{}, func(c *storage.Chunk) error {
if c == nil {
return fmt.Errorf("received nil chunk in flatten push for data %s", d1.DataName())
}
ch <- c.TKeyValue
return nil
})
ch <- nil
if err != nil {
return fmt.Errorf("error in flatten push for data %q: %v", d1.DataName(), err)
}
} else {
// Start goroutine to receive all key-value pairs and store them.
ch := make(chan *storage.KeyValue, 1000)
go func() {
for {
kv := <-ch
if kv == nil {
wg.Done()
dvid.Infof("Sent %d %q key-value pairs (%s, out of %d kv pairs, %s)\n",
kvSent, d1.DataName(), humanize.Bytes(bytesSent), kvTotal, humanize.Bytes(bytesTotal))
stats.printStats()
return
}
tkey, err := storage.TKeyFromKey(kv.K)
if err != nil {
dvid.Errorf("couldn't get %q TKey from Key %v: %v\n", d1.DataName(), kv.K, err)
continue
}
kvTotal++
curBytes := uint64(len(kv.V) + len(kv.K))
bytesTotal += curBytes
if f != nil {
skip, err := f.Check(&storage.TKeyValue{K: tkey, V: kv.V})
if err != nil {
dvid.Errorf("problem applying filter on data %q: %v\n", d1.DataName(), err)
continue
}
if skip {
continue
}
}
kvSent++
bytesSent += curBytes
if dstCtx != nil {
err := dstCtx.UpdateInstance(kv.K)
if err != nil {
dvid.Errorf("can't update raw key to new data instance %q: %v\n", d2.DataName(), err)
}
}
if err := newKV.RawPut(kv.K, kv.V); err != nil {
dvid.Errorf("can't put k/v pair to destination instance %q: %v\n", d2.DataName(), err)
}
stats.addKV(kv.K, kv.V)
}
}()
begKey, endKey := srcCtx.KeyRange()
if err = oldKV.RawRangeQuery(begKey, endKey, keysOnly, ch, nil); err != nil {
return fmt.Errorf("push voxels %q range query: %v", d1.DataName(), err)
}
}
wg.Wait()
return nil
}
// PushData transfers all key-value pairs pertinent to the given data instance.
// Each datatype can implement filters that can restrict the transmitted key-value pairs
// based on the given FilterSpec. Note that because of the generality of this function,
// a particular datatype implementation could be much more efficient when implementing
// filtering. For example, the imageblk datatype could scan its key-values using the ROI
// to generate keys (since imageblk keys will likely be a vast superset of ROI spans),
// while this generic routine will scan every key-value pair for a data instance and
// query the ROI to see if this key is ok to send.
func PushData(d dvid.Data, p *PushSession) error {
// We should be able to get the backing store (only ordered kv for now)
storer, ok := d.(storage.Accessor)
if !ok {
return fmt.Errorf("unable to push data %q: unable to access backing store", d.DataName())
}
store, err := storer.GetOrderedKeyValueDB()
if err != nil {
return fmt.Errorf("unable to get backing store for data %q: %v\n", d.DataName(), err)
}
// See if this data instance implements a Send filter.
var filter storage.Filter
filterer, ok := d.(storage.Filterer)
if ok {
var err error
filter, err = filterer.NewFilter(p.Filter)
if err != nil {
return err
}
}
// pick any version because flatten transmit will only have one version, and all or branch transmit will
// be looking at all versions anyway.
if len(p.Versions) == 0 {
return fmt.Errorf("need at least one version to send")
}
var v dvid.VersionID
for v = range p.Versions {
break
}
ctx := NewVersionedCtx(d, v)
// Send the initial data instance start message
if err := p.StartInstancePush(d); err != nil {
return err
}
// Send this instance's key-value pairs
var wg sync.WaitGroup
wg.Add(1)
var kvTotal, kvSent int
var bytesTotal, bytesSent uint64
keysOnly := false
if p.t == rpc.TransmitFlatten {
// Start goroutine to receive flattened key-value pairs and transmit to remote.
ch := make(chan *storage.TKeyValue, 1000)
go func() {
for {
tkv := <-ch
if tkv == nil {
if err := p.EndInstancePush(); err != nil {
dvid.Errorf("Bad data %q termination: %v\n", d.DataName(), err)
}
wg.Done()
dvid.Infof("Sent %d %q key-value pairs (%s, out of %d kv pairs, %s) [flattened]\n",
kvSent, d.DataName(), humanize.Bytes(bytesSent), kvTotal, humanize.Bytes(bytesTotal))
return
}
kvTotal++
curBytes := uint64(len(tkv.V) + len(tkv.K))
bytesTotal += curBytes
if filter != nil {
skip, err := filter.Check(tkv)
if err != nil {
dvid.Errorf("problem applying filter on data %q: %v\n", d.DataName(), err)
continue
}
if skip {
continue
}
}
kvSent++
bytesSent += curBytes
kv := storage.KeyValue{
K: ctx.ConstructKey(tkv.K),
V: tkv.V,
}
if err := p.SendKV(&kv); err != nil {
dvid.Errorf("Bad data %q send KV: %v", d.DataName(), err)
}
}
}()
begKey, endKey := ctx.TKeyRange()
err := store.ProcessRange(ctx, begKey, endKey, &storage.ChunkOp{}, func(c *storage.Chunk) error {
if c == nil {
return fmt.Errorf("received nil chunk in flatten push for data %s", d.DataName())
}
ch <- c.TKeyValue
return nil
})
ch <- nil
if err != nil {
return fmt.Errorf("error in flatten push for data %q: %v", d.DataName(), err)
}
} else {
// Start goroutine to receive all key-value pairs and transmit to remote.
ch := make(chan *storage.KeyValue, 1000)
go func() {
for {
kv := <-ch
if kv == nil {
if err := p.EndInstancePush(); err != nil {
dvid.Errorf("Bad data %q termination: %v\n", d.DataName(), err)
}
wg.Done()
dvid.Infof("Sent %d %q key-value pairs (%s, out of %d kv pairs, %s)\n",
kvSent, d.DataName(), humanize.Bytes(bytesSent), kvTotal, humanize.Bytes(bytesTotal))
return
}
if !ctx.ValidKV(kv, p.Versions) {
continue
}
kvTotal++
curBytes := uint64(len(kv.V) + len(kv.K))
bytesTotal += curBytes
if filter != nil {
tkey, err := storage.TKeyFromKey(kv.K)
if err != nil {
dvid.Errorf("couldn't get %q TKey from Key %v: %v\n", d.DataName(), kv.K, err)
continue
}
skip, err := filter.Check(&storage.TKeyValue{K: tkey, V: kv.V})
if err != nil {
dvid.Errorf("problem applying filter on data %q: %v\n", d.DataName(), err)
continue
}
if skip {
continue
}
}
kvSent++
bytesSent += curBytes
if err := p.SendKV(kv); err != nil {
dvid.Errorf("Bad data %q send KV: %v", d.DataName(), err)
}
}
}()
begKey, endKey := ctx.KeyRange()
if err = store.RawRangeQuery(begKey, endKey, keysOnly, ch, nil); err != nil {
return fmt.Errorf("push voxels %q range query: %v", d.DataName(), err)
}
}
wg.Wait()
return nil
}
