DeforaNetworks/corteza
3
0
Fork 0
Code Activity

Remove legacy bits

Browse Source
This commit is contained in:
Tomaž Jerman
2020-11-27 11:19:15 +01:00
parent be08351969
commit 22de4d2b80
18 changed files with 0 additions and 1138 deletions
Download Patch File Download Diff File Expand all files Collapse all files
pkg/envoy/store/application.go
-22
View File
@@ -1,22 +0,0 @@
package store
import (
"context"
"time"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
)
func storeApplication(ctx context.Context, s store.Storer, n *node.Application) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateApplication(ctx, s, n.Res)
}
pkg/envoy/store/compose_chart.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
"time"
)
func storeComposeChart(ctx context.Context, s store.Storer, n *node.ComposeChart) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateComposeChart(ctx, s, n.Res)
}
pkg/envoy/store/compose_module.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
"time"
)
func storeComposeModule(ctx context.Context, s store.Storer, n *node.ComposeModule) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateComposeModule(ctx, s, n.Res)
}
pkg/envoy/store/compose_namespace.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
"time"
)
func storeComposeNamespace(ctx context.Context, s store.Storer, n *node.ComposeNamespace) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateComposeNamespace(ctx, s, n.Res)
}
pkg/envoy/store/compose_page.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
"time"
)
func storeComposePage(ctx context.Context, s store.Storer, n *node.ComposePage) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateComposePage(ctx, s, n.Res)
}
pkg/envoy/store/compose_record.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
)
func storeComposeRecord(ctx context.Context, s store.Storer, n *node.ComposeRecordSet) error {
//var (
// res = n.Res
//)
//
//res.ID = nextID()
//if res.CreatedAt.IsZero() {
// res.CreatedAt = time.Now()
//}
//
//return store.CreateComposeRecord(ctx, s, n.Res)
return nil
}
pkg/envoy/store/encoder.go
-196
View File
@@ -1,196 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/compose/service/values"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/pkg/envoy"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
)
type (
StoreEncoder struct {
s store.Storer
}
)
var (
rvSanitizer = values.Sanitizer()
rvValidator = values.Validator()
)
func NewStoreEncoder(s store.Storer) *StoreEncoder {
return &StoreEncoder{
s: s,
}
}
func (se *StoreEncoder) Encode(ctx context.Context, nn ...envoy.Node) error {
return store.Tx(ctx, se.s, func(ctx context.Context, s store.Storer) (err error) {
for _, n := range nn {
switch n := n.(type) {
case *node.Application:
err = storeApplication(ctx, s, n)
case *node.Role:
err = storeRole(ctx, s, n)
case *node.User:
err = storeUser(ctx, s, n)
case *node.ComposeChart:
err = storeComposeChart(ctx, s, n)
case *node.ComposeModule:
err = storeComposeModule(ctx, s, n)
case *node.ComposePage:
err = storeComposePage(ctx, s, n)
case *node.ComposeNamespace:
err = storeComposeNamespace(ctx, s, n)
case *node.ComposeRecordSet:
err = storeComposeRecord(ctx, s, n)
}
//switch n.Resource() {
//case types.NamespaceRBACResource.String():
// ns := n.(*node.ComposeNamespace)
// if ns.Ns, err = se.encodeNamespace(ctx, s, ns); err != nil {
// return
// }
//
//case types.ModuleRBACResource.String():
// mod := n.(*node.ComposeModule)
// if mod.Module, err = se.encodeModule(ctx, s, mod); err != nil {
// return
// }
//
// //case "compose:record:":
// // rec := n.(*envoy.ComposeRecordSet)
// //
// // if err = se.encodeRecord(ctx, s, rec); err != nil {
// // return
// // }
//}
}
return nil
})
}
//func (se *StoreEncoder) encodeNamespace(ctx context.Context, s store.Storer, n *envoy.ComposeNamespaceNode) (*types.Namespace, error) {
// cns := n.Ns
//
// // @todo this should probably be refactored (together with services)
// // so that core logic is handled in one place
// cns.ID = nextID()
// if cns.CreatedAt.IsZero() {
// cns.CreatedAt = time.Now()
// }
//
// if err := store.CreateComposeNamespace(ctx, s, cns); err != nil {
// return nil, err
// }
//
// return cns, nil
//}
//
//func (se *StoreEncoder) encodeModule(ctx context.Context, s store.Storer, m *envoy.ComposeModuleNode) (*types.Module, error) {
// mod := m.Module
//
// // @todo this should probably be refactored (together with services)
// // so that core logic is handled in one place
// mod.ID = nextID()
//
// if mod.CreatedAt.IsZero() {
// mod.CreatedAt = time.Now()
// }
//
// // Store the module
// if err := store.CreateComposeModule(ctx, s, mod); err != nil {
// return nil, err
// }
//
// // Store module fields
// for _, f := range mod.Fields {
// f.ID = nextID()
// f.ModuleID = mod.ID
//
// if err := store.CreateComposeModuleField(ctx, s, f); err != nil {
// return nil, err
// }
//
// // Update the original module fields so dependant resources can proceed without issues
// mod.Fields = append(mod.Fields, f)
// }
//
// return mod, nil
//}
//func (se *StoreEncoder) encodeRecord(ctx context.Context, s store.Storer, m *envoy.ComposeRecordSet) error {
// mod := m.Mod
//
// // @todo a bit less ad-hoc-ish solution
// return m.Walk(func(rec *types.Record) error {
// // @todo this should probably be refactored (together with services)
// // so that core logic is handled in one place
//
// rec.ID = nextID()
// rec.ModuleID = mod.ID
// rec.NamespaceID = mod.NamespaceID
//
// if rec.CreatedAt.IsZero() {
// rec.CreatedAt = time.Now()
// }
//
// rec.Values = make(types.RecordValueSet, 0, 100)
//
// // Process record values
// for _, crv := range rec.Values {
// crv.RecordID = rec.ID
// rec.Values = append(rec.Values, crv)
// }
// rec.Values.SetUpdatedFlag(true)
// rec.Values = se.setDefaultComposeRecordValues(mod, rec.Values)
// rec.Values = rvSanitizer.Run(mod, rec.Values)
// err := rvValidator.Run(ctx, s, mod, rec)
// if err != nil {
// return err
// }
//
// if err := store.CreateComposeRecord(ctx, s, m.Mod, rec); err != nil {
// return err
// }
//
// return nil
// })
//}
// @note this method is coppied over from the compose/service/record.
// Would it be better to unify the two methods?
func (se *StoreEncoder) setDefaultComposeRecordValues(m *types.Module, vv types.RecordValueSet) (out types.RecordValueSet) {
out = vv
for _, f := range m.Fields {
if f.DefaultValue == nil {
continue
}
for i, dv := range f.DefaultValue {
// Default values on field are (might be) without field name and place
if !out.Has(f.Name, uint(i)) {
out = append(out, &types.RecordValue{
Name: f.Name,
Value: dv.Value,
Place: uint(i),
})
}
}
}
return
}
pkg/envoy/store/rbac_rules.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
"time"
)
func storeRbacRules(ctx context.Context, s store.Storer, n *node.Role) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateRole(ctx, s, n.Res)
}
pkg/envoy/store/role.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
"time"
)
func storeRole(ctx context.Context, s store.Storer, n *node.Role) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateRole(ctx, s, n.Res)
}
pkg/envoy/store/user.go
-21
View File
@@ -1,21 +0,0 @@
package store
import (
"context"
"github.com/cortezaproject/corteza-server/pkg/envoy/node"
"github.com/cortezaproject/corteza-server/store"
"time"
)
func storeUser(ctx context.Context, s store.Storer, n *node.User) error {
var (
res = n.Res
)
res.ID = nextID()
if res.CreatedAt.IsZero() {
res.CreatedAt = time.Now()
}
return store.CreateUser(ctx, s, n.Res)
}
pkg/envoy/store/util.go
-10
View File
@@ -1,10 +0,0 @@
package store
import "github.com/cortezaproject/corteza-server/pkg/id"
var (
// wrapper around nextID that will aid service testing
nextID = func() uint64 {
return id.Next()
}
)
pkg/envoy/tmp/compose_module.go
-192
View File
@@ -1,192 +0,0 @@
package tmp
import (
"context"
"errors"
"fmt"
"time"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/pkg/envoy"
"github.com/cortezaproject/corteza-server/pkg/envoy/resource"
"github.com/cortezaproject/corteza-server/store"
)
type (
composeModule struct {
es *encoderState
s store.Storer
}
)
func NewComposeModule(es *encoderState, s store.Storer) *composeModule {
return &composeModule{
es: es,
s: s,
}
}
func (p *composeModule) Process(ctx context.Context, state *envoy.ExecState) error {
res, is := state.Res.(*resource.ComposeModule)
if !is {
return nil
}
// Get relate namespace
ns, err := findNamespace(ctx, p.s, state.ParentResources, res.NsRef.Identifiers)
if err != nil {
return err
}
if ns == nil {
return errors.New("@todo couldn't resolve namespace")
}
p.es.Set(res, res.NsRef.ResourceType, ns.ID, res.NsRef.Identifiers.StringSlice()...)
// Check if the current module exits
f := moduleFilterFromGeneric(GenericFilter(res.Identifiers()))
f.NamespaceID = ns.ID
mod, err := loadComposeModule(ctx, p.s, f)
if err != nil {
return err
}
if mod != nil {
p.es.SetExists(res)
p.es.Set(res, res.ResourceType(), mod.ID, res.Identifiers().StringSlice()...)
}
// Go over missing deps and handle those
for _, m := range state.MissingDeps {
switch m.ResourceType {
case resource.COMPOSE_MODULE_RESOURCE_TYPE:
f := moduleFilterFromGeneric(GenericFilter(m.Identifiers))
f.NamespaceID = ns.ID
mod, err := loadComposeModule(ctx, p.s, f)
if err != nil {
return err
} else if mod == nil {
continue
}
p.es.Set(res, resource.COMPOSE_MODULE_RESOURCE_TYPE, mod.ID, m.Identifiers.StringSlice()...)
}
}
return nil
}
func encodeComposeModule(ctx context.Context, ectx *encodingContext, s store.Storer, state resRefs, res *resource.ComposeModule) (resRefs, error) {
var (
mod = res.Res
rState = make(resRefs)
)
mod.ID = state.Get(res)
if mod.ID <= 0 {
mod.ID = nextID()
}
if mod.CreatedAt.IsZero() {
mod.CreatedAt = time.Now()
}
rState.Set(resource.COMPOSE_MODULE_RESOURCE_TYPE, mod.ID, res.Identifiers().StringSlice()...)
// Namespace...
// A module can exist under a single namespace, so this is good enough for now
for _, v := range state[resource.COMPOSE_NAMESPACE_RESOURCE_TYPE] {
mod.NamespaceID = v
break
}
if !ectx.partial && !ectx.exists {
for i, f := range mod.Fields {
f.ID = nextID()
f.ModuleID = mod.ID
f.Place = i
f.DeletedAt = nil
if f.Kind == "Record" {
refM := f.Options.String("module")
mID := state[resource.COMPOSE_MODULE_RESOURCE_TYPE][refM]
if mID > 0 {
f.Options["module"] = mID
}
}
}
err := store.CreateComposeModule(ctx, s, mod)
if err != nil {
return nil, err
}
err = store.CreateComposeModuleField(ctx, s, mod.Fields...)
if err != nil {
return nil, err
}
}
return rState, nil
}
func moduleFilterFromGeneric(gf genericFilter) types.ModuleFilter {
f := types.ModuleFilter{
Name: gf.Name,
Handle: gf.Ref,
}
if gf.ID > 0 {
f.Query = fmt.Sprintf("moduleID=%d", gf.ID)
}
return f
}
func findModule(ctx context.Context, s store.Storer, rr []resource.Interface, ii resource.Identifiers) (ns *types.Module, err error) {
// Try to find it in the parent resources
var modRes *resource.ComposeModule
walkResources(rr, func(r resource.Interface) error {
mR, ok := r.(*resource.ComposeModule)
if !ok {
return nil
}
if mR.Identifiers().HasAny(r.Identifiers().StringSlice()...) {
modRes = mR
}
return nil
})
// Found it
if modRes != nil {
return modRes.Res, nil
}
// Go in the store
f := moduleFilterFromGeneric(GenericFilter(ii))
return loadComposeModule(ctx, s, f)
}
func loadComposeModule(ctx context.Context, s store.Storer, f types.ModuleFilter) (*types.Module, error) {
mdd, f, err := store.SearchComposeModules(ctx, s, f)
if err != nil {
return nil, err
}
if len(mdd) > 0 {
return mdd[0], nil
}
return nil, nil
}
func loadComposeModuleFields(ctx context.Context, s store.Storer, mod *types.Module) (types.ModuleFieldSet, error) {
if mod.ID <= 0 {
return mod.Fields, nil
}
f := types.ModuleFieldFilter{
ModuleID: []uint64{mod.ID},
}
ff, f, err := store.SearchComposeModuleFields(ctx, s, f)
if err != nil {
return nil, err
}
return ff, nil
}
pkg/envoy/tmp/compose_namespace.go
-127
View File
@@ -1,127 +0,0 @@
package tmp
import (
"context"
"fmt"
"time"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/pkg/envoy"
"github.com/cortezaproject/corteza-server/pkg/envoy/resource"
"github.com/cortezaproject/corteza-server/store"
)
type (
composeNamespacePreproc struct {
es *encoderState
s store.Storer
}
)
func NewComposeNamespacePreproc(es *encoderState, s store.Storer) envoy.Processor {
return &composeNamespacePreproc{
es: es,
s: s,
}
}
func (p *composeNamespacePreproc) Process(ctx context.Context, state *envoy.ExecState) error {
res, is := state.Res.(*resource.ComposeNamespace)
if !is {
return nil
}
// Check if the given namespace exists
// Namespaces are top-level resources, so they don't depend on anything;
// no other checks are needed
ns, err := loadComposeNamespace(ctx, p.s, namespaceFilterFromGeneric(GenericFilter(res.Identifiers())))
if err != nil {
return err
}
if ns != nil {
p.es.SetExists(res)
p.es.Set(res, res.ResourceType(), ns.ID, res.Identifiers().StringSlice()...)
}
return nil
}
func encodeComposeNamespace(ctx context.Context, ectx *encodingContext, s store.Storer, state resRefs, res *resource.ComposeNamespace) (resRefs, error) {
var (
ns = res.Res
rState = make(resRefs)
)
ns.ID = state.Get(res)
if ns.ID <= 0 {
ns.ID = nextID()
}
if ns.CreatedAt.IsZero() {
ns.CreatedAt = time.Now()
}
rState.Set(resource.COMPOSE_NAMESPACE_RESOURCE_TYPE, ns.ID, res.Identifiers().StringSlice()...)
if !ectx.partial && !ectx.exists {
err := store.CreateComposeNamespace(ctx, s, ns)
if err != nil {
return nil, err
}
}
return rState, nil
}
// Utils
func namespaceFilterFromGeneric(gf genericFilter) types.NamespaceFilter {
f := types.NamespaceFilter{
Name: gf.Name,
Slug: gf.Ref,
}
if gf.ID > 0 {
f.Query = fmt.Sprintf("namespaceID=%d", gf.ID)
}
return f
}
func findNamespace(ctx context.Context, s store.Storer, rr []resource.Interface, ii resource.Identifiers) (ns *types.Namespace, err error) {
// Try to find it in the parent resources
var nsRes *resource.ComposeNamespace
walkResources(rr, func(r resource.Interface) error {
nsR, ok := r.(*resource.ComposeNamespace)
if !ok {
return nil
}
if nsR.Identifiers().HasAny(r.Identifiers().StringSlice()...) {
nsRes = nsR
}
return nil
})
// Found it
if nsRes != nil {
return nsRes.Res, nil
}
// Go in the store
f := namespaceFilterFromGeneric(GenericFilter(ii))
return loadComposeNamespace(ctx, s, f)
}
func loadComposeNamespace(ctx context.Context, s store.Storer, f types.NamespaceFilter) (*types.Namespace, error) {
nss, f, err := store.SearchComposeNamespaces(ctx, s, f)
if err != nil {
return nil, err
}
if len(nss) > 0 {
return nss[0], nil
}
return nil, nil
}
pkg/envoy/tmp/compose_record.go
-156
View File
@@ -1,156 +0,0 @@
package tmp
import (
"context"
"errors"
"time"
"github.com/cortezaproject/corteza-server/compose/types"
"github.com/cortezaproject/corteza-server/pkg/envoy"
"github.com/cortezaproject/corteza-server/pkg/envoy/resource"
"github.com/cortezaproject/corteza-server/store"
)
type (
composeRecordPreproc struct {
es *encoderState
s store.Storer
}
)
func NewComposeRecordPreproc(is *encoderState, s store.Storer) *composeRecordPreproc {
return &composeRecordPreproc{
es: is,
s: s,
}
}
func (p *composeRecordPreproc) Process(ctx context.Context, state *envoy.ExecState) error {
res, is := state.Res.(*resource.ComposeRecord)
if !is {
return nil
}
// Get relate namespace
ns, err := findNamespace(ctx, p.s, state.ParentResources, res.NsRef.Identifiers)
if err != nil {
return err
}
if ns == nil {
return errors.New("@todo couldn't resolve namespace")
}
p.es.Set(res, res.NsRef.ResourceType, ns.ID, res.NsRef.Identifiers.StringSlice()...)
// Get relate namespace
mod, err := findModule(ctx, p.s, state.ParentResources, res.ModRef.Identifiers)
if err != nil {
return err
}
if mod == nil {
return errors.New("@todo couldn't resolve module")
}
p.es.Set(res, res.ModRef.ResourceType, mod.ID, res.ModRef.Identifiers.StringSlice()...)
// @todo existing records
//
// Hookup with labels to determine existing records
ff, err := loadComposeModuleFields(ctx, p.s, mod)
if err != nil {
return err
}
res.ModFields = ff
for _, f := range ff {
switch f.Kind {
case "Record":
refM := f.Options.String("module")
if refM != "" && refM != "0" {
// Make a reference with that module's records
res.AddRef(resource.COMPOSE_RECORD_RESOURCE_TYPE, refM)
}
}
}
return nil
}
func encodeComposeRecord(ctx context.Context, ectx *encodingContext, s store.Storer, state resRefs, res *resource.ComposeRecord) (resRefs, error) {
var err error
rState := make(resRefs)
// Namespace...
nsID := uint64(0)
for _, v := range state[resource.COMPOSE_NAMESPACE_RESOURCE_TYPE] {
nsID = v
break
}
// Module...
modID := uint64(0)
for _, v := range state[resource.COMPOSE_MODULE_RESOURCE_TYPE] {
modID = v
break
}
mod := &types.Module{
NamespaceID: nsID,
ID: modID,
Fields: res.ModFields,
}
return rState, res.Walker(func(r *resource.ComposeRecordRaw) error {
rec := &types.Record{
NamespaceID: nsID,
ModuleID: modID,
}
rec.ID = state[res.ResourceType()][r.ID]
if rec.ID <= 0 {
rec.ID = nextID()
}
rState.Set(resource.COMPOSE_RECORD_RESOURCE_TYPE, rec.ID, r.ID)
for k, v := range r.SysValues {
if v == "" {
continue
}
switch k {
case "createdAt":
// @todo set time
rec.CreatedAt = time.Now()
case "updatedAt":
// @todo set time
rec.UpdatedAt = nil
case "deletedAt":
// @todo set time
rec.DeletedAt = nil
}
}
rvs := make(types.RecordValueSet, 0, len(r.Values))
for k, v := range r.Values {
rv := &types.RecordValue{
RecordID: rec.ID,
Name: k,
Value: v,
Updated: true,
}
rvs = append(rvs, rv)
}
rec.Values = rvSanitizer.Run(mod, rvs)
if !ectx.partial && !ectx.exists {
err = store.CreateComposeRecord(ctx, s, mod, rec)
if err != nil {
return err
}
}
return nil
})
}
pkg/envoy/tmp/encoder.go
-85
View File
@@ -1,85 +0,0 @@
package tmp
import (
"context"
"github.com/cortezaproject/corteza-server/compose/service/values"
"github.com/cortezaproject/corteza-server/pkg/envoy"
"github.com/cortezaproject/corteza-server/pkg/envoy/resource"
"github.com/cortezaproject/corteza-server/store"
)
type (
storeEncoder struct {
s store.Storer
es *encoderState
}
encodingContext struct {
exists bool
partial bool
}
)
var (
rvSanitizer = values.Sanitizer()
rvValidator = values.Validator()
)
// NewStoreEncoder initializes and returns a fresh store encoder
//
// @todo add support for merge options (skip, overwrite, leftMerge, rightMerge)
func NewStoreEncoder(s store.Storer, es *encoderState) envoy.Encoder {
if es == nil {
es = NewEncoderState()
}
return &storeEncoder{
s: s,
es: es,
}
}
// Encode encodes the given resource
//
// @todo improve the transaction with channels
func (se *storeEncoder) Encode(ctx context.Context, ee ...*envoy.ExecState) error {
return store.Tx(ctx, se.s, func(ctx context.Context, s store.Storer) (err error) {
var rState resRefs
var state resRefs
for _, e := range ee {
state = se.es.Get(e.Res)
ectx := &encodingContext{
exists: se.es.Exists(e.Res),
partial: e.Conflicting,
}
switch res := e.Res.(type) {
case *resource.ComposeNamespace:
rState, err = encodeComposeNamespace(ctx, ectx, s, state, res)
case *resource.ComposeModule:
rState, err = encodeComposeModule(ctx, ectx, s, state, res)
case *resource.ComposeRecord:
rState, err = encodeComposeRecord(ctx, ectx, s, state, res)
}
if err != nil {
return err
}
for _, dr := range e.DepResources {
se.es.Merge(dr, rState)
}
// @todo this is only relevant for resources conflicting with themselves
if e.Conflicting {
se.es.Merge(e.Res, rState)
}
}
return nil
})
}
pkg/envoy/tmp/encoder_state.go
-107
View File
@@ -1,107 +0,0 @@
package tmp
import "github.com/cortezaproject/corteza-server/pkg/envoy/resource"
type (
encoderState struct {
// Maps the state for each separate resource
state map[resource.Interface]resRefs
// Lets us keep track of existing resources
// @todo how will we deal with CompseRecord?
existing map[resource.Interface]bool
}
// ref: internalID
ref map[string]uint64
// resourceType: ref
resRefs map[string]ref
)
// NewEncoderState initializes and returns an empty encoder state
func NewEncoderState() *encoderState {
return &encoderState{
state: make(map[resource.Interface]resRefs),
existing: make(map[resource.Interface]bool),
}
}
// Get returns the state for the given resource
func (es *encoderState) Get(res resource.Interface) resRefs {
return es.state[res]
}
// Set sets the encoding state for the given resource
func (es *encoderState) Set(res resource.Interface, resType string, id uint64, refs ...string) {
if es.state[res] == nil {
es.state[res] = make(resRefs)
}
es.state[res].Set(resType, id, refs...)
}
// Merge merges the encoding state with another state
func (es *encoderState) Merge(res resource.Interface, refs resRefs) {
if refs == nil {
return
}
if es.state[res] == nil {
es.state[res] = make(resRefs)
}
es.state[res].Merge(refs)
}
// Set sets refs for a given resource
func (r resRefs) Set(res string, id uint64, refs ...string) {
if r[res] == nil {
r[res] = make(ref)
}
r[res].Set(id, refs...)
}
// Merge merges the two states
func (r resRefs) Merge(state resRefs) {
for res, refs := range state {
if r[res] == nil {
r[res] = make(ref)
}
for lID, iID := range refs {
r[res][lID] = iID
}
}
}
// Get returns an internalID based on the passed interface.
//
// If not found, it returns a 0
func (r resRefs) Get(res resource.Interface) uint64 {
ref := r[res.ResourceType()]
if ref == nil {
return 0
}
for i := range res.Identifiers() {
if ref[i] > 0 {
return ref[i]
}
}
return 0
}
// Set sets provided ref: ID mappings
func (r ref) Set(id uint64, refs ...string) {
for _, ref := range refs {
r[ref] = id
}
}
func (es *encoderState) Exists(res resource.Interface) bool {
return es.existing[res]
}
func (es *encoderState) SetExists(res resource.Interface) {
es.existing[res] = true
}
pkg/envoy/tmp/preproc_util.go
-15
View File
@@ -1,15 +0,0 @@
package tmp
import (
"github.com/cortezaproject/corteza-server/pkg/envoy"
"github.com/cortezaproject/corteza-server/store"
)
func CollectPreproc(is *encoderState, s store.Storer) []envoy.Processor {
return []envoy.Processor{
NewComposeModule(is, s),
NewComposeNamespacePreproc(is, s),
NewComposeRecordPreproc(is, s),
// ...
}
}
pkg/envoy/tmp/util.go
-60
View File
@@ -1,60 +0,0 @@
package tmp
import (
"regexp"
"strconv"
"github.com/cortezaproject/corteza-server/pkg/envoy/resource"
"github.com/cortezaproject/corteza-server/pkg/id"
)
type (
genericFilter struct {
ID uint64
Ref string
Name string
}
)
var (
refy = regexp.MustCompile(`^[1-9](\d*)$`)
handy = regexp.MustCompile(`^[A-Za-z][0-9A-Za-z_\-.]*[A-Za-z0-9]$`)
// wrapper around nextID that will aid service testing
nextID = func() uint64 {
return id.Next()
}
)
func GenericFilter(ii resource.Identifiers) genericFilter {
f := genericFilter{}
for i := range ii {
if i == "" {
continue
}
if refy.MatchString(i) {
id, err := strconv.ParseUint(i, 10, 64)
if err != nil {
continue
}
f.ID = id
} else if handy.MatchString(i) {
f.Ref = i
} else {
f.Name = i
}
}
return f
}
func walkResources(rr []resource.Interface, f func(r resource.Interface) error) (err error) {
for _, r := range rr {
err = f(r)
if err != nil {
return
}
}
return nil
}