From 9673916c24e3e4774c228faa32fcff518c6e9d26 Mon Sep 17 00:00:00 2001 From: Jake Moshenko Date: Mon, 6 Dec 2021 14:45:29 -0500 Subject: [PATCH] use canonical terms for memdb datastore --- internal/datastore/memdb/memdb.go | 136 +++++++++++----------- internal/datastore/memdb/query.go | 36 +++--- internal/datastore/memdb/reverse_query.go | 8 +- internal/datastore/memdb/tuple.go | 8 +- internal/datastore/memdb/watch.go | 2 +- 5 files changed, 95 insertions(+), 95 deletions(-) diff --git a/internal/datastore/memdb/memdb.go b/internal/datastore/memdb/memdb.go index 6a032c4e81..d94c8c8bd2 100644 --- a/internal/datastore/memdb/memdb.go +++ b/internal/datastore/memdb/memdb.go @@ -25,20 +25,20 @@ const ( tableTransaction = "transaction" tableNamespace = "namespaceConfig" - indexID = "id" - indexTimestamp = "timestamp" - indexLive = "live" - indexNamespace = "namespace" - indexNamespaceAndObjectID = "namespaceAndObjectID" - indexNamespaceAndRelation = "namespaceAndRelation" - indexNamespaceAndUsersetID = "namespaceAndUsersetID" - indexRelationAndUserset = "relationAndUserset" - indexRelationAndRelation = "relationAndRelation" - indexUsersetNamespace = "usersetNamespace" - indexUsersetRelation = "usersetRelation" - indexUserset = "userset" - indexCreatedTxn = "createdTxn" - indexDeletedTxn = "deletedTxn" + indexID = "id" + indexTimestamp = "timestamp" + indexLive = "live" + indexNamespace = "namespace" + indexNamespaceAndResourceID = "namespaceAndResourceID" + indexNamespaceAndRelation = "namespaceAndRelation" + indexNamespaceAndSubjectID = "namespaceAndSubjectID" + indexRelationAndSubject = "relationAndSubject" + indexRelationAndRelation = "relationAndRelation" + indexSubjectNamespace = "subjectNamespace" + indexSubjectRelation = "subjectRelation" + indexSubject = "subject" + indexCreatedTxn = "createdTxn" + indexDeletedTxn = "deletedTxn" defaultWatchBufferLength = 128 @@ -61,11 +61,11 @@ type transaction struct { type relationship struct { namespace string - objectID string + resourceID string relation string - usersetNamespace string - usersetObjectID string - usersetRelation string + subjectNamespace string + subjectObjectID string + subjectRelation string createdTxn uint64 deletedTxn uint64 } @@ -73,11 +73,11 @@ type relationship struct { func tupleEntryFromRelationship(r *v1.Relationship, created, deleted uint64) *relationship { return &relationship{ namespace: r.Resource.ObjectType, - objectID: r.Resource.ObjectId, + resourceID: r.Resource.ObjectId, relation: r.Relation, - usersetNamespace: r.Subject.Object.ObjectType, - usersetObjectID: r.Subject.Object.ObjectId, - usersetRelation: stringz.DefaultEmpty(r.Subject.OptionalRelation, "..."), + subjectNamespace: r.Subject.Object.ObjectType, + subjectObjectID: r.Subject.Object.ObjectId, + subjectRelation: stringz.DefaultEmpty(r.Subject.OptionalRelation, "..."), createdTxn: created, deletedTxn: deleted, } @@ -87,15 +87,15 @@ func (t relationship) Relationship() *v1.Relationship { return &v1.Relationship{ Resource: &v1.ObjectReference{ ObjectType: t.namespace, - ObjectId: t.objectID, + ObjectId: t.resourceID, }, Relation: t.relation, Subject: &v1.SubjectReference{ Object: &v1.ObjectReference{ - ObjectType: t.usersetNamespace, - ObjectId: t.usersetObjectID, + ObjectType: t.subjectNamespace, + ObjectId: t.subjectObjectID, }, - OptionalRelation: stringz.Default(t.usersetRelation, "", datastore.Ellipsis), + OptionalRelation: stringz.Default(t.subjectRelation, "", datastore.Ellipsis), }, } } @@ -104,13 +104,13 @@ func (t relationship) RelationTuple() *v0.RelationTuple { return &v0.RelationTuple{ ObjectAndRelation: &v0.ObjectAndRelation{ Namespace: t.namespace, - ObjectId: t.objectID, + ObjectId: t.resourceID, Relation: t.relation, }, User: &v0.User{UserOneof: &v0.User_Userset{Userset: &v0.ObjectAndRelation{ - Namespace: t.usersetNamespace, - ObjectId: t.usersetObjectID, - Relation: t.usersetRelation, + Namespace: t.subjectNamespace, + ObjectId: t.subjectObjectID, + Relation: t.subjectRelation, }}}, } } @@ -119,11 +119,11 @@ func (t relationship) String() string { return fmt.Sprintf( "%s:%s#%s@%s:%s#%s[%d-%d)", t.namespace, - t.objectID, + t.resourceID, t.relation, - t.usersetNamespace, - t.usersetObjectID, - t.usersetRelation, + t.subjectNamespace, + t.subjectObjectID, + t.subjectRelation, t.createdTxn, t.deletedTxn, ) @@ -185,11 +185,11 @@ var schema = &memdb.DBSchema{ Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ &memdb.StringFieldIndex{Field: "namespace"}, - &memdb.StringFieldIndex{Field: "objectID"}, + &memdb.StringFieldIndex{Field: "resourceID"}, &memdb.StringFieldIndex{Field: "relation"}, - &memdb.StringFieldIndex{Field: "usersetNamespace"}, - &memdb.StringFieldIndex{Field: "usersetObjectID"}, - &memdb.StringFieldIndex{Field: "usersetRelation"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, + &memdb.StringFieldIndex{Field: "subjectObjectID"}, + &memdb.StringFieldIndex{Field: "subjectRelation"}, &memdb.UintFieldIndex{Field: "createdTxn"}, }, }, @@ -200,11 +200,11 @@ var schema = &memdb.DBSchema{ Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ &memdb.StringFieldIndex{Field: "namespace"}, - &memdb.StringFieldIndex{Field: "objectID"}, + &memdb.StringFieldIndex{Field: "resourceID"}, &memdb.StringFieldIndex{Field: "relation"}, - &memdb.StringFieldIndex{Field: "usersetNamespace"}, - &memdb.StringFieldIndex{Field: "usersetObjectID"}, - &memdb.StringFieldIndex{Field: "usersetRelation"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, + &memdb.StringFieldIndex{Field: "subjectObjectID"}, + &memdb.StringFieldIndex{Field: "subjectRelation"}, &memdb.UintFieldIndex{Field: "deletedTxn"}, }, }, @@ -214,13 +214,13 @@ var schema = &memdb.DBSchema{ Unique: false, Indexer: &memdb.StringFieldIndex{Field: "namespace"}, }, - indexNamespaceAndObjectID: { - Name: indexNamespaceAndObjectID, + indexNamespaceAndResourceID: { + Name: indexNamespaceAndResourceID, Unique: false, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ &memdb.StringFieldIndex{Field: "namespace"}, - &memdb.StringFieldIndex{Field: "objectID"}, + &memdb.StringFieldIndex{Field: "resourceID"}, }, }, }, @@ -234,57 +234,57 @@ var schema = &memdb.DBSchema{ }, }, }, - indexNamespaceAndUsersetID: { - Name: indexNamespaceAndUsersetID, + indexNamespaceAndSubjectID: { + Name: indexNamespaceAndSubjectID, Unique: false, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ &memdb.StringFieldIndex{Field: "namespace"}, - &memdb.StringFieldIndex{Field: "usersetNamespace"}, - &memdb.StringFieldIndex{Field: "usersetObjectID"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, + &memdb.StringFieldIndex{Field: "subjectObjectID"}, }, }, }, - indexRelationAndUserset: { - Name: indexRelationAndUserset, + indexRelationAndSubject: { + Name: indexRelationAndSubject, Unique: false, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ - &memdb.StringFieldIndex{Field: "usersetNamespace"}, - &memdb.StringFieldIndex{Field: "usersetObjectID"}, - &memdb.StringFieldIndex{Field: "usersetRelation"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, + &memdb.StringFieldIndex{Field: "subjectObjectID"}, + &memdb.StringFieldIndex{Field: "subjectRelation"}, &memdb.StringFieldIndex{Field: "namespace"}, &memdb.StringFieldIndex{Field: "relation"}, }, }, }, - indexUsersetRelation: { - Name: indexUsersetRelation, + indexSubjectRelation: { + Name: indexSubjectRelation, Unique: false, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ - &memdb.StringFieldIndex{Field: "usersetNamespace"}, - &memdb.StringFieldIndex{Field: "usersetRelation"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, + &memdb.StringFieldIndex{Field: "subjectRelation"}, }, }, }, - indexUserset: { - Name: indexUserset, + indexSubject: { + Name: indexSubject, Unique: false, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ - &memdb.StringFieldIndex{Field: "usersetNamespace"}, - &memdb.StringFieldIndex{Field: "usersetObjectID"}, - &memdb.StringFieldIndex{Field: "usersetRelation"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, + &memdb.StringFieldIndex{Field: "subjectObjectID"}, + &memdb.StringFieldIndex{Field: "subjectRelation"}, }, }, }, - indexUsersetNamespace: { - Name: indexUsersetNamespace, + indexSubjectNamespace: { + Name: indexSubjectNamespace, Unique: false, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ - &memdb.StringFieldIndex{Field: "usersetNamespace"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, }, }, }, @@ -293,8 +293,8 @@ var schema = &memdb.DBSchema{ Unique: false, Indexer: &memdb.CompoundIndex{ Indexes: []memdb.Indexer{ - &memdb.StringFieldIndex{Field: "usersetNamespace"}, - &memdb.StringFieldIndex{Field: "usersetRelation"}, + &memdb.StringFieldIndex{Field: "subjectNamespace"}, + &memdb.StringFieldIndex{Field: "subjectRelation"}, &memdb.StringFieldIndex{Field: "namespace"}, &memdb.StringFieldIndex{Field: "relation"}, }, diff --git a/internal/datastore/memdb/query.go b/internal/datastore/memdb/query.go index 76b46c59d7..ca3768f906 100644 --- a/internal/datastore/memdb/query.go +++ b/internal/datastore/memdb/query.go @@ -20,7 +20,7 @@ type memdbTupleQuery struct { resourceFilter *v1.RelationshipFilter optionalSubjectFilter *v1.SubjectFilter - usersetsFilter []*v0.ObjectAndRelation + subjectsFilter []*v0.ObjectAndRelation limit *uint64 simulatedLatency time.Duration @@ -40,7 +40,7 @@ func (mtq memdbTupleQuery) WithSubjectFilter(filter *v1.SubjectFilter) datastore panic("cannot call WithSubjectFilter after WithUsersets") } - if mtq.usersetsFilter != nil { + if mtq.subjectsFilter != nil { panic("called WithSubjectFilter twice") } @@ -48,20 +48,20 @@ func (mtq memdbTupleQuery) WithSubjectFilter(filter *v1.SubjectFilter) datastore return mtq } -func (mtq memdbTupleQuery) WithUsersets(usersets []*v0.ObjectAndRelation) datastore.TupleQuery { +func (mtq memdbTupleQuery) WithUsersets(subjects []*v0.ObjectAndRelation) datastore.TupleQuery { if mtq.optionalSubjectFilter != nil { panic("cannot call WithUsersets after WithSubjectFilter") } - if mtq.usersetsFilter != nil { + if mtq.subjectsFilter != nil { panic("called WithUsersets twice") } - if len(usersets) == 0 { - panic("Given nil or empty usersets") + if len(subjects) == 0 { + panic("Given nil or empty subjects") } - mtq.usersetsFilter = usersets + mtq.subjectsFilter = subjects return mtq } @@ -70,14 +70,14 @@ func iteratorForFilter(txn *memdb.Txn, filter *v1.RelationshipFilter) (memdb.Res case filter.OptionalResourceId != "": return txn.Get( tableRelationship, - indexNamespaceAndObjectID, + indexNamespaceAndResourceID, filter.ResourceType, filter.OptionalResourceId, ) case filter.OptionalSubjectFilter != nil && filter.OptionalSubjectFilter.OptionalSubjectId != "": return txn.Get( tableRelationship, - indexNamespaceAndUsersetID, + indexNamespaceAndSubjectID, filter.ResourceType, filter.OptionalSubjectFilter.SubjectType, filter.OptionalSubjectFilter.OptionalSubjectId, @@ -122,7 +122,7 @@ func (mtq memdbTupleQuery) Execute(ctx context.Context) (datastore.TupleIterator filter := relationshipFilter switch { - case filter.OptionalResourceId != "" && filter.OptionalResourceId != tuple.objectID: + case filter.OptionalResourceId != "" && filter.OptionalResourceId != tuple.resourceID: return true case filter.OptionalRelation != "" && filter.OptionalRelation != tuple.relation: return true @@ -130,21 +130,21 @@ func (mtq memdbTupleQuery) Execute(ctx context.Context) (datastore.TupleIterator if subjectFilter := filter.OptionalSubjectFilter; subjectFilter != nil { switch { - case subjectFilter.SubjectType != tuple.usersetNamespace: + case subjectFilter.SubjectType != tuple.subjectNamespace: return true - case subjectFilter.OptionalSubjectId != "" && subjectFilter.OptionalSubjectId != tuple.usersetObjectID: + case subjectFilter.OptionalSubjectId != "" && subjectFilter.OptionalSubjectId != tuple.subjectObjectID: return true - case subjectFilter.OptionalRelation != nil && stringz.DefaultEmpty(subjectFilter.OptionalRelation.Relation, datastore.Ellipsis) != tuple.usersetRelation: + case subjectFilter.OptionalRelation != nil && stringz.DefaultEmpty(subjectFilter.OptionalRelation.Relation, datastore.Ellipsis) != tuple.subjectRelation: return true } } - if len(mtq.usersetsFilter) > 0 { + if len(mtq.subjectsFilter) > 0 { found := false - for _, filter := range mtq.usersetsFilter { - if filter.Namespace == tuple.usersetNamespace && - filter.ObjectId == tuple.usersetObjectID && - filter.Relation == tuple.usersetRelation { + for _, filter := range mtq.subjectsFilter { + if filter.Namespace == tuple.subjectNamespace && + filter.ObjectId == tuple.subjectObjectID && + filter.Relation == tuple.subjectRelation { found = true break } diff --git a/internal/datastore/memdb/reverse_query.go b/internal/datastore/memdb/reverse_query.go index 5de45f6000..0f40b28059 100644 --- a/internal/datastore/memdb/reverse_query.go +++ b/internal/datastore/memdb/reverse_query.go @@ -54,7 +54,7 @@ func (mtq memdbReverseTupleQuery) Execute(ctx context.Context) (datastore.TupleI if mtq.subObjectID != "" { bestIterator, err = txn.Get( tableRelationship, - indexRelationAndUserset, + indexRelationAndSubject, mtq.subNamespaceName, mtq.subObjectID, mtq.subRelationName, @@ -74,7 +74,7 @@ func (mtq memdbReverseTupleQuery) Execute(ctx context.Context) (datastore.TupleI } else if mtq.subObjectID != "" { bestIterator, err = txn.Get( tableRelationship, - indexUserset, + indexSubject, mtq.subNamespaceName, mtq.subObjectID, mtq.subRelationName, @@ -82,14 +82,14 @@ func (mtq memdbReverseTupleQuery) Execute(ctx context.Context) (datastore.TupleI } else if mtq.subRelationName != "" { bestIterator, err = txn.Get( tableRelationship, - indexUsersetRelation, + indexSubjectRelation, mtq.subNamespaceName, mtq.subRelationName, ) } else { bestIterator, err = txn.Get( tableRelationship, - indexUsersetNamespace, + indexSubjectNamespace, mtq.subNamespaceName, ) } diff --git a/internal/datastore/memdb/tuple.go b/internal/datastore/memdb/tuple.go index 5d9877e7c6..88c0cb2aff 100644 --- a/internal/datastore/memdb/tuple.go +++ b/internal/datastore/memdb/tuple.go @@ -322,7 +322,7 @@ func relationshipFilterFilterFunc(filter *v1.RelationshipFilter) func(interface{ switch { case filter.ResourceType != tuple.namespace: return true - case filter.OptionalResourceId != "" && filter.OptionalResourceId != tuple.objectID: + case filter.OptionalResourceId != "" && filter.OptionalResourceId != tuple.resourceID: return true case filter.OptionalRelation != "" && filter.OptionalRelation != tuple.relation: return true @@ -331,12 +331,12 @@ func relationshipFilterFilterFunc(filter *v1.RelationshipFilter) func(interface{ // If it doesn't match one of the subject filters, filter it. if subjectFilter := filter.OptionalSubjectFilter; subjectFilter != nil { switch { - case subjectFilter.SubjectType != tuple.usersetNamespace: + case subjectFilter.SubjectType != tuple.subjectNamespace: return true - case subjectFilter.OptionalSubjectId != "" && subjectFilter.OptionalSubjectId != tuple.usersetObjectID: + case subjectFilter.OptionalSubjectId != "" && subjectFilter.OptionalSubjectId != tuple.subjectObjectID: return true case subjectFilter.OptionalRelation != nil && - stringz.DefaultEmpty(subjectFilter.OptionalRelation.Relation, datastore.Ellipsis) != tuple.usersetRelation: + stringz.DefaultEmpty(subjectFilter.OptionalRelation.Relation, datastore.Ellipsis) != tuple.subjectRelation: return true } } diff --git a/internal/datastore/memdb/watch.go b/internal/datastore/memdb/watch.go index 9e62e7c586..e34e983254 100644 --- a/internal/datastore/memdb/watch.go +++ b/internal/datastore/memdb/watch.go @@ -99,5 +99,5 @@ func (mds *memdbDatastore) loadChanges(ctx context.Context, currentTxn uint64) ( return nil, 0, nil, fmt.Errorf(errWatchError, err) } - return stagedChanges.RevisionChanges(), currentTxn, watchChan, nil + return stagedChanges.AsRevisionChanges(), currentTxn, watchChan, nil }