You are viewing a plain text version of this content. The canonical link for it is here.
Posted to notifications@skywalking.apache.org by ha...@apache.org on 2024/03/14 01:14:45 UTC
(skywalking-banyandb) 02/02: Add a initilization phase on starting
This is an automated email from the ASF dual-hosted git repository.
hanahmily pushed a commit to branch metadata
in repository https://gitbox.apache.org/repos/asf/skywalking-banyandb.git
commit 9444e509188efbdf3c59f3304d116df912300f21
Author: Gao Hongtao <ha...@gmail.com>
AuthorDate: Thu Mar 14 01:10:27 2024 +0000
Add a initilization phase on starting
In this phase, etcd client would load all necessary data
using a prefix instead of invoking server several times.
Signed-off-by: Gao Hongtao <ha...@gmail.com>
---
banyand/liaison/grpc/discovery.go | 2 +
banyand/liaison/grpc/node.go | 1 +
banyand/measure/metadata.go | 132 +------
banyand/measure/topn.go | 8 -
banyand/measure/write.go | 1 +
banyand/metadata/schema/etcd.go | 39 +-
banyand/metadata/schema/etcd_test.go | 15 -
banyand/metadata/schema/schema.go | 9 +
banyand/metadata/schema/watcher.go | 52 ++-
banyand/queue/pub/pub.go | 1 +
banyand/stream/metadata.go | 22 +-
banyand/stream/write.go | 1 +
dist/LICENSE | 1 -
dist/licenses/license-github.com-stretchr-objx.txt | 22 --
go.mod | 1 -
go.sum | 3 +-
pkg/schema/init.go | 392 +++++++++++++++++++++
pkg/schema/metadata.go | 41 ++-
pkg/schema/schema.go | 6 +-
19 files changed, 543 insertions(+), 206 deletions(-)
diff --git a/banyand/liaison/grpc/discovery.go b/banyand/liaison/grpc/discovery.go
index 57914fec..07f308d5 100644
--- a/banyand/liaison/grpc/discovery.go
+++ b/banyand/liaison/grpc/discovery.go
@@ -95,6 +95,7 @@ func (i identity) String() string {
var _ schema.EventHandler = (*shardRepo)(nil)
type shardRepo struct {
+ schema.UnimplementedOnInitHandler
log *logger.Logger
shardEventsMap map[identity]uint32
sync.RWMutex
@@ -154,6 +155,7 @@ func getID(metadata *commonv1.Metadata) identity {
var _ schema.EventHandler = (*entityRepo)(nil)
type entityRepo struct {
+ schema.UnimplementedOnInitHandler
log *logger.Logger
entitiesMap map[identity]partition.EntityLocator
sync.RWMutex
diff --git a/banyand/liaison/grpc/node.go b/banyand/liaison/grpc/node.go
index edae58aa..b43a3bdb 100644
--- a/banyand/liaison/grpc/node.go
+++ b/banyand/liaison/grpc/node.go
@@ -40,6 +40,7 @@ type NodeRegistry interface {
}
type clusterNodeService struct {
+ schema.UnimplementedOnInitHandler
pipeline queue.Client
sel node.Selector
sync.Once
diff --git a/banyand/measure/metadata.go b/banyand/measure/metadata.go
index 681e36c0..c6a89320 100644
--- a/banyand/measure/metadata.go
+++ b/banyand/measure/metadata.go
@@ -24,9 +24,7 @@ import (
"path"
"time"
- "github.com/google/go-cmp/cmp"
"github.com/pkg/errors"
- "google.golang.org/protobuf/testing/protocmp"
"github.com/apache/skywalking-banyandb/api/common"
commonv1 "github.com/apache/skywalking-banyandb/api/proto/banyandb/common/v1"
@@ -94,6 +92,14 @@ func (sr *schemaRepo) Measure(metadata *commonv1.Metadata) (Measure, error) {
return sm, nil
}
+func (sr *schemaRepo) OnInit(kinds []schema.Kind) (bool, []int64) {
+ if len(kinds) != 5 {
+ logger.Panicf("unexpected kinds: %v", kinds)
+ return false, nil
+ }
+ return true, sr.Repository.Init(schema.KindMeasure)
+}
+
func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
switch metadata.Kind {
case schema.KindGroup:
@@ -104,13 +110,13 @@ func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindGroup,
- Metadata: g.GetMetadata(),
+ Metadata: g,
})
case schema.KindMeasure:
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: metadata.Spec.(*databasev1.Measure).GetMetadata(),
+ Metadata: metadata.Spec.(*databasev1.Measure),
})
case schema.KindIndexRuleBinding:
irb, ok := metadata.Spec.(*databasev1.IndexRuleBinding)
@@ -131,7 +137,7 @@ func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: stm.GetMetadata(),
+ Metadata: stm,
})
}
case schema.KindIndexRule:
@@ -145,109 +151,19 @@ func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: sub.(*databasev1.Measure).GetMetadata(),
+ Metadata: sub.(*databasev1.Measure),
})
}
case schema.KindTopNAggregation:
- // createOrUpdate TopN schemas in advance
- _, err := createOrUpdateTopNMeasure(context.Background(), sr.metadata.MeasureRegistry(), metadata.Spec.(*databasev1.TopNAggregation))
- if err != nil {
- return
- }
- // reload source measure
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
- Kind: resourceSchema.EventKindResource,
- Metadata: metadata.Spec.(*databasev1.TopNAggregation).GetSourceMeasure(),
+ Kind: resourceSchema.EventKindTopNAgg,
+ Metadata: metadata.Spec.(*databasev1.TopNAggregation),
})
default:
}
}
-func createOrUpdateTopNMeasure(ctx context.Context, measureSchemaRegistry schema.Measure, topNSchema *databasev1.TopNAggregation) (*databasev1.Measure, error) {
- oldTopNSchema, err := measureSchemaRegistry.GetMeasure(ctx, topNSchema.GetMetadata())
- if err != nil && !errors.Is(err, schema.ErrGRPCResourceNotFound) {
- return nil, err
- }
-
- sourceMeasureSchema, err := measureSchemaRegistry.GetMeasure(ctx, topNSchema.GetSourceMeasure())
- if err != nil {
- return nil, err
- }
-
- tagNames := sourceMeasureSchema.GetEntity().GetTagNames()
- seriesSpecs := make([]*databasev1.TagSpec, 0, len(tagNames))
-
- for _, tagName := range tagNames {
- var found bool
- for _, fSpec := range sourceMeasureSchema.GetTagFamilies() {
- for _, tSpec := range fSpec.GetTags() {
- if tSpec.GetName() == tagName {
- seriesSpecs = append(seriesSpecs, tSpec)
- found = true
- goto CHECK
- }
- }
- }
-
- CHECK:
- if !found {
- return nil, fmt.Errorf("fail to find tag spec %s", tagName)
- }
- }
-
- // create a new "derived" measure for TopN result
- newTopNMeasure := &databasev1.Measure{
- Metadata: topNSchema.GetMetadata(),
- Interval: sourceMeasureSchema.GetInterval(),
- TagFamilies: []*databasev1.TagFamilySpec{
- {
- Name: topNTagFamily,
- Tags: append([]*databasev1.TagSpec{
- {
- Name: "measure_id",
- Type: databasev1.TagType_TAG_TYPE_STRING,
- },
- {
- Name: "sortDirection",
- Type: databasev1.TagType_TAG_TYPE_INT,
- },
- {
- Name: "rankNumber",
- Type: databasev1.TagType_TAG_TYPE_INT,
- },
- }, seriesSpecs...),
- },
- },
- Fields: []*databasev1.FieldSpec{topNValueFieldSpec},
- Entity: &databasev1.Entity{
- TagNames: append([]string{
- "sortDirection",
- "rankNumber",
- }, topNSchema.GetGroupByTagNames()...),
- },
- }
- if oldTopNSchema == nil {
- if _, innerErr := measureSchemaRegistry.CreateMeasure(ctx, newTopNMeasure); innerErr != nil {
- return nil, innerErr
- }
- return newTopNMeasure, nil
- }
- // compare with the old one
- if cmp.Diff(newTopNMeasure, oldTopNSchema,
- protocmp.IgnoreUnknown(),
- protocmp.IgnoreFields(&databasev1.Measure{}, "updated_at"),
- protocmp.IgnoreFields(&commonv1.Metadata{}, "id", "create_revision", "mod_revision"),
- protocmp.Transform()) == "" {
- return oldTopNSchema, nil
- }
- // update
- if _, err = measureSchemaRegistry.UpdateMeasure(ctx, newTopNMeasure); err != nil {
- return nil, err
- }
- return newTopNMeasure, nil
-}
-
func (sr *schemaRepo) OnDelete(metadata schema.Metadata) {
switch metadata.Kind {
case schema.KindGroup:
@@ -258,13 +174,13 @@ func (sr *schemaRepo) OnDelete(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventDelete,
Kind: resourceSchema.EventKindGroup,
- Metadata: g.GetMetadata(),
+ Metadata: g,
})
case schema.KindMeasure:
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventDelete,
Kind: resourceSchema.EventKindResource,
- Metadata: metadata.Spec.(*databasev1.Measure).GetMetadata(),
+ Metadata: metadata.Spec.(*databasev1.Measure),
})
case schema.KindIndexRuleBinding:
if metadata.Spec.(*databasev1.IndexRuleBinding).GetSubject().Catalog == commonv1.Catalog_CATALOG_MEASURE {
@@ -281,30 +197,20 @@ func (sr *schemaRepo) OnDelete(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: m.GetMetadata(),
+ Metadata: m,
})
}
case schema.KindIndexRule:
case schema.KindTopNAggregation:
- err := sr.removeTopNMeasure(metadata.Spec.(*databasev1.TopNAggregation).GetSourceMeasure())
- if err != nil {
- return
- }
- // we should update instead of delete
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
- Kind: resourceSchema.EventKindResource,
- Metadata: metadata.Spec.(*databasev1.TopNAggregation).GetSourceMeasure(),
+ Kind: resourceSchema.EventKindTopNAgg,
+ Metadata: metadata.Spec.(*databasev1.TopNAggregation),
})
default:
}
}
-func (sr *schemaRepo) removeTopNMeasure(metadata *commonv1.Metadata) error {
- _, err := sr.metadata.MeasureRegistry().DeleteMeasure(context.Background(), metadata)
- return err
-}
-
func (sr *schemaRepo) loadMeasure(metadata *commonv1.Metadata) (*measure, bool) {
r, ok := sr.LoadResource(metadata)
if !ok {
diff --git a/banyand/measure/topn.go b/banyand/measure/topn.go
index 10774efc..90b2d473 100644
--- a/banyand/measure/topn.go
+++ b/banyand/measure/topn.go
@@ -51,20 +51,12 @@ import (
const (
timeBucketFormat = "200601021504"
- topNTagFamily = "__topN__"
)
var (
_ io.Closer = (*topNStreamingProcessor)(nil)
_ io.Closer = (*topNProcessorManager)(nil)
_ flow.Sink = (*topNStreamingProcessor)(nil)
-
- topNValueFieldSpec = &databasev1.FieldSpec{
- Name: "value",
- FieldType: databasev1.FieldType_FIELD_TYPE_INT,
- EncodingMethod: databasev1.EncodingMethod_ENCODING_METHOD_GORILLA,
- CompressionMethod: databasev1.CompressionMethod_COMPRESSION_METHOD_ZSTD,
- }
)
type dataPointWithEntityValues struct {
diff --git a/banyand/measure/write.go b/banyand/measure/write.go
index a4075dab..d6292bb3 100644
--- a/banyand/measure/write.go
+++ b/banyand/measure/write.go
@@ -240,6 +240,7 @@ func (w *writeCallback) Rev(message bus.Message) (resp bus.Message) {
var err error
if groups, err = w.handle(groups, writeEvent); err != nil {
w.l.Error().Err(err).Msg("cannot handle write event")
+ groups = make(map[string]*dataPointsInGroup)
continue
}
}
diff --git a/banyand/metadata/schema/etcd.go b/banyand/metadata/schema/etcd.go
index 213f02a5..7de1f39c 100644
--- a/banyand/metadata/schema/etcd.go
+++ b/banyand/metadata/schema/etcd.go
@@ -124,11 +124,33 @@ func (e *etcdSchemaRegistry) RegisterHandler(name string, kind Kind, handler Eve
}
e.mux.Lock()
defer e.mux.Unlock()
+ var kinds []Kind
for i := 0; i < KindSize; i++ {
ki := Kind(1 << i)
if kind&ki > 0 {
- e.l.Info().Str("name", name).Stringer("kind", ki).Msg("registering watcher")
- w := e.newWatcher(name, ki, handler)
+ kinds = append(kinds, ki)
+ }
+ }
+ e.l.Info().Str("name", name).Interface("kinds", kinds).Msg("initializing schema cache")
+ ok, revisions := handler.OnInit(kinds)
+ if ok {
+ if len(revisions) != len(kinds) {
+ logger.Panicf("invalid number of revisions for %s", name)
+ return
+ }
+ for i := range kinds {
+ e.l.Info().Str("name", name).Stringer("kind", kinds[i]).Msg("registering watcher")
+ w := e.newWatcherWithRevision(name, kinds[i], revisions[i], handler)
+ if w != nil {
+ e.watchers = append(e.watchers, w)
+ }
+ }
+ return
+ }
+ for i := range kinds {
+ e.l.Info().Str("name", name).Stringer("kind", kinds[i]).Msg("registering watcher")
+ w := e.newWatcher(name, kinds[i], handler)
+ if w != nil {
e.watchers = append(e.watchers, w)
}
}
@@ -419,11 +441,16 @@ func (e *etcdSchemaRegistry) register(ctx context.Context, metadata Metadata, fo
return nil
}
-func (e *etcdSchemaRegistry) newWatcher(name string, kind Kind, handler EventHandler) *watcher {
+func (e *etcdSchemaRegistry) newWatcher(name string, kind Kind, handler watchEventHandler) *watcher {
+ return e.newWatcherWithRevision(name, kind, 0, handler)
+}
+
+func (e *etcdSchemaRegistry) newWatcherWithRevision(name string, kind Kind, revision int64, handler watchEventHandler) *watcher {
return newWatcher(e.client, watcherConfig{
- key: e.prependNamespace(kind.key()),
- kind: kind,
- handler: handler,
+ key: e.prependNamespace(kind.key()),
+ kind: kind,
+ handler: handler,
+ revision: revision,
}, e.l.Named(fmt.Sprintf("watcher-%s[%s]", name, kind.String())))
}
diff --git a/banyand/metadata/schema/etcd_test.go b/banyand/metadata/schema/etcd_test.go
index e4fc3913..45aa7fd8 100644
--- a/banyand/metadata/schema/etcd_test.go
+++ b/banyand/metadata/schema/etcd_test.go
@@ -27,7 +27,6 @@ import (
"github.com/google/uuid"
"github.com/stretchr/testify/assert"
- "github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/encoding/protojson"
@@ -48,22 +47,8 @@ var (
streamJSON string
//go:embed testdata/group.json
groupJSON string
-
- _ EventHandler = (*mockedEventHandler)(nil)
)
-type mockedEventHandler struct {
- mock.Mock
-}
-
-func (m *mockedEventHandler) OnAddOrUpdate(metadata Metadata) {
- m.Called(metadata)
-}
-
-func (m *mockedEventHandler) OnDelete(metadata Metadata) {
- m.Called(metadata)
-}
-
func preloadSchema(e Registry) error {
g := &commonv1.Group{}
if err := protojson.Unmarshal([]byte(groupJSON), g); err != nil {
diff --git a/banyand/metadata/schema/schema.go b/banyand/metadata/schema/schema.go
index 3a35c13f..aaedd502 100644
--- a/banyand/metadata/schema/schema.go
+++ b/banyand/metadata/schema/schema.go
@@ -34,10 +34,19 @@ var errUnsupportedEntityType = errors.New("unsupported entity type")
// EventHandler allows receiving and handling the resource change events.
type EventHandler interface {
+ OnInit([]Kind) (bool, []int64)
OnAddOrUpdate(Metadata)
OnDelete(Metadata)
}
+// UnimplementedOnInitHandler is a placeholder for unimplemented OnInitHandler.
+type UnimplementedOnInitHandler struct{}
+
+// OnInit is a placeholder for unimplemented OnInitHandler.
+func (u UnimplementedOnInitHandler) OnInit([]Kind) (bool, []int64) {
+ return false, nil
+}
+
// ListOpt contains options to list resources.
type ListOpt struct {
Group string
diff --git a/banyand/metadata/schema/watcher.go b/banyand/metadata/schema/watcher.go
index c21e3dec..aa203485 100644
--- a/banyand/metadata/schema/watcher.go
+++ b/banyand/metadata/schema/watcher.go
@@ -18,40 +18,52 @@
package schema
import (
+ "errors"
"time"
mvccpb "go.etcd.io/etcd/api/v3/mvccpb"
+ v3rpc "go.etcd.io/etcd/api/v3/v3rpc/rpctypes"
clientv3 "go.etcd.io/etcd/client/v3"
"github.com/apache/skywalking-banyandb/pkg/logger"
"github.com/apache/skywalking-banyandb/pkg/run"
)
+type watchEventHandler interface {
+ OnAddOrUpdate(Metadata)
+ OnDelete(Metadata)
+}
type watcherConfig struct {
- handler EventHandler
- key string
- kind Kind
+ handler watchEventHandler
+ key string
+ revision int64
+ kind Kind
}
type watcher struct {
- handler EventHandler
- cli *clientv3.Client
- closer *run.Closer
- l *logger.Logger
- key string
- kind Kind
+ handler watchEventHandler
+ cli *clientv3.Client
+ closer *run.Closer
+ l *logger.Logger
+ key string
+ revision int64
+ kind Kind
}
func newWatcher(cli *clientv3.Client, wc watcherConfig, l *logger.Logger) *watcher {
w := &watcher{
- cli: cli,
- key: wc.key,
- kind: wc.kind,
- handler: wc.handler,
- closer: run.NewCloser(1),
- l: l,
+ cli: cli,
+ key: wc.key,
+ kind: wc.kind,
+ handler: wc.handler,
+ revision: wc.revision,
+ closer: run.NewCloser(1),
+ l: l,
+ }
+ revision := w.revision
+ if revision < 1 {
+ revision = w.allEvents()
}
- revision := w.allEvents()
go w.watch(revision)
return w
}
@@ -95,9 +107,7 @@ func (w *watcher) watch(revision int64) {
defer w.closer.Done()
cli := w.cli
for {
- if revision > 0 {
- revision = -1
- } else {
+ if revision < 0 {
revision = w.allEvents()
}
select {
@@ -120,6 +130,10 @@ func (w *watcher) watch(revision int64) {
case <-w.closer.CloseNotify():
return
default:
+ if errors.Is(err, v3rpc.ErrCompacted) {
+ revision = -1
+ break
+ }
continue
}
}
diff --git a/banyand/queue/pub/pub.go b/banyand/queue/pub/pub.go
index 8e6de582..18a9b214 100644
--- a/banyand/queue/pub/pub.go
+++ b/banyand/queue/pub/pub.go
@@ -46,6 +46,7 @@ var (
)
type pub struct {
+ schema.UnimplementedOnInitHandler
metadata metadata.Repo
handler schema.EventHandler
log *logger.Logger
diff --git a/banyand/stream/metadata.go b/banyand/stream/metadata.go
index d494ed8b..9ef65105 100644
--- a/banyand/stream/metadata.go
+++ b/banyand/stream/metadata.go
@@ -92,6 +92,14 @@ func (sr *schemaRepo) Stream(metadata *commonv1.Metadata) (Stream, error) {
return sm, nil
}
+func (sr *schemaRepo) OnInit(kinds []schema.Kind) (bool, []int64) {
+ if len(kinds) != 4 {
+ logger.Panicf("invalid kinds: %v", kinds)
+ return false, nil
+ }
+ return true, sr.Repository.Init(schema.KindStream)
+}
+
func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
switch metadata.Kind {
case schema.KindGroup:
@@ -102,13 +110,13 @@ func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindGroup,
- Metadata: g.GetMetadata(),
+ Metadata: g,
})
case schema.KindStream:
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: metadata.Spec.(*databasev1.Stream).GetMetadata(),
+ Metadata: metadata.Spec.(*databasev1.Stream),
})
case schema.KindIndexRuleBinding:
irb, ok := metadata.Spec.(*databasev1.IndexRuleBinding)
@@ -129,7 +137,7 @@ func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: stm.GetMetadata(),
+ Metadata: stm,
})
}
case schema.KindIndexRule:
@@ -143,7 +151,7 @@ func (sr *schemaRepo) OnAddOrUpdate(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: sub.(*databasev1.Stream).GetMetadata(),
+ Metadata: sub.(*databasev1.Stream),
})
}
default:
@@ -160,13 +168,13 @@ func (sr *schemaRepo) OnDelete(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventDelete,
Kind: resourceSchema.EventKindGroup,
- Metadata: g.GetMetadata(),
+ Metadata: g,
})
case schema.KindStream:
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventDelete,
Kind: resourceSchema.EventKindResource,
- Metadata: metadata.Spec.(*databasev1.Stream).GetMetadata(),
+ Metadata: metadata.Spec.(*databasev1.Stream),
})
case schema.KindIndexRuleBinding:
if metadata.Spec.(*databasev1.IndexRuleBinding).GetSubject().Catalog == commonv1.Catalog_CATALOG_STREAM {
@@ -183,7 +191,7 @@ func (sr *schemaRepo) OnDelete(metadata schema.Metadata) {
sr.SendMetadataEvent(resourceSchema.MetadataEvent{
Typ: resourceSchema.EventAddOrUpdate,
Kind: resourceSchema.EventKindResource,
- Metadata: m.GetMetadata(),
+ Metadata: m,
})
}
case schema.KindIndexRule:
diff --git a/banyand/stream/write.go b/banyand/stream/write.go
index 4cc06aa4..216a340f 100644
--- a/banyand/stream/write.go
+++ b/banyand/stream/write.go
@@ -217,6 +217,7 @@ func (w *writeCallback) Rev(message bus.Message) (resp bus.Message) {
var err error
if groups, err = w.handle(groups, writeEvent); err != nil {
w.l.Error().Err(err).Msg("cannot handle write event")
+ groups = make(map[string]*elementsInGroup)
continue
}
}
diff --git a/dist/LICENSE b/dist/LICENSE
index 43c34b3a..06b1cfc3 100644
--- a/dist/LICENSE
+++ b/dist/LICENSE
@@ -344,7 +344,6 @@ MIT licenses
github.com/sourcegraph/conc v0.3.0 MIT
github.com/spf13/cast v1.6.0 MIT
github.com/spf13/viper v1.18.2 MIT
- github.com/stretchr/objx v0.5.0 MIT
github.com/stretchr/testify v1.8.4 MIT
github.com/subosito/gotenv v1.6.0 MIT
github.com/tmc/grpc-websocket-proxy v0.0.0-20220101234140-673ab2c3ae75 MIT
diff --git a/dist/licenses/license-github.com-stretchr-objx.txt b/dist/licenses/license-github.com-stretchr-objx.txt
deleted file mode 100644
index 44d4d9d5..00000000
--- a/dist/licenses/license-github.com-stretchr-objx.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-The MIT License
-
-Copyright (c) 2014 Stretchr, Inc.
-Copyright (c) 2017-2018 objx contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/go.mod b/go.mod
index dabad54e..bfaf6890 100644
--- a/go.mod
+++ b/go.mod
@@ -115,7 +115,6 @@ require (
github.com/sourcegraph/conc v0.3.0 // indirect
github.com/spf13/afero v1.11.0 // indirect
github.com/spf13/cast v1.6.0 // indirect
- github.com/stretchr/objx v0.5.0 // indirect
github.com/subosito/gotenv v1.6.0 // indirect
github.com/tklauser/go-sysconf v0.3.13 // indirect
github.com/tklauser/numcpus v0.7.0 // indirect
diff --git a/go.sum b/go.sum
index 2bc1fba7..3cd60e04 100644
--- a/go.sum
+++ b/go.sum
@@ -321,7 +321,6 @@ github.com/spf13/viper v1.18.2/go.mod h1:EKmWIqdnk5lOcmR72yw6hS+8OPYcwD0jteitLMV
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
-github.com/stretchr/objx v0.5.0 h1:1zr/of2m5FGMsad5YfcqgdqdWrIhu+EBEJRhR1U7z/c=
github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
@@ -600,4 +599,4 @@ honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWh
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
rsc.io/pdf v0.1.1/go.mod h1:n8OzWcQ6Sp37PL01nO98y4iUCRdTGarVfzxY20ICaU4=
sigs.k8s.io/yaml v1.4.0 h1:Mk1wCc2gy/F0THH0TAp1QYyJNzRm2KCLy3o5ASXVI5E=
-sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
\ No newline at end of file
+sigs.k8s.io/yaml v1.4.0/go.mod h1:Ejl7/uTz7PSA4eKMyQCUTnhZYNmLIl+5c2lQPGR2BPY=
diff --git a/pkg/schema/init.go b/pkg/schema/init.go
new file mode 100644
index 00000000..4813be53
--- /dev/null
+++ b/pkg/schema/init.go
@@ -0,0 +1,392 @@
+// Licensed to Apache Software Foundation (ASF) under one or more contributor
+// license agreements. See the NOTICE file distributed with
+// this work for additional information regarding copyright
+// ownership. Apache Software Foundation (ASF) licenses this file to you under
+// the Apache License, Version 2.0 (the "License"); you may
+// not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package schema
+
+import (
+ "context"
+ "fmt"
+ "time"
+
+ "github.com/google/go-cmp/cmp"
+ "github.com/pkg/errors"
+ "google.golang.org/protobuf/testing/protocmp"
+
+ commonv1 "github.com/apache/skywalking-banyandb/api/proto/banyandb/common/v1"
+ databasev1 "github.com/apache/skywalking-banyandb/api/proto/banyandb/database/v1"
+ "github.com/apache/skywalking-banyandb/banyand/metadata/schema"
+ "github.com/apache/skywalking-banyandb/pkg/logger"
+)
+
+const topNTagFamily = "__topN__"
+
+var (
+ initTimeout = 10 * time.Second
+ topNValueFieldSpec = &databasev1.FieldSpec{
+ Name: "value",
+ FieldType: databasev1.FieldType_FIELD_TYPE_INT,
+ EncodingMethod: databasev1.EncodingMethod_ENCODING_METHOD_GORILLA,
+ CompressionMethod: databasev1.CompressionMethod_COMPRESSION_METHOD_ZSTD,
+ }
+)
+
+type revisionContext struct {
+ group int64
+ measure int64
+ stream int64
+ indexRule int64
+ indexRuleBinding int64
+ topNAgg int64
+}
+
+func (r revisionContext) String() string {
+ return fmt.Sprintf("Group: %d, Measure: %d, Stream: %d, IndexRule: %d, IndexRuleBinding: %d, TopNAgg: %d",
+ r.group, r.measure, r.stream, r.indexRule, r.indexRuleBinding, r.topNAgg)
+}
+
+type revisionContextKey struct{}
+
+var revCtxKey = revisionContextKey{}
+
+func (sr *schemaRepo) Init(kind schema.Kind) []int64 {
+ if kind != schema.KindMeasure && kind != schema.KindStream {
+ return nil
+ }
+ catalog := sr.getCatalog(kind)
+ ctx := context.Background()
+ groups, err := sr.metadata.GroupRegistry().ListGroup(ctx)
+ if err != nil {
+ logger.Panicf("fails to get the groups: %v", err)
+ return nil
+ }
+ var revCtx revisionContext
+ for _, g := range groups {
+ if g.Catalog != catalog {
+ continue
+ }
+ if g.Metadata.ModRevision > revCtx.group {
+ revCtx.group = g.Metadata.ModRevision
+ }
+ sr.processGroup(context.WithValue(ctx, revCtxKey, &revCtx), g, catalog)
+ }
+ if kind == schema.KindMeasure {
+ sr.l.Info().Stringer("revision", revCtx).Msg("init measures")
+ return []int64{revCtx.group, revCtx.measure, revCtx.indexRuleBinding, revCtx.indexRule, revCtx.topNAgg}
+ }
+ sr.l.Info().Stringer("revision", revCtx).Msg("init stream")
+ return []int64{revCtx.group, revCtx.stream, revCtx.indexRuleBinding, revCtx.indexRule}
+}
+
+func (sr *schemaRepo) getCatalog(kind schema.Kind) commonv1.Catalog {
+ if kind == schema.KindMeasure {
+ return commonv1.Catalog_CATALOG_MEASURE
+ }
+ return commonv1.Catalog_CATALOG_STREAM
+}
+
+func (sr *schemaRepo) processGroup(ctx context.Context, g *commonv1.Group, catalog commonv1.Catalog) {
+ group, err := sr.initGroup(g)
+ if err != nil {
+ logger.Panicf("fails to init the group: %v", err)
+ }
+ bindings := sr.getBindings(ctx, g.Metadata.GetName())
+ rules := sr.getRules(ctx, g.Metadata.GetName())
+ if catalog == commonv1.Catalog_CATALOG_MEASURE {
+ sr.processMeasure(ctx, g.Metadata.Name, group, bindings, rules)
+ return
+ }
+ sr.processStream(ctx, g.Metadata.Name, group, bindings, rules)
+}
+
+func (sr *schemaRepo) getBindings(ctx context.Context, gName string) map[string][]string {
+ ctx, cancel := context.WithTimeout(ctx, initTimeout)
+ defer cancel()
+ start := time.Now()
+ ibb, err := sr.metadata.IndexRuleBindingRegistry().ListIndexRuleBinding(ctx, schema.ListOpt{Group: gName})
+ if err != nil {
+ logger.Panicf("fails to get the index rule bindings: %v", err)
+ }
+ revCtx := ctx.Value(revCtxKey).(*revisionContext)
+ bindings := make(map[string][]string, len(ibb))
+ for _, ib := range ibb {
+ bindings[ib.GetSubject().GetName()] = ib.GetRules()
+ if ib.Metadata.ModRevision > revCtx.indexRuleBinding {
+ revCtx.indexRuleBinding = ib.Metadata.ModRevision
+ }
+ }
+ sr.l.Info().Str("group", gName).Dur("duration", time.Since(start)).Int("size", len(bindings)).Msg("get index rule bindings")
+ return bindings
+}
+
+func (sr *schemaRepo) getRules(ctx context.Context, gName string) map[string]*databasev1.IndexRule {
+ ctx, cancel := context.WithTimeout(ctx, initTimeout)
+ defer cancel()
+ start := time.Now()
+ rr, err := sr.metadata.IndexRuleRegistry().ListIndexRule(ctx, schema.ListOpt{Group: gName})
+ if err != nil {
+ logger.Panicf("fails to get the index rules: %v", err)
+ }
+ revCtx := ctx.Value(revCtxKey).(*revisionContext)
+ rules := make(map[string]*databasev1.IndexRule, len(rr))
+ for _, r := range rr {
+ rules[r.Metadata.Name] = r
+ if r.Metadata.ModRevision > revCtx.indexRule {
+ revCtx.indexRule = r.Metadata.ModRevision
+ }
+ }
+ sr.l.Info().Str("group", gName).Dur("duration", time.Since(start)).Int("size", len(rules)).Msg("get index rules")
+ return rules
+}
+
+func (sr *schemaRepo) processMeasure(ctx context.Context, gName string, group *group, bindings map[string][]string, rules map[string]*databasev1.IndexRule) {
+ aggMap := sr.getAggMap(ctx, gName)
+
+ ctx, cancel := context.WithTimeout(ctx, initTimeout)
+ defer cancel()
+ start := time.Now()
+ mm, err := sr.metadata.MeasureRegistry().ListMeasure(ctx, schema.ListOpt{Group: gName})
+ if err != nil {
+ logger.Panicf("fails to get the measures: %v", err)
+ return
+ }
+ revCtx := ctx.Value(revCtxKey).(*revisionContext)
+ measureMap := make(map[string]*databasev1.Measure, len(mm))
+ for _, m := range mm {
+ measureMap[m.Metadata.Name] = m
+ }
+ for _, aa := range aggMap {
+ for _, a := range aa {
+ sourceMeasre, ok := measureMap[a.SourceMeasure.Name]
+ if !ok {
+ sr.l.Warn().Str("group", gName).Str("measure", a.SourceMeasure.Name).Str("agg", a.Metadata.Name).Msg("source measure not found")
+ continue
+ }
+ if _, ok := measureMap[a.Metadata.Name]; !ok {
+ sr.l.Info().Str("group", gName).Str("measure", a.SourceMeasure.Name).Str("agg", a.Metadata.Name).Msg("remove topN aggregation")
+ m, err := createTopNMeasure(ctx, sr.metadata.MeasureRegistry(), a, sourceMeasre)
+ if err != nil {
+ logger.Panicf("fails to create or update the topN measure: %v", err)
+ return
+ }
+ mm = append(mm, m)
+ }
+ }
+ }
+
+ for _, m := range mm {
+ if m.Metadata.ModRevision > revCtx.measure {
+ revCtx.measure = m.Metadata.ModRevision
+ }
+ sr.storeMeasure(m, group, bindings, rules, aggMap)
+ }
+ sr.l.Info().Str("group", gName).Dur("duration", time.Since(start)).Int("size", len(mm)).Msg("store measures")
+}
+
+func (sr *schemaRepo) getAggMap(ctx context.Context, gName string) map[string][]*databasev1.TopNAggregation {
+ ctx, cancel := context.WithTimeout(ctx, initTimeout)
+ defer cancel()
+ start := time.Now()
+ agg, err := sr.metadata.TopNAggregationRegistry().ListTopNAggregation(ctx, schema.ListOpt{Group: gName})
+ if err != nil {
+ logger.Panicf("fails to get the topN aggregations: %v", err)
+ }
+ revCtx := ctx.Value(revCtxKey).(*revisionContext)
+ aggMap := make(map[string][]*databasev1.TopNAggregation, len(agg))
+ for _, a := range agg {
+ aggs, ok := aggMap[a.SourceMeasure.Name]
+ if ok {
+ aggs = append(aggs, a)
+ } else {
+ aggs = []*databasev1.TopNAggregation{a}
+ }
+ aggMap[a.SourceMeasure.Name] = aggs
+ if a.Metadata.ModRevision > revCtx.topNAgg {
+ revCtx.topNAgg = a.Metadata.ModRevision
+ }
+ }
+ sr.l.Info().Str("group", gName).Dur("duration", time.Since(start)).Int("size", len(agg)).Msg("get topN aggregations")
+ return aggMap
+}
+
+func (sr *schemaRepo) storeMeasure(m *databasev1.Measure, group *group, bindings map[string][]string,
+ rules map[string]*databasev1.IndexRule, aggMap map[string][]*databasev1.TopNAggregation,
+) {
+ var indexRules []*databasev1.IndexRule
+ if rr, ok := bindings[m.Metadata.GetName()]; ok {
+ for _, r := range rr {
+ indexRules = append(indexRules, rules[r])
+ }
+ }
+ var topNAggr []*databasev1.TopNAggregation
+ if aa, ok := aggMap[m.Metadata.GetName()]; ok {
+ topNAggr = append(topNAggr, aa...)
+ }
+ _, err := group.storeResource(m, indexRules, topNAggr)
+ if err != nil {
+ logger.Panicf("fails to store the measure: %v", err)
+ }
+}
+
+func (sr *schemaRepo) processStream(ctx context.Context, gName string, group *group, bindings map[string][]string, rules map[string]*databasev1.IndexRule) {
+ ctx, cancel := context.WithTimeout(ctx, initTimeout)
+ defer cancel()
+ start := time.Now()
+ ss, err := sr.metadata.StreamRegistry().ListStream(ctx, schema.ListOpt{Group: gName})
+ if err != nil {
+ logger.Panicf("fails to get the streams: %v", err)
+ return
+ }
+ revCtx := ctx.Value(revCtxKey).(*revisionContext)
+ for _, s := range ss {
+ sr.storeStream(s, group, bindings, rules)
+ if s.Metadata.ModRevision > revCtx.stream {
+ revCtx.stream = s.Metadata.ModRevision
+ }
+ }
+ sr.l.Info().Str("group", gName).Dur("duration", time.Since(start)).Int("size", len(ss)).Msg("store streams")
+}
+
+func (sr *schemaRepo) storeStream(s *databasev1.Stream, group *group, bindings map[string][]string, rules map[string]*databasev1.IndexRule) {
+ var indexRules []*databasev1.IndexRule
+ if rr, ok := bindings[s.Metadata.GetName()]; ok {
+ for _, r := range rr {
+ indexRules = append(indexRules, rules[r])
+ }
+ }
+ _, err := group.storeResource(s, indexRules, nil)
+ if err != nil {
+ logger.Panicf("fails to store the stream: %v", err)
+ }
+}
+
+func (sr *schemaRepo) initGroup(groupSchema *commonv1.Group) (*group, error) {
+ g, ok := sr.getGroup(groupSchema.Metadata.Name)
+ if ok {
+ return g, nil
+ }
+ sr.l.Info().Str("group", groupSchema.Metadata.Name).Msg("creating a tsdb")
+ g = sr.createGroup(groupSchema.Metadata.Name)
+ if err := g.initBySchema(groupSchema); err != nil {
+ return nil, err
+ }
+ return g, nil
+}
+
+func createOrUpdateTopNMeasure(ctx context.Context, measureSchemaRegistry schema.Measure, topNSchema *databasev1.TopNAggregation) (*databasev1.Measure, error) {
+ oldTopNSchema, err := measureSchemaRegistry.GetMeasure(ctx, topNSchema.GetMetadata())
+ if err != nil && !errors.Is(err, schema.ErrGRPCResourceNotFound) {
+ return nil, err
+ }
+
+ sourceMeasureSchema, err := measureSchemaRegistry.GetMeasure(ctx, topNSchema.GetSourceMeasure())
+ if err != nil {
+ return nil, err
+ }
+
+ // create a new "derived" measure for TopN result
+ newTopNMeasure, err := buildTopNSourceMeasure(topNSchema, sourceMeasureSchema)
+ if err != nil {
+ return nil, err
+ }
+ if oldTopNSchema == nil {
+ if _, innerErr := measureSchemaRegistry.CreateMeasure(ctx, newTopNMeasure); innerErr != nil {
+ return nil, innerErr
+ }
+ return newTopNMeasure, nil
+ }
+ // compare with the old one
+ if cmp.Diff(newTopNMeasure, oldTopNSchema,
+ protocmp.IgnoreUnknown(),
+ protocmp.IgnoreFields(&databasev1.Measure{}, "updated_at"),
+ protocmp.IgnoreFields(&commonv1.Metadata{}, "id", "create_revision", "mod_revision"),
+ protocmp.Transform()) == "" {
+ return oldTopNSchema, nil
+ }
+ // update
+ if _, err = measureSchemaRegistry.UpdateMeasure(ctx, newTopNMeasure); err != nil {
+ return nil, err
+ }
+ return newTopNMeasure, nil
+}
+
+func createTopNMeasure(ctx context.Context, measureSchemaRegistry schema.Measure, topNSchema *databasev1.TopNAggregation,
+ sourceMeasureSchema *databasev1.Measure,
+) (*databasev1.Measure, error) {
+ newTopNMeasure, err := buildTopNSourceMeasure(topNSchema, sourceMeasureSchema)
+ if err != nil {
+ return nil, err
+ }
+ if _, err := measureSchemaRegistry.CreateMeasure(ctx, newTopNMeasure); err != nil {
+ return nil, err
+ }
+ return newTopNMeasure, nil
+}
+
+func buildTopNSourceMeasure(topNSchema *databasev1.TopNAggregation, sourceMeasureSchema *databasev1.Measure) (*databasev1.Measure, error) {
+ tagNames := sourceMeasureSchema.GetEntity().GetTagNames()
+ seriesSpecs := make([]*databasev1.TagSpec, 0, len(tagNames))
+
+ for _, tagName := range tagNames {
+ var found bool
+ for _, fSpec := range sourceMeasureSchema.GetTagFamilies() {
+ for _, tSpec := range fSpec.GetTags() {
+ if tSpec.GetName() == tagName {
+ seriesSpecs = append(seriesSpecs, tSpec)
+ found = true
+ goto CHECK
+ }
+ }
+ }
+
+ CHECK:
+ if !found {
+ return nil, fmt.Errorf("fail to find tag spec %s", tagName)
+ }
+ }
+
+ // create a new "derived" measure for TopN result
+ return &databasev1.Measure{
+ Metadata: topNSchema.Metadata,
+ Interval: sourceMeasureSchema.GetInterval(),
+ TagFamilies: []*databasev1.TagFamilySpec{
+ {
+ Name: topNTagFamily,
+ Tags: append([]*databasev1.TagSpec{
+ {
+ Name: "measure_id",
+ Type: databasev1.TagType_TAG_TYPE_STRING,
+ },
+ {
+ Name: "sortDirection",
+ Type: databasev1.TagType_TAG_TYPE_INT,
+ },
+ {
+ Name: "rankNumber",
+ Type: databasev1.TagType_TAG_TYPE_INT,
+ },
+ }, seriesSpecs...),
+ },
+ },
+ Fields: []*databasev1.FieldSpec{topNValueFieldSpec},
+ Entity: &databasev1.Entity{
+ TagNames: append([]string{
+ "sortDirection",
+ "rankNumber",
+ }, topNSchema.GetGroupByTagNames()...),
+ },
+ }, nil
+}
diff --git a/pkg/schema/metadata.go b/pkg/schema/metadata.go
index 7692bdf2..75979ebd 100644
--- a/pkg/schema/metadata.go
+++ b/pkg/schema/metadata.go
@@ -180,16 +180,29 @@ func (sr *schemaRepo) Watcher() {
case EventAddOrUpdate:
switch evt.Kind {
case EventKindGroup:
- _, err = sr.StoreGroup(evt.Metadata)
+ _, err = sr.storeGroup(evt.Metadata.GetMetadata())
case EventKindResource:
- err = sr.storeResource(evt.Metadata)
+ err = sr.storeResource(evt.Metadata.GetMetadata())
+ case EventKindTopNAgg:
+ topNSchema := evt.Metadata.(*databasev1.TopNAggregation)
+ _, err = createOrUpdateTopNMeasure(context.Background(), sr.metadata.MeasureRegistry(), topNSchema)
+ if err != nil {
+ break
+ }
+ err = sr.storeResource(topNSchema.SourceMeasure)
}
case EventDelete:
switch evt.Kind {
case EventKindGroup:
- err = sr.deleteGroup(evt.Metadata)
+ err = sr.deleteGroup(evt.Metadata.GetMetadata())
case EventKindResource:
- err = sr.deleteResource(evt.Metadata)
+ err = sr.deleteResource(evt.Metadata.GetMetadata())
+ case EventKindTopNAgg:
+ topNSchema := evt.Metadata.(*databasev1.TopNAggregation)
+ err = multierr.Combine(
+ sr.deleteResource(topNSchema.SourceMeasure),
+ sr.storeResource(topNSchema.SourceMeasure),
+ )
}
}
if err != nil && !errors.Is(err, schema.ErrClosed) {
@@ -209,7 +222,7 @@ func (sr *schemaRepo) Watcher() {
}
}
-func (sr *schemaRepo) StoreGroup(groupMeta *commonv1.Metadata) (*group, error) {
+func (sr *schemaRepo) storeGroup(groupMeta *commonv1.Metadata) (*group, error) {
name := groupMeta.GetName()
sr.Lock()
defer sr.Unlock()
@@ -305,7 +318,7 @@ func (sr *schemaRepo) storeResource(metadata *commonv1.Metadata) error {
g, ok := sr.LoadGroup(metadata.Group)
if !ok {
var err error
- if g, err = sr.StoreGroup(&commonv1.Metadata{Name: metadata.Group}); err != nil {
+ if g, err = sr.storeGroup(&commonv1.Metadata{Name: metadata.Group}); err != nil {
return errors.WithMessagef(err, "create unknown group:%s", metadata.Group)
}
}
@@ -319,7 +332,7 @@ func (sr *schemaRepo) storeResource(metadata *commonv1.Metadata) error {
}
return errors.WithMessage(err, "fails to get the resource")
}
- _, err = g.(*group).storeResource(context.Background(), stm)
+ _, err = g.(*group).initResource(context.Background(), stm)
return err
}
@@ -404,6 +417,10 @@ func (g *group) init(name string) error {
if err != nil {
return err
}
+ return g.initBySchema(groupSchema)
+}
+
+func (g *group) initBySchema(groupSchema *commonv1.Group) error {
g.groupSchema.Store(groupSchema)
if g.isPortable() {
return nil
@@ -428,9 +445,7 @@ func (g *group) SupplyTSDB() io.Closer {
return g.db.Load().(io.Closer)
}
-func (g *group) storeResource(ctx context.Context, resourceSchema ResourceSchema) (Resource, error) {
- g.mapMutex.Lock()
- defer g.mapMutex.Unlock()
+func (g *group) initResource(ctx context.Context, resourceSchema ResourceSchema) (Resource, error) {
localCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()
idxRules, err := g.metadata.IndexRules(localCtx, resourceSchema.GetMetadata())
@@ -447,6 +462,12 @@ func (g *group) storeResource(ctx context.Context, resourceSchema ResourceSchema
return nil, innerErr
}
}
+ return g.storeResource(resourceSchema, idxRules, topNAggrs)
+}
+
+func (g *group) storeResource(resourceSchema ResourceSchema, idxRules []*databasev1.IndexRule, topNAggrs []*databasev1.TopNAggregation) (Resource, error) {
+ g.mapMutex.Lock()
+ defer g.mapMutex.Unlock()
resource := &resourceSpec{
schema: resourceSchema,
indexRules: idxRules,
diff --git a/pkg/schema/schema.go b/pkg/schema/schema.go
index 372f3035..025c29ec 100644
--- a/pkg/schema/schema.go
+++ b/pkg/schema/schema.go
@@ -23,6 +23,7 @@ import (
commonv1 "github.com/apache/skywalking-banyandb/api/proto/banyandb/common/v1"
databasev1 "github.com/apache/skywalking-banyandb/api/proto/banyandb/database/v1"
+ "github.com/apache/skywalking-banyandb/banyand/metadata/schema"
)
// EventType defines actions of events.
@@ -42,6 +43,7 @@ type EventKind uint8
const (
EventKindGroup EventKind = iota
EventKindResource
+ EventKindTopNAgg
)
// Group is the root node, allowing get resources from its sub nodes.
@@ -53,7 +55,7 @@ type Group interface {
// MetadataEvent is the syncing message between metadata repo and this framework.
type MetadataEvent struct {
- Metadata *commonv1.Metadata
+ Metadata ResourceSchema
Typ EventType
Kind EventKind
}
@@ -92,8 +94,8 @@ type ResourceSupplier interface {
// Repository is the collection of several hierarchies groups by a "Group".
type Repository interface {
Watcher()
+ Init(schema.Kind) []int64
SendMetadataEvent(MetadataEvent)
- StoreGroup(groupMeta *commonv1.Metadata) (*group, error)
LoadGroup(name string) (Group, bool)
LoadResource(metadata *commonv1.Metadata) (Resource, bool)
Close()