feat(inmem): add in-memory service implementations
Chris Goller
parent
348501afd6
commit
eb68362cfc
|
|
@ -0,0 +1,189 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
var (
|
||||
errTokenNotFound = fmt.Errorf("authorization not found")
|
||||
)
|
||||
|
||||
func (s *Service) loadAuthorization(ctx context.Context, id platform.ID) (*platform.Authorization, error) {
|
||||
i, ok := s.authorizationKV.Load(id.String())
|
||||
if !ok {
|
||||
return nil, errTokenNotFound
|
||||
}
|
||||
|
||||
a, ok := i.(platform.Authorization)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("value found in map is not an authorization")
|
||||
}
|
||||
|
||||
if a.Status == "" {
|
||||
a.Status = platform.Active
|
||||
}
|
||||
|
||||
if err := s.setUserOnAuthorization(ctx, &a); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &a, nil
|
||||
}
|
||||
|
||||
func (s *Service) setUserOnAuthorization(ctx context.Context, a *platform.Authorization) error {
|
||||
u, err := s.loadUser(a.UserID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
a.User = u.Name
|
||||
return nil
|
||||
}
|
||||
|
||||
// PutAuthorization overwrites the authorization with the contents of a.
|
||||
func (s *Service) PutAuthorization(ctx context.Context, a *platform.Authorization) error {
|
||||
if a.Status == "" {
|
||||
a.Status = platform.Active
|
||||
}
|
||||
s.authorizationKV.Store(a.ID.String(), *a)
|
||||
return nil
|
||||
}
|
||||
|
||||
// FindAuthorizationByID returns an authorization given an ID.
|
||||
func (s *Service) FindAuthorizationByID(ctx context.Context, id platform.ID) (*platform.Authorization, error) {
|
||||
return s.loadAuthorization(ctx, id)
|
||||
}
|
||||
|
||||
// FindAuthorizationByToken returns an authorization given a token.
|
||||
func (s *Service) FindAuthorizationByToken(ctx context.Context, t string) (*platform.Authorization, error) {
|
||||
as, n, err := s.FindAuthorizations(ctx, platform.AuthorizationFilter{Token: &t})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if n < 1 {
|
||||
return nil, errTokenNotFound
|
||||
}
|
||||
return as[0], nil
|
||||
}
|
||||
|
||||
func filterAuthorizationsFn(filter platform.AuthorizationFilter) func(a *platform.Authorization) bool {
|
||||
if filter.ID != nil {
|
||||
return func(a *platform.Authorization) bool {
|
||||
return bytes.Equal(a.ID, *filter.ID)
|
||||
}
|
||||
}
|
||||
|
||||
if filter.Token != nil {
|
||||
return func(a *platform.Authorization) bool {
|
||||
return a.Token == *filter.Token
|
||||
}
|
||||
}
|
||||
|
||||
if filter.UserID != nil {
|
||||
return func(a *platform.Authorization) bool {
|
||||
return bytes.Equal(a.UserID, *filter.UserID)
|
||||
}
|
||||
}
|
||||
|
||||
return func(a *platform.Authorization) bool { return true }
|
||||
}
|
||||
|
||||
// FindAuthorizations returns all authorizations matching the filter.
|
||||
func (s *Service) FindAuthorizations(ctx context.Context, filter platform.AuthorizationFilter, opt ...platform.FindOptions) ([]*platform.Authorization, int, error) {
|
||||
if filter.ID != nil {
|
||||
a, err := s.FindAuthorizationByID(ctx, *filter.ID)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return []*platform.Authorization{a}, 1, nil
|
||||
}
|
||||
|
||||
var as []*platform.Authorization
|
||||
if filter.User != nil {
|
||||
u, err := s.findUserByName(ctx, *filter.User)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
filter.UserID = &u.ID
|
||||
}
|
||||
var err error
|
||||
filterF := filterAuthorizationsFn(filter)
|
||||
s.authorizationKV.Range(func(k, v interface{}) bool {
|
||||
a, ok := v.(platform.Authorization)
|
||||
if !ok {
|
||||
err = fmt.Errorf("value found in map is not an authorization")
|
||||
return false
|
||||
}
|
||||
|
||||
if err = s.setUserOnAuthorization(ctx, &a); err != nil {
|
||||
return false
|
||||
}
|
||||
|
||||
if filterF(&a) {
|
||||
as = append(as, &a)
|
||||
}
|
||||
|
||||
return true
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return as, len(as), nil
|
||||
}
|
||||
|
||||
// CreateAuthorization sets a.Token and a.ID and creates an platform.Authorization
|
||||
func (s *Service) CreateAuthorization(ctx context.Context, a *platform.Authorization) error {
|
||||
if len(a.UserID) == 0 {
|
||||
u, err := s.findUserByName(ctx, a.User)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
a.UserID = u.ID
|
||||
}
|
||||
var err error
|
||||
a.Token, err = s.TokenGenerator.Token()
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
a.ID = s.IDGenerator.ID()
|
||||
a.Status = platform.Active
|
||||
return s.PutAuthorization(ctx, a)
|
||||
}
|
||||
|
||||
// DeleteAuthorization deletes an authorization associated with id.
|
||||
func (s *Service) DeleteAuthorization(ctx context.Context, id platform.ID) error {
|
||||
if _, err := s.FindAuthorizationByID(ctx, id); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
s.authorizationKV.Delete(id.String())
|
||||
return nil
|
||||
}
|
||||
|
||||
// SetAuthorizationStatus updates the status of an authorization associated with id.
|
||||
func (s *Service) SetAuthorizationStatus(ctx context.Context, id platform.ID, status platform.Status) error {
|
||||
a, err := s.FindAuthorizationByID(ctx, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
switch status {
|
||||
case platform.Active, platform.Inactive:
|
||||
default:
|
||||
return fmt.Errorf("unknown authorization status")
|
||||
}
|
||||
|
||||
if a.Status == status {
|
||||
return nil
|
||||
}
|
||||
|
||||
a.Status = status
|
||||
return s.PutAuthorization(ctx, a)
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
platformtesting "github.com/influxdata/platform/testing"
|
||||
)
|
||||
|
||||
func initAuthorizationService(f platformtesting.AuthorizationFields, t *testing.T) (platform.AuthorizationService, func()) {
|
||||
s := NewService()
|
||||
s.IDGenerator = f.IDGenerator
|
||||
s.TokenGenerator = f.TokenGenerator
|
||||
ctx := context.TODO()
|
||||
for _, u := range f.Users {
|
||||
if err := s.PutUser(ctx, u); err != nil {
|
||||
t.Fatalf("failed to populate users")
|
||||
}
|
||||
}
|
||||
for _, u := range f.Authorizations {
|
||||
if err := s.PutAuthorization(ctx, u); err != nil {
|
||||
t.Fatalf("failed to populate authorizations")
|
||||
}
|
||||
}
|
||||
return s, func() {}
|
||||
}
|
||||
|
||||
func TestAuthorizationService_CreateAuthorization(t *testing.T) {
|
||||
platformtesting.CreateAuthorization(initAuthorizationService, t)
|
||||
}
|
||||
|
||||
func TestAuthorizationService_FindAuthorizationByID(t *testing.T) {
|
||||
platformtesting.FindAuthorizationByID(initAuthorizationService, t)
|
||||
}
|
||||
|
||||
func TestAuthorizationService_FindAuthorizationByToken(t *testing.T) {
|
||||
platformtesting.FindAuthorizationByToken(initAuthorizationService, t)
|
||||
}
|
||||
|
||||
func TestAuthorizationService_FindAuthorizations(t *testing.T) {
|
||||
platformtesting.FindAuthorizations(initAuthorizationService, t)
|
||||
}
|
||||
|
||||
func TestAuthorizationService_DeleteAuthorization(t *testing.T) {
|
||||
platformtesting.DeleteAuthorization(initAuthorizationService, t)
|
||||
}
|
||||
|
|
@ -0,0 +1,229 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
var (
|
||||
errBucketNotFound = fmt.Errorf("bucket not found")
|
||||
)
|
||||
|
||||
func (c *Service) loadBucket(ctx context.Context, id platform.ID) (*platform.Bucket, error) {
|
||||
i, ok := c.bucketKV.Load(id.String())
|
||||
if !ok {
|
||||
return nil, errBucketNotFound
|
||||
}
|
||||
|
||||
b, ok := i.(platform.Bucket)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("type %T is not a bucket", i)
|
||||
}
|
||||
|
||||
if err := c.setOrganizationNameOnBucket(ctx, &b); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return &b, nil
|
||||
}
|
||||
|
||||
func (c *Service) setOrganizationNameOnBucket(ctx context.Context, b *platform.Bucket) error {
|
||||
o, err := c.loadOrganization(b.OrganizationID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
b.Organization = o.Name
|
||||
return nil
|
||||
}
|
||||
|
||||
// FindBucketByID returns a single bucket by ID.
|
||||
func (s *Service) FindBucketByID(ctx context.Context, id platform.ID) (*platform.Bucket, error) {
|
||||
return s.loadBucket(ctx, id)
|
||||
}
|
||||
|
||||
func (c *Service) forEachBucket(ctx context.Context, fn func(b *platform.Bucket) bool) error {
|
||||
var err error
|
||||
c.bucketKV.Range(func(k, v interface{}) bool {
|
||||
b, ok := v.(platform.Bucket)
|
||||
if !ok {
|
||||
err = fmt.Errorf("type %T is not a bucket", v)
|
||||
return false
|
||||
}
|
||||
return fn(&b)
|
||||
})
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Service) filterBuckets(ctx context.Context, fn func(b *platform.Bucket) bool) ([]*platform.Bucket, error) {
|
||||
buckets := []*platform.Bucket{}
|
||||
err := s.forEachBucket(ctx, func(b *platform.Bucket) bool {
|
||||
if fn(b) {
|
||||
buckets = append(buckets, b)
|
||||
}
|
||||
return true
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return buckets, nil
|
||||
}
|
||||
|
||||
// FindBucket returns the first bucket that matches filter.
|
||||
func (s *Service) FindBucket(ctx context.Context, filter platform.BucketFilter) (*platform.Bucket, error) {
|
||||
if filter.ID == nil && filter.Name == nil && filter.OrganizationID == nil {
|
||||
return nil, fmt.Errorf("no filter parameters provided")
|
||||
}
|
||||
|
||||
// filter by bucket id
|
||||
if filter.ID != nil {
|
||||
return s.FindBucketByID(ctx, *filter.ID)
|
||||
}
|
||||
|
||||
bs, n, err := s.FindBuckets(ctx, filter)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if n < 1 {
|
||||
return nil, fmt.Errorf("bucket not found")
|
||||
}
|
||||
|
||||
return bs[0], nil
|
||||
}
|
||||
|
||||
func (s *Service) findBuckets(ctx context.Context, filter platform.BucketFilter, opt ...platform.FindOptions) ([]*platform.Bucket, error) {
|
||||
// filter by bucket id
|
||||
if filter.ID != nil {
|
||||
b, err := s.FindBucketByID(ctx, *filter.ID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return []*platform.Bucket{b}, nil
|
||||
}
|
||||
|
||||
if filter.Organization != nil {
|
||||
o, err := s.findOrganizationByName(ctx, *filter.Organization)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
filter.OrganizationID = &o.ID
|
||||
}
|
||||
|
||||
filterFunc := func(b *platform.Bucket) bool { return true }
|
||||
|
||||
if filter.Name != nil && filter.OrganizationID != nil {
|
||||
filterFunc = func(b *platform.Bucket) bool {
|
||||
return b.Name == *filter.Name && bytes.Equal(b.OrganizationID, *filter.OrganizationID)
|
||||
}
|
||||
} else if filter.Name != nil {
|
||||
// filter by bucket name
|
||||
filterFunc = func(b *platform.Bucket) bool {
|
||||
return b.Name == *filter.Name
|
||||
}
|
||||
} else if filter.OrganizationID != nil {
|
||||
// filter by organization id
|
||||
filterFunc = func(b *platform.Bucket) bool {
|
||||
return bytes.Equal(b.OrganizationID, *filter.OrganizationID)
|
||||
}
|
||||
}
|
||||
|
||||
bs, err := s.filterBuckets(ctx, filterFunc)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
return bs, nil
|
||||
}
|
||||
|
||||
// FindBuckets returns a list of buckets that match filter and the total count of matching buckets.
|
||||
// Additional options provide pagination & sorting.
|
||||
func (s *Service) FindBuckets(ctx context.Context, filter platform.BucketFilter, opt ...platform.FindOptions) ([]*platform.Bucket, int, error) {
|
||||
bs, err := s.findBuckets(ctx, filter, opt...)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
for _, b := range bs {
|
||||
if err := s.setOrganizationNameOnBucket(ctx, b); err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
}
|
||||
return bs, len(bs), nil
|
||||
}
|
||||
|
||||
// CreateBucket creates a new bucket and sets b.ID with the new identifier.
|
||||
func (s *Service) CreateBucket(ctx context.Context, b *platform.Bucket) error {
|
||||
if len(b.OrganizationID) == 0 {
|
||||
o, err := s.findOrganizationByName(ctx, b.Organization)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
b.OrganizationID = o.ID
|
||||
}
|
||||
filter := platform.BucketFilter{
|
||||
Name: &b.Name,
|
||||
OrganizationID: &b.OrganizationID,
|
||||
}
|
||||
if _, err := s.FindBucket(ctx, filter); err == nil {
|
||||
return fmt.Errorf("bucket with name %s already exists", b.Name)
|
||||
}
|
||||
b.ID = s.IDGenerator.ID()
|
||||
return s.PutBucket(ctx, b)
|
||||
}
|
||||
|
||||
// PutBucket sets bucket with the current ID.
|
||||
func (s *Service) PutBucket(ctx context.Context, b *platform.Bucket) error {
|
||||
s.bucketKV.Store(b.ID.String(), *b)
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateBucket updates a single bucket with changeset.
|
||||
// Returns the new bucket state after update.
|
||||
func (s *Service) UpdateBucket(ctx context.Context, id platform.ID, upd platform.BucketUpdate) (*platform.Bucket, error) {
|
||||
b, err := s.FindBucketByID(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if upd.Name != nil {
|
||||
b.Name = *upd.Name
|
||||
}
|
||||
|
||||
if upd.RetentionPeriod != nil {
|
||||
b.RetentionPeriod = *upd.RetentionPeriod
|
||||
}
|
||||
|
||||
s.bucketKV.Store(b.ID.String(), b)
|
||||
|
||||
return b, nil
|
||||
}
|
||||
|
||||
// DeleteBucket removes a bucket by ID.
|
||||
func (s *Service) DeleteBucket(ctx context.Context, id platform.ID) error {
|
||||
if _, err := s.FindBucketByID(ctx, id); err != nil {
|
||||
return err
|
||||
}
|
||||
s.bucketKV.Delete(id.String())
|
||||
return nil
|
||||
|
||||
}
|
||||
|
||||
// DeleteOrganizationBuckets removes all the buckets for a given org
|
||||
func (s *Service) DeleteOrganizationBuckets(ctx context.Context, id platform.ID) error {
|
||||
bucks, err := s.findBuckets(ctx, platform.BucketFilter{
|
||||
OrganizationID: &id,
|
||||
})
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
for _, buck := range bucks {
|
||||
s.bucketKV.Delete(buck.ID.String())
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
platformtesting "github.com/influxdata/platform/testing"
|
||||
)
|
||||
|
||||
func initBucketService(f platformtesting.BucketFields, t *testing.T) (platform.BucketService, func()) {
|
||||
s := NewService()
|
||||
s.IDGenerator = f.IDGenerator
|
||||
ctx := context.TODO()
|
||||
for _, o := range f.Organizations {
|
||||
if err := s.PutOrganization(ctx, o); err != nil {
|
||||
t.Fatalf("failed to populate organizations")
|
||||
}
|
||||
}
|
||||
for _, b := range f.Buckets {
|
||||
if err := s.PutBucket(ctx, b); err != nil {
|
||||
t.Fatalf("failed to populate buckets")
|
||||
}
|
||||
}
|
||||
return s, func() {}
|
||||
}
|
||||
|
||||
func TestBucketService_CreateBucket(t *testing.T) {
|
||||
t.Skip("skipping to unblock")
|
||||
platformtesting.CreateBucket(initBucketService, t)
|
||||
}
|
||||
|
||||
func TestBucketService_FindBucketByID(t *testing.T) {
|
||||
platformtesting.FindBucketByID(initBucketService, t)
|
||||
}
|
||||
|
||||
func TestBucketService_FindBuckets(t *testing.T) {
|
||||
platformtesting.FindBuckets(initBucketService, t)
|
||||
}
|
||||
|
||||
func TestBucketService_DeleteBucket(t *testing.T) {
|
||||
platformtesting.DeleteBucket(initBucketService, t)
|
||||
}
|
||||
|
||||
func TestBucketService_FindBucket(t *testing.T) {
|
||||
platformtesting.FindBucket(initBucketService, t)
|
||||
}
|
||||
|
||||
func TestBucketService_UpdateBucket(t *testing.T) {
|
||||
platformtesting.UpdateBucket(initBucketService, t)
|
||||
}
|
||||
|
|
@ -0,0 +1,218 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
func (s *Service) loadDashboard(ctx context.Context, id platform.ID) (*platform.Dashboard, error) {
|
||||
i, ok := s.dashboardKV.Load(id.String())
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("dashboard not found")
|
||||
}
|
||||
|
||||
d, ok := i.(*platform.Dashboard)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("type %T is not a dashboard", i)
|
||||
}
|
||||
return d, nil
|
||||
}
|
||||
|
||||
// FindDashboardByID returns a single dashboard by ID.
|
||||
func (s *Service) FindDashboardByID(ctx context.Context, id platform.ID) (*platform.Dashboard, error) {
|
||||
return s.loadDashboard(ctx, id)
|
||||
}
|
||||
|
||||
func filterDashboardFn(filter platform.DashboardFilter) func(d *platform.Dashboard) bool {
|
||||
if filter.ID != nil {
|
||||
return func(d *platform.Dashboard) bool {
|
||||
return bytes.Equal(d.ID, *filter.ID)
|
||||
}
|
||||
}
|
||||
|
||||
return func(d *platform.Dashboard) bool { return true }
|
||||
}
|
||||
|
||||
// FindDashboards implements platform.DashboardService interface.
|
||||
func (s *Service) FindDashboards(ctx context.Context, filter platform.DashboardFilter) ([]*platform.Dashboard, int, error) {
|
||||
if filter.ID != nil {
|
||||
d, err := s.FindDashboardByID(ctx, *filter.ID)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return []*platform.Dashboard{d}, 1, nil
|
||||
}
|
||||
|
||||
var ds []*platform.Dashboard
|
||||
var err error
|
||||
filterF := filterDashboardFn(filter)
|
||||
s.dashboardKV.Range(func(k, v interface{}) bool {
|
||||
d, ok := v.(*platform.Dashboard)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
if filterF(d) {
|
||||
ds = append(ds, d)
|
||||
}
|
||||
return true
|
||||
})
|
||||
return ds, len(ds), err
|
||||
}
|
||||
|
||||
// CreateDashboard implements platform.DashboardService interface.
|
||||
func (s *Service) CreateDashboard(ctx context.Context, d *platform.Dashboard) error {
|
||||
d.ID = s.IDGenerator.ID()
|
||||
return s.PutDashboard(ctx, d)
|
||||
}
|
||||
|
||||
// PutDashboard implements platform.DashboardService interface.
|
||||
func (s *Service) PutDashboard(ctx context.Context, o *platform.Dashboard) error {
|
||||
s.dashboardKV.Store(o.ID.String(), o)
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateDashboard implements platform.DashboardService interface.
|
||||
func (s *Service) UpdateDashboard(ctx context.Context, id platform.ID, upd platform.DashboardUpdate) (*platform.Dashboard, error) {
|
||||
o, err := s.FindDashboardByID(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if upd.Name != nil {
|
||||
o.Name = *upd.Name
|
||||
}
|
||||
|
||||
s.dashboardKV.Store(o.ID.String(), o)
|
||||
|
||||
return o, nil
|
||||
}
|
||||
|
||||
// DeleteDashboard implements platform.DashboardService interface.
|
||||
func (s *Service) DeleteDashboard(ctx context.Context, id platform.ID) error {
|
||||
if _, err := s.FindDashboardByID(ctx, id); err != nil {
|
||||
return err
|
||||
}
|
||||
s.dashboardKV.Delete(id.String())
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) AddDashboardCell(ctx context.Context, id platform.ID, cell *platform.Cell, opts platform.AddDashboardCellOptions) error {
|
||||
d, err := s.FindDashboardByID(ctx, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cell.ID = s.IDGenerator.ID()
|
||||
if err := s.createViewIfNotExists(ctx, cell, opts); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
d.Cells = append(d.Cells, cell)
|
||||
return s.PutDashboard(ctx, d)
|
||||
}
|
||||
|
||||
func (s *Service) PutDashboardCell(ctx context.Context, id platform.ID, cell *platform.Cell) error {
|
||||
d, err := s.FindDashboardByID(ctx, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
view := &platform.View{}
|
||||
view.ID = cell.ViewID
|
||||
if err := s.PutView(ctx, view); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
d.Cells = append(d.Cells, cell)
|
||||
return s.PutDashboard(ctx, d)
|
||||
}
|
||||
|
||||
func (s *Service) RemoveDashboardCell(ctx context.Context, dashboardID platform.ID, cellID platform.ID) error {
|
||||
d, err := s.FindDashboardByID(ctx, dashboardID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
idx := -1
|
||||
for i, cell := range d.Cells {
|
||||
if bytes.Equal(cell.ID, cellID) {
|
||||
idx = i
|
||||
break
|
||||
}
|
||||
}
|
||||
if idx == -1 {
|
||||
return platform.ErrCellNotFound
|
||||
}
|
||||
|
||||
if err := s.DeleteView(ctx, d.Cells[idx].ViewID); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
d.Cells = append(d.Cells[:idx], d.Cells[idx+1:]...)
|
||||
return s.PutDashboard(ctx, d)
|
||||
|
||||
}
|
||||
|
||||
func (s *Service) UpdateDashboardCell(ctx context.Context, dashboardID platform.ID, cellID platform.ID, upd platform.CellUpdate) (*platform.Cell, error) {
|
||||
d, err := s.FindDashboardByID(ctx, dashboardID)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
idx := -1
|
||||
for i, cell := range d.Cells {
|
||||
if bytes.Equal(cell.ID, cellID) {
|
||||
idx = i
|
||||
break
|
||||
}
|
||||
}
|
||||
if idx == -1 {
|
||||
return nil, platform.ErrCellNotFound
|
||||
}
|
||||
|
||||
if err := upd.Apply(d.Cells[idx]); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
cell := d.Cells[idx]
|
||||
|
||||
if err := s.PutDashboard(ctx, d); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return cell, nil
|
||||
}
|
||||
|
||||
func (s *Service) ReplaceDashboardCells(ctx context.Context, id platform.ID, cs []*platform.Cell) error {
|
||||
d, err := s.FindDashboardByID(ctx, id)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
ids := map[string]*platform.Cell{}
|
||||
for _, cell := range d.Cells {
|
||||
ids[cell.ID.String()] = cell
|
||||
}
|
||||
|
||||
for _, cell := range cs {
|
||||
if len(cell.ID) == 0 {
|
||||
return fmt.Errorf("cannot provide empty cell id")
|
||||
}
|
||||
|
||||
cl, ok := ids[cell.ID.String()]
|
||||
if !ok {
|
||||
return fmt.Errorf("cannot replace cells that were not already present")
|
||||
}
|
||||
|
||||
if !bytes.Equal(cl.ViewID, cell.ViewID) {
|
||||
return fmt.Errorf("cannot update view id in replace")
|
||||
}
|
||||
}
|
||||
|
||||
d.Cells = cs
|
||||
|
||||
return s.PutDashboard(ctx, d)
|
||||
}
|
||||
|
|
@ -0,0 +1,61 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
platformtesting "github.com/influxdata/platform/testing"
|
||||
)
|
||||
|
||||
func initDashboardService(f platformtesting.DashboardFields, t *testing.T) (platform.DashboardService, func()) {
|
||||
s := NewService()
|
||||
s.IDGenerator = f.IDGenerator
|
||||
ctx := context.TODO()
|
||||
for _, b := range f.Dashboards {
|
||||
if err := s.PutDashboard(ctx, b); err != nil {
|
||||
t.Fatalf("failed to populate Dashboards")
|
||||
}
|
||||
}
|
||||
for _, b := range f.Views {
|
||||
if err := s.PutView(ctx, b); err != nil {
|
||||
t.Fatalf("failed to populate views")
|
||||
}
|
||||
}
|
||||
return s, func() {}
|
||||
}
|
||||
|
||||
func TestDashboardService_CreateDashboard(t *testing.T) {
|
||||
platformtesting.CreateDashboard(initDashboardService, t)
|
||||
}
|
||||
|
||||
func TestDashboardService_FindDashboardByID(t *testing.T) {
|
||||
platformtesting.FindDashboardByID(initDashboardService, t)
|
||||
}
|
||||
func TestDashboardService_FindDashboards(t *testing.T) {
|
||||
platformtesting.FindDashboards(initDashboardService, t)
|
||||
}
|
||||
|
||||
func TestDashboardService_DeleteDashboard(t *testing.T) {
|
||||
platformtesting.DeleteDashboard(initDashboardService, t)
|
||||
}
|
||||
|
||||
func TestDashboardService_UpdateDashboard(t *testing.T) {
|
||||
platformtesting.UpdateDashboard(initDashboardService, t)
|
||||
}
|
||||
|
||||
func TestDashboardService_AddDashboardCell(t *testing.T) {
|
||||
platformtesting.AddDashboardCell(initDashboardService, t)
|
||||
}
|
||||
|
||||
func TestDashboardService_RemoveDashboardCell(t *testing.T) {
|
||||
platformtesting.RemoveDashboardCell(initDashboardService, t)
|
||||
}
|
||||
|
||||
func TestDashboardService_UpdateDashboardCell(t *testing.T) {
|
||||
platformtesting.UpdateDashboardCell(initDashboardService, t)
|
||||
}
|
||||
|
||||
func TestDashboardService_ReplaceDashboardCells(t *testing.T) {
|
||||
platformtesting.ReplaceDashboardCells(initDashboardService, t)
|
||||
}
|
||||
|
|
@ -0,0 +1,150 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"path"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
var (
|
||||
errDBRPMappingNotFound = fmt.Errorf("dbrp mapping not found")
|
||||
)
|
||||
|
||||
func encodeDBRPMappingKey(cluster, db, rp string) string {
|
||||
return path.Join(cluster, db, rp)
|
||||
}
|
||||
|
||||
func (c *Service) loadDBRPMapping(ctx context.Context, cluster, db, rp string) (*platform.DBRPMapping, error) {
|
||||
i, ok := c.dbrpMappingKV.Load(encodeDBRPMappingKey(cluster, db, rp))
|
||||
if !ok {
|
||||
return nil, errDBRPMappingNotFound
|
||||
}
|
||||
|
||||
m, ok := i.(platform.DBRPMapping)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("type %T is not a dbrp mapping", i)
|
||||
}
|
||||
|
||||
return &m, nil
|
||||
}
|
||||
|
||||
// FindBy returns a single dbrp mapping by cluster, db and rp.
|
||||
func (s *Service) FindBy(ctx context.Context, cluster, db, rp string) (*platform.DBRPMapping, error) {
|
||||
return s.loadDBRPMapping(ctx, cluster, db, rp)
|
||||
}
|
||||
|
||||
func (c *Service) forEachDBRPMapping(ctx context.Context, fn func(m *platform.DBRPMapping) bool) error {
|
||||
var err error
|
||||
c.dbrpMappingKV.Range(func(k, v interface{}) bool {
|
||||
m, ok := v.(platform.DBRPMapping)
|
||||
if !ok {
|
||||
err = fmt.Errorf("type %T is not a dbrp mapping", v)
|
||||
return false
|
||||
}
|
||||
return fn(&m)
|
||||
})
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Service) filterDBRPMappings(ctx context.Context, fn func(m *platform.DBRPMapping) bool) ([]*platform.DBRPMapping, error) {
|
||||
mappings := []*platform.DBRPMapping{}
|
||||
err := s.forEachDBRPMapping(ctx, func(m *platform.DBRPMapping) bool {
|
||||
if fn(m) {
|
||||
mappings = append(mappings, m)
|
||||
}
|
||||
return true
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return mappings, nil
|
||||
}
|
||||
|
||||
// Find returns the first dbrp mapping that matches filter.
|
||||
func (s *Service) Find(ctx context.Context, filter platform.DBRPMappingFilter) (*platform.DBRPMapping, error) {
|
||||
if filter.Cluster == nil && filter.Database == nil && filter.RetentionPolicy == nil {
|
||||
return nil, fmt.Errorf("no filter parameters provided")
|
||||
}
|
||||
|
||||
// filter by dbrpMapping id
|
||||
if filter.Cluster != nil && filter.Database != nil && filter.RetentionPolicy != nil {
|
||||
return s.FindBy(ctx, *filter.Cluster, *filter.Database, *filter.RetentionPolicy)
|
||||
}
|
||||
|
||||
mappings, n, err := s.FindMany(ctx, filter)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if n < 1 {
|
||||
return nil, errDBRPMappingNotFound
|
||||
}
|
||||
|
||||
return mappings[0], nil
|
||||
}
|
||||
|
||||
// FindMany returns a list of dbrpMappings that match filter and the total count of matching dbrp mappings.
|
||||
// Additional options provide pagination & sorting.
|
||||
func (s *Service) FindMany(ctx context.Context, filter platform.DBRPMappingFilter, opt ...platform.FindOptions) ([]*platform.DBRPMapping, int, error) {
|
||||
// filter by dbrpMapping id
|
||||
if filter.Cluster != nil && filter.Database != nil && filter.RetentionPolicy != nil {
|
||||
m, err := s.FindBy(ctx, *filter.Cluster, *filter.Database, *filter.RetentionPolicy)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
return []*platform.DBRPMapping{m}, 1, nil
|
||||
}
|
||||
|
||||
filterFunc := func(mapping *platform.DBRPMapping) bool {
|
||||
return (filter.Cluster == nil || (*filter.Cluster) == mapping.Cluster) &&
|
||||
(filter.Database == nil || (*filter.Database) == mapping.Database) &&
|
||||
(filter.RetentionPolicy == nil || (*filter.RetentionPolicy) == mapping.RetentionPolicy) &&
|
||||
(filter.Default == nil || (*filter.Default) == mapping.Default)
|
||||
}
|
||||
|
||||
mappings, err := s.filterDBRPMappings(ctx, filterFunc)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return mappings, len(mappings), nil
|
||||
}
|
||||
|
||||
// Create creates a new dbrp mapping.
|
||||
func (s *Service) Create(ctx context.Context, m *platform.DBRPMapping) error {
|
||||
if err := m.Validate(); err != nil {
|
||||
return nil
|
||||
}
|
||||
existing, err := s.loadDBRPMapping(ctx, m.Cluster, m.Database, m.RetentionPolicy)
|
||||
if err != nil {
|
||||
if err == errDBRPMappingNotFound {
|
||||
return s.PutDBRPMapping(ctx, m)
|
||||
}
|
||||
return err
|
||||
}
|
||||
|
||||
if !existing.Equal(m) {
|
||||
return errors.New("dbrp mapping already exists")
|
||||
}
|
||||
|
||||
return s.PutDBRPMapping(ctx, m)
|
||||
}
|
||||
|
||||
// PutDBRPMapping sets dbrpMapping with the current ID.
|
||||
func (s *Service) PutDBRPMapping(ctx context.Context, m *platform.DBRPMapping) error {
|
||||
k := encodeDBRPMappingKey(m.Cluster, m.Database, m.RetentionPolicy)
|
||||
s.dbrpMappingKV.Store(k, *m)
|
||||
return nil
|
||||
}
|
||||
|
||||
// Delete removes a dbrp mapping
|
||||
func (s *Service) Delete(ctx context.Context, cluster, db, rp string) error {
|
||||
s.dbrpMappingKV.Delete(encodeDBRPMappingKey(cluster, db, rp))
|
||||
return nil
|
||||
}
|
||||
|
|
@ -0,0 +1,43 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
platformtesting "github.com/influxdata/platform/testing"
|
||||
)
|
||||
|
||||
func initDBRPMappingService(f platformtesting.DBRPMappingFields, t *testing.T) (platform.DBRPMappingService, func()) {
|
||||
s := NewService()
|
||||
ctx := context.TODO()
|
||||
if err := f.Populate(ctx, s); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return s, func() {}
|
||||
}
|
||||
|
||||
func TestDBRPMappingService_CreateDBRPMapping(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.CreateDBRPMapping(initDBRPMappingService, t)
|
||||
}
|
||||
|
||||
func TestDBRPMappingService_FindDBRPMappingByKey(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.FindDBRPMappingByKey(initDBRPMappingService, t)
|
||||
}
|
||||
|
||||
func TestDBRPMappingService_FindDBRPMappings(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.FindDBRPMappings(initDBRPMappingService, t)
|
||||
}
|
||||
|
||||
func TestDBRPMappingService_DeleteDBRPMapping(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.DeleteDBRPMapping(initDBRPMappingService, t)
|
||||
}
|
||||
|
||||
func TestDBRPMappingService_FindDBRPMapping(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.FindDBRPMapping(initDBRPMappingService, t)
|
||||
}
|
||||
|
|
@ -0,0 +1,147 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
var (
|
||||
errOrganizationNotFound = fmt.Errorf("organization not found")
|
||||
)
|
||||
|
||||
func (s *Service) loadOrganization(id platform.ID) (*platform.Organization, error) {
|
||||
i, ok := s.organizationKV.Load(id.String())
|
||||
if !ok {
|
||||
return nil, errOrganizationNotFound
|
||||
}
|
||||
|
||||
b, ok := i.(*platform.Organization)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("type %T is not a organization", i)
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
func (s *Service) forEachOrganization(ctx context.Context, fn func(b *platform.Organization) bool) error {
|
||||
var err error
|
||||
s.organizationKV.Range(func(k, v interface{}) bool {
|
||||
o, ok := v.(*platform.Organization)
|
||||
if !ok {
|
||||
err = fmt.Errorf("type %T is not a organization", v)
|
||||
return false
|
||||
}
|
||||
|
||||
return fn(o)
|
||||
})
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Service) filterOrganizations(ctx context.Context, fn func(b *platform.Organization) bool) ([]*platform.Organization, error) {
|
||||
orgs := []*platform.Organization{}
|
||||
err := s.forEachOrganization(ctx, func(o *platform.Organization) bool {
|
||||
if fn(o) {
|
||||
orgs = append(orgs, o)
|
||||
}
|
||||
return true
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return orgs, nil
|
||||
}
|
||||
|
||||
// FindOrganizationByID returns a single organization by ID.
|
||||
func (s *Service) FindOrganizationByID(ctx context.Context, id platform.ID) (*platform.Organization, error) {
|
||||
return s.loadOrganization(id)
|
||||
}
|
||||
|
||||
// FindOrganization returns the first organization that matches a filter.
|
||||
func (s *Service) FindOrganization(ctx context.Context, filter platform.OrganizationFilter) (*platform.Organization, error) {
|
||||
if filter.ID == nil && filter.Name == nil {
|
||||
return nil, fmt.Errorf("no filter parameters provided")
|
||||
}
|
||||
|
||||
if filter.ID != nil {
|
||||
return s.FindOrganizationByID(ctx, *filter.ID)
|
||||
}
|
||||
|
||||
orgs, n, err := s.FindOrganizations(ctx, filter)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
if n < 1 {
|
||||
return nil, fmt.Errorf("organization not found")
|
||||
}
|
||||
|
||||
return orgs[0], nil
|
||||
}
|
||||
|
||||
func (s *Service) FindOrganizations(ctx context.Context, filter platform.OrganizationFilter, opt ...platform.FindOptions) ([]*platform.Organization, int, error) {
|
||||
if filter.ID != nil {
|
||||
o, err := s.FindOrganizationByID(ctx, *filter.ID)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return []*platform.Organization{o}, 1, nil
|
||||
}
|
||||
|
||||
filterFunc := func(o *platform.Organization) bool { return true }
|
||||
if filter.Name != nil {
|
||||
filterFunc = func(o *platform.Organization) bool {
|
||||
return o.Name == *filter.Name
|
||||
}
|
||||
}
|
||||
|
||||
orgs, err := s.filterOrganizations(ctx, filterFunc)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return orgs, len(orgs), nil
|
||||
}
|
||||
|
||||
func (c *Service) findOrganizationByName(ctx context.Context, n string) (*platform.Organization, error) {
|
||||
return c.FindOrganization(ctx, platform.OrganizationFilter{Name: &n})
|
||||
}
|
||||
|
||||
func (s *Service) CreateOrganization(ctx context.Context, o *platform.Organization) error {
|
||||
if _, err := s.FindOrganization(ctx, platform.OrganizationFilter{Name: &o.Name}); err == nil {
|
||||
return fmt.Errorf("organization with name %s already exists", o.Name)
|
||||
}
|
||||
o.ID = s.IDGenerator.ID()
|
||||
return s.PutOrganization(ctx, o)
|
||||
}
|
||||
|
||||
func (s *Service) PutOrganization(ctx context.Context, o *platform.Organization) error {
|
||||
s.organizationKV.Store(o.ID.String(), o)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) UpdateOrganization(ctx context.Context, id platform.ID, upd platform.OrganizationUpdate) (*platform.Organization, error) {
|
||||
o, err := s.FindOrganizationByID(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if upd.Name != nil {
|
||||
o.Name = *upd.Name
|
||||
}
|
||||
|
||||
s.organizationKV.Store(o.ID.String(), o)
|
||||
|
||||
return o, nil
|
||||
}
|
||||
|
||||
func (s *Service) DeleteOrganization(ctx context.Context, id platform.ID) error {
|
||||
if _, err := s.FindOrganizationByID(ctx, id); err != nil {
|
||||
return err
|
||||
}
|
||||
s.organizationKV.Delete(id.String())
|
||||
return nil
|
||||
}
|
||||
|
|
@ -0,0 +1,45 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
platformtesting "github.com/influxdata/platform/testing"
|
||||
)
|
||||
|
||||
func initOrganizationService(f platformtesting.OrganizationFields, t *testing.T) (platform.OrganizationService, func()) {
|
||||
s := NewService()
|
||||
s.IDGenerator = f.IDGenerator
|
||||
ctx := context.TODO()
|
||||
for _, o := range f.Organizations {
|
||||
if err := s.PutOrganization(ctx, o); err != nil {
|
||||
t.Fatalf("failed to populate organizations")
|
||||
}
|
||||
}
|
||||
return s, func() {}
|
||||
}
|
||||
|
||||
func TestOrganizationService_CreateOrganization(t *testing.T) {
|
||||
platformtesting.CreateOrganization(initOrganizationService, t)
|
||||
}
|
||||
|
||||
func TestOrganizationService_FindOrganizationByID(t *testing.T) {
|
||||
platformtesting.FindOrganizationByID(initOrganizationService, t)
|
||||
}
|
||||
|
||||
func TestOrganizationService_FindOrganizations(t *testing.T) {
|
||||
platformtesting.FindOrganizations(initOrganizationService, t)
|
||||
}
|
||||
|
||||
func TestOrganizationService_DeleteOrganization(t *testing.T) {
|
||||
platformtesting.DeleteOrganization(initOrganizationService, t)
|
||||
}
|
||||
|
||||
func TestOrganizationService_FindOrganization(t *testing.T) {
|
||||
platformtesting.FindOrganization(initOrganizationService, t)
|
||||
}
|
||||
|
||||
func TestOrganizationService_UpdateOrganization(t *testing.T) {
|
||||
platformtesting.UpdateOrganization(initOrganizationService, t)
|
||||
}
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"sync"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
"github.com/influxdata/platform/rand"
|
||||
"github.com/influxdata/platform/snowflake"
|
||||
)
|
||||
|
||||
// Service implements various top level services.
|
||||
type Service struct {
|
||||
authorizationKV sync.Map
|
||||
organizationKV sync.Map
|
||||
bucketKV sync.Map
|
||||
userKV sync.Map
|
||||
dashboardKV sync.Map
|
||||
viewKV sync.Map
|
||||
dbrpMappingKV sync.Map
|
||||
userResourceMappingKV sync.Map
|
||||
|
||||
TokenGenerator platform.TokenGenerator
|
||||
IDGenerator platform.IDGenerator
|
||||
}
|
||||
|
||||
// NewService creates an instance of a Service.
|
||||
func NewService() *Service {
|
||||
return &Service{
|
||||
TokenGenerator: rand.NewTokenGenerator(64),
|
||||
IDGenerator: snowflake.NewIDGenerator(),
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,93 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"path"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
func encodeUserResourceMappingKey(resourceID, userID platform.ID) string {
|
||||
return path.Join(resourceID.String(), userID.String())
|
||||
}
|
||||
|
||||
func (s *Service) loadUserResourceMapping(ctx context.Context, resourceID, userID platform.ID) (*platform.UserResourceMapping, error) {
|
||||
i, ok := s.userResourceMappingKV.Load(encodeUserResourceMappingKey(resourceID, userID))
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("userResource mapping not found")
|
||||
}
|
||||
|
||||
m, ok := i.(platform.UserResourceMapping)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("type %T is not an userResource mapping", i)
|
||||
}
|
||||
|
||||
return &m, nil
|
||||
}
|
||||
|
||||
func (s *Service) FindUserResourceBy(ctx context.Context, resourceID, userID platform.ID) (*platform.UserResourceMapping, error) {
|
||||
return s.loadUserResourceMapping(ctx, resourceID, userID)
|
||||
}
|
||||
|
||||
func (s *Service) forEachUserResourceMapping(ctx context.Context, fn func(m *platform.UserResourceMapping) bool) error {
|
||||
var err error
|
||||
s.userResourceMappingKV.Range(func(k, v interface{}) bool {
|
||||
m, ok := v.(platform.UserResourceMapping)
|
||||
if !ok {
|
||||
err = fmt.Errorf("type %T is not a userResource mapping", v)
|
||||
return false
|
||||
}
|
||||
return fn(&m)
|
||||
})
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
func (s *Service) filterUserResourceMappings(ctx context.Context, fn func(m *platform.UserResourceMapping) bool) ([]*platform.UserResourceMapping, error) {
|
||||
mappings := []*platform.UserResourceMapping{}
|
||||
err := s.forEachUserResourceMapping(ctx, func(m *platform.UserResourceMapping) bool {
|
||||
if fn(m) {
|
||||
mappings = append(mappings, m)
|
||||
}
|
||||
return true
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return mappings, nil
|
||||
}
|
||||
|
||||
func (s *Service) FindManyUserResourceMappings(ctx context.Context, filter platform.UserResourceMappingFilter, opt ...platform.FindOptions) ([]*platform.UserResourceMapping, int, error) {
|
||||
if filter.ResourceID != nil && filter.UserID != nil {
|
||||
m, err := s.FindUserResourceBy(ctx, filter.ResourceID, filter.UserID)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
return []*platform.UserResourceMapping{m}, 1, nil
|
||||
}
|
||||
|
||||
filterFunc := func(mapping *platform.UserResourceMapping) bool {
|
||||
return (filter.UserID == nil || (filter.UserID.String()) == mapping.UserID.String()) &&
|
||||
(filter.ResourceID == nil || (filter.ResourceID.String()) == mapping.ResourceID.String())
|
||||
}
|
||||
|
||||
mappings, err := s.filterUserResourceMappings(ctx, filterFunc)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return mappings, len(mappings), nil
|
||||
}
|
||||
|
||||
func (s *Service) PutUserResourceMapping(ctx context.Context, m *platform.UserResourceMapping) error {
|
||||
s.userResourceMappingKV.Store(encodeUserResourceMappingKey(m.ResourceID, m.UserID), *m)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) DeleteUserResourceMapping(ctx context.Context, resourceID, userID platform.ID) error {
|
||||
s.userResourceMappingKV.Delete(encodeUserResourceMappingKey(resourceID, userID))
|
||||
return nil
|
||||
}
|
||||
|
|
@ -0,0 +1,141 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
func (s *Service) loadUser(id platform.ID) (*platform.User, error) {
|
||||
i, ok := s.userKV.Load(id.String())
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("user not found")
|
||||
}
|
||||
|
||||
b, ok := i.(*platform.User)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("type %T is not a user", i)
|
||||
}
|
||||
return b, nil
|
||||
}
|
||||
|
||||
func (s *Service) forEachUser(ctx context.Context, fn func(b *platform.User) bool) error {
|
||||
var err error
|
||||
s.userKV.Range(func(k, v interface{}) bool {
|
||||
o, ok := v.(*platform.User)
|
||||
if !ok {
|
||||
err = fmt.Errorf("type %T is not a user", v)
|
||||
return false
|
||||
}
|
||||
|
||||
return fn(o)
|
||||
})
|
||||
|
||||
return err
|
||||
}
|
||||
|
||||
// FindUserByID returns a single user by ID.
|
||||
func (s *Service) FindUserByID(ctx context.Context, id platform.ID) (*platform.User, error) {
|
||||
return s.loadUser(id)
|
||||
}
|
||||
|
||||
func (c *Service) findUserByName(ctx context.Context, n string) (*platform.User, error) {
|
||||
return c.FindUser(ctx, platform.UserFilter{Name: &n})
|
||||
}
|
||||
|
||||
// FindUser returns the first user that matches a filter.
|
||||
func (s *Service) FindUser(ctx context.Context, filter platform.UserFilter) (*platform.User, error) {
|
||||
if filter.Name != nil {
|
||||
var o *platform.User
|
||||
|
||||
err := s.forEachUser(ctx, func(org *platform.User) bool {
|
||||
if org.Name == *filter.Name {
|
||||
o = org
|
||||
return false
|
||||
}
|
||||
return true
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if o == nil {
|
||||
return nil, fmt.Errorf("user not found")
|
||||
}
|
||||
|
||||
return o, nil
|
||||
}
|
||||
|
||||
return nil, fmt.Errorf("expected filter to contain name")
|
||||
}
|
||||
|
||||
func (s *Service) FindUsers(ctx context.Context, filter platform.UserFilter, opt ...platform.FindOptions) ([]*platform.User, int, error) {
|
||||
if filter.ID != nil {
|
||||
o, err := s.FindUserByID(ctx, *filter.ID)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return []*platform.User{o}, 1, nil
|
||||
}
|
||||
if filter.Name != nil {
|
||||
o, err := s.FindUser(ctx, filter)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return []*platform.User{o}, 1, nil
|
||||
}
|
||||
|
||||
orgs := []*platform.User{}
|
||||
|
||||
err := s.forEachUser(ctx, func(org *platform.User) bool {
|
||||
orgs = append(orgs, org)
|
||||
return true
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return orgs, len(orgs), nil
|
||||
}
|
||||
|
||||
func (s *Service) CreateUser(ctx context.Context, u *platform.User) error {
|
||||
if _, err := s.FindUser(ctx, platform.UserFilter{Name: &u.Name}); err == nil {
|
||||
return fmt.Errorf("user with name %s already exists", u.Name)
|
||||
}
|
||||
u.ID = s.IDGenerator.ID()
|
||||
s.PutUser(ctx, u)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) PutUser(ctx context.Context, o *platform.User) error {
|
||||
s.userKV.Store(o.ID.String(), o)
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) UpdateUser(ctx context.Context, id platform.ID, upd platform.UserUpdate) (*platform.User, error) {
|
||||
o, err := s.FindUserByID(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if upd.Name != nil {
|
||||
o.Name = *upd.Name
|
||||
}
|
||||
|
||||
s.userKV.Store(o.ID.String(), o)
|
||||
|
||||
return o, nil
|
||||
}
|
||||
|
||||
func (s *Service) DeleteUser(ctx context.Context, id platform.ID) error {
|
||||
if _, err := s.FindUserByID(ctx, id); err != nil {
|
||||
return err
|
||||
}
|
||||
s.userKV.Delete(id.String())
|
||||
return nil
|
||||
}
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
platformtesting "github.com/influxdata/platform/testing"
|
||||
)
|
||||
|
||||
func initUserService(f platformtesting.UserFields, t *testing.T) (platform.UserService, func()) {
|
||||
s := NewService()
|
||||
s.IDGenerator = f.IDGenerator
|
||||
ctx := context.TODO()
|
||||
for _, u := range f.Users {
|
||||
if err := s.PutUser(ctx, u); err != nil {
|
||||
t.Fatalf("failed to populate users")
|
||||
}
|
||||
}
|
||||
return s, func() {}
|
||||
}
|
||||
|
||||
func TestUserService_CreateUser(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.CreateUser(initUserService, t)
|
||||
}
|
||||
|
||||
func TestUserService_FindUserByID(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.FindUserByID(initUserService, t)
|
||||
}
|
||||
|
||||
func TestUserService_FindUsers(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.FindUsers(initUserService, t)
|
||||
}
|
||||
|
||||
func TestUserService_DeleteUser(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.DeleteUser(initUserService, t)
|
||||
}
|
||||
|
||||
func TestUserService_FindUser(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.FindUser(initUserService, t)
|
||||
}
|
||||
|
||||
func TestUserService_UpdateUser(t *testing.T) {
|
||||
t.Parallel()
|
||||
platformtesting.UpdateUser(initUserService, t)
|
||||
}
|
||||
|
|
@ -0,0 +1,161 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"fmt"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
)
|
||||
|
||||
func (s *Service) loadView(ctx context.Context, id platform.ID) (*platform.View, error) {
|
||||
i, ok := s.viewKV.Load(id.String())
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("View not found")
|
||||
}
|
||||
|
||||
d, ok := i.(*platform.View)
|
||||
if !ok {
|
||||
return nil, fmt.Errorf("type %T is not a view", i)
|
||||
}
|
||||
return d, nil
|
||||
}
|
||||
|
||||
// FindViewByID returns a single view by ID.
|
||||
func (s *Service) FindViewByID(ctx context.Context, id platform.ID) (*platform.View, error) {
|
||||
return s.loadView(ctx, id)
|
||||
}
|
||||
|
||||
func filterViewFn(filter platform.ViewFilter) func(d *platform.View) bool {
|
||||
if filter.ID != nil {
|
||||
return func(d *platform.View) bool {
|
||||
return bytes.Equal(d.ID, *filter.ID)
|
||||
}
|
||||
}
|
||||
|
||||
return func(d *platform.View) bool { return true }
|
||||
}
|
||||
|
||||
// FindViews implements platform.ViewService interface.
|
||||
func (s *Service) FindViews(ctx context.Context, filter platform.ViewFilter) ([]*platform.View, int, error) {
|
||||
if filter.ID != nil {
|
||||
d, err := s.FindViewByID(ctx, *filter.ID)
|
||||
if err != nil {
|
||||
return nil, 0, err
|
||||
}
|
||||
|
||||
return []*platform.View{d}, 1, nil
|
||||
}
|
||||
|
||||
var ds []*platform.View
|
||||
var err error
|
||||
filterF := filterViewFn(filter)
|
||||
s.viewKV.Range(func(k, v interface{}) bool {
|
||||
d, ok := v.(*platform.View)
|
||||
if !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
if filterF(d) {
|
||||
ds = append(ds, d)
|
||||
}
|
||||
return true
|
||||
})
|
||||
return ds, len(ds), err
|
||||
}
|
||||
|
||||
// CreateView implements platform.ViewService interface.
|
||||
func (s *Service) CreateView(ctx context.Context, c *platform.View) error {
|
||||
c.ID = s.IDGenerator.ID()
|
||||
return s.PutView(ctx, c)
|
||||
}
|
||||
|
||||
// PutView implements platform.ViewService interface.
|
||||
func (s *Service) PutView(ctx context.Context, c *platform.View) error {
|
||||
if c.Properties == nil {
|
||||
c.Properties = platform.EmptyViewProperties{}
|
||||
}
|
||||
s.viewKV.Store(c.ID.String(), c)
|
||||
return nil
|
||||
}
|
||||
|
||||
// UpdateView implements platform.ViewService interface.
|
||||
func (s *Service) UpdateView(ctx context.Context, id platform.ID, upd platform.ViewUpdate) (*platform.View, error) {
|
||||
c, err := s.FindViewByID(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
if upd.Name != nil {
|
||||
c.Name = *upd.Name
|
||||
}
|
||||
|
||||
if upd.Properties != nil {
|
||||
c.Properties = upd.Properties
|
||||
}
|
||||
|
||||
s.viewKV.Store(c.ID.String(), c)
|
||||
|
||||
return c, nil
|
||||
}
|
||||
|
||||
// DeleteView implements platform.ViewService interface.
|
||||
func (s *Service) DeleteView(ctx context.Context, id platform.ID) error {
|
||||
if _, err := s.FindViewByID(ctx, id); err != nil {
|
||||
return err
|
||||
}
|
||||
s.viewKV.Delete(id.String())
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) createViewIfNotExists(ctx context.Context, cell *platform.Cell, opts platform.AddDashboardCellOptions) error {
|
||||
if len(opts.UsingView) != 0 {
|
||||
// Creates a hard copy of a view
|
||||
v, err := s.FindViewByID(ctx, opts.UsingView)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
view, err := s.copyView(ctx, v.ID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
cell.ViewID = view.ID
|
||||
return nil
|
||||
} else if len(cell.ViewID) != 0 {
|
||||
// Creates a soft copy of a view
|
||||
_, err := s.FindViewByID(ctx, cell.ViewID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// If not view exists create the view
|
||||
view := &platform.View{}
|
||||
if err := s.CreateView(ctx, view); err != nil {
|
||||
return err
|
||||
}
|
||||
cell.ViewID = view.ID
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (s *Service) copyView(ctx context.Context, id platform.ID) (*platform.View, error) {
|
||||
v, err := s.FindViewByID(ctx, id)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
view := &platform.View{
|
||||
ViewContents: platform.ViewContents{
|
||||
Name: v.Name,
|
||||
},
|
||||
Properties: v.Properties,
|
||||
}
|
||||
|
||||
if err := s.CreateView(ctx, view); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return view, nil
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
package inmem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"testing"
|
||||
|
||||
"github.com/influxdata/platform"
|
||||
platformtesting "github.com/influxdata/platform/testing"
|
||||
)
|
||||
|
||||
func initViewService(f platformtesting.ViewFields, t *testing.T) (platform.ViewService, func()) {
|
||||
s := NewService()
|
||||
s.IDGenerator = f.IDGenerator
|
||||
ctx := context.TODO()
|
||||
for _, b := range f.Views {
|
||||
if err := s.PutView(ctx, b); err != nil {
|
||||
t.Fatalf("failed to populate Views")
|
||||
}
|
||||
}
|
||||
return s, func() {}
|
||||
}
|
||||
|
||||
func TestViewService_CreateView(t *testing.T) {
|
||||
platformtesting.CreateView(initViewService, t)
|
||||
}
|
||||
|
||||
func TestViewService_FindViewByID(t *testing.T) {
|
||||
platformtesting.FindViewByID(initViewService, t)
|
||||
}
|
||||
func TestViewService_FindViews(t *testing.T) {
|
||||
platformtesting.FindViews(initViewService, t)
|
||||
}
|
||||
|
||||
func TestViewService_DeleteView(t *testing.T) {
|
||||
platformtesting.DeleteView(initViewService, t)
|
||||
}
|
||||
|
||||
func TestViewService_UpdateView(t *testing.T) {
|
||||
platformtesting.UpdateView(initViewService, t)
|
||||
}
|
||||
Loading…
Reference in New Issue